| """Versioned v4 image profile over the exact reviewed batch06 candidate API. |
| |
| No baseline execution, gold selection, score writes or publication. PNPM requires |
| an externally SHA-bound completed v4 formal receipt before input preparation or |
| candidate dispatch. Import/help/check-only never create outputs or use Docker. |
| """ |
| import argparse |
| import collections |
| import copy |
| import hashlib |
| import importlib.util |
| import json |
| from pathlib import Path |
| import sys |
|
|
| HERE=Path(__file__).resolve().parent |
| PARENT='evaluate_candidate_batch06_v1.py';PARENT_SHA='4c0ba175d2d0f6af6f409ec90853f9acb4c52d8307d1b94552d93958dbf507fc' |
| PARSER='batch06_candidate_case_reports_v1.py';PARSER_SHA='9d42cd5aa901366cacea886560cb9487ea3d912c5ed72001144a216258b7999d' |
| IID='buildpkg-pnpm-11330';OWNER='native-candidate-pnpm-v4-a03' |
| DIGEST='sha256:f35465cc119d326935b3bf47aad741c84f66acc8536eebe2bb891c381db66af0' |
| CONFIG='sha256:946c0bba28290b4a42687e6d542fe79580a3ebbd7b8b2db4ac2d2a38a22a9ef0' |
| BASELINE_ATTEMPT='agent-ready-v4-mem64-a01';BASELINE_STATE='RUNTIME_AND_AGENT_VALIDATED_PENDING_PUBLICATION' |
| BASELINE_CONTROLLER_SHA='f029b122705fdc73adc409146a37b8d4066e8d46fa939dd6b8f1d586d7ee4434' |
| BASELINE_PLAN_SHA='5f7ec90df531d8f3571d8654c20ca4409e45bcf4b3cd20b4abd28b7defa54a18' |
| BASELINE_REVIEWER_SHA='1d2f5f76a49546d95e4675c1a7e019a319437dc359f60ee129dff6b67bf35b34' |
| ORIGINAL_BASELINE_REVIEWER_SHA='a8ed487ee178641b6c5c602634404ae65bb2b809dfe1afb8d2ae82c9321a962d' |
| PUBLIC_RECEIPT_SHA='351432cd6213417a757cfb37c8e297182babd53f70b32789f9c113c6accd5cc8' |
| RECOVERY_REVIEWER='reparse_pnpm11330_native_inventory_v4_a02.py' |
| RECOVERY_KIND='PNPM_V4_NATIVE_UNICODE_INVENTORY_RECOVERY_V2' |
| RECOVERY_PLAN_KIND='PNPM_V4_NATIVE_UNICODE_INVENTORY_RECOVERY_PLAN_V2' |
| RECOVERY_ROOT=Path('/root/silinchen/silin_repo/crossrepo-work/docker171-build-20261015') |
|
|
|
|
| def _recovery_pin(relative,size,sha): |
| return {'path':str(RECOVERY_ROOT/relative),'bytes':size,'sha256':sha} |
|
|
|
|
| |
| |
| RECOVERY_REFERENCE_PINS={ |
| 'reviewed_controller':_recovery_pin('control/code/agent-readiness/pnpm11330-native-v4-mem64-overlay-reparse-a01/code/restore_validate_pnpm_v4_mem64_a01.py',43339,BASELINE_CONTROLLER_SHA), |
| 'reviewed_plan':_recovery_pin('control/agent-readiness/buildpkg-pnpm-11330/native-repair-v4-mem64-a01-plan.json',9128,BASELINE_PLAN_SHA), |
| 'original_review_tool':_recovery_pin('control/code/agent-readiness/pnpm11330-native-v4-mem64-overlay-reparse-a01/code/finalize_pnpm_v4_mem64_a01.py',9483,ORIGINAL_BASELINE_REVIEWER_SHA), |
| 'review_tool':_recovery_pin('control/code/agent-readiness/pnpm11330-native-inventory-recovery-a02/code/reparse_pnpm11330_native_inventory_v4_a02.py',53254,BASELINE_REVIEWER_SHA), |
| 'original_controller_error':_recovery_pin('control/agent-readiness/buildpkg-pnpm-11330/recovery-validation-agent-ready-v4-mem64-a01.json',22744,'7a0ad37a6c16dee74378f926c8146ba10069b159b00a679b435a082628a610c8'), |
| 'native_status':_recovery_pin('validation/buildpkg-pnpm-11330/agent-ready-v4-mem64-a01/status.json',13595,'721fe8d705c42aa314fe87beccf454b7473be26ff27a93399da1bef2a5fe0751'), |
| 'merkle_proof':_recovery_pin('control/agent-readiness/buildpkg-pnpm-11330/native-terminal-source-review-diagnostic-a01/base-commit-unicode-merkle-proof.json',13509,'4bec9c0a7f08cb6326c2d659ca70f6b492b3ef93fbc164d06b3d1592e8d2477c'), |
| 'source_difference':_recovery_pin('control/agent-readiness/buildpkg-pnpm-11330/native-terminal-source-review-diagnostic-a01/inventory-difference.json',3076,'36900b2b4ffe2e0ed5971d74396758169de8b8cc39ea9781b92089c056fa76d2'), |
| 'lifecycle_output_proof':_recovery_pin('control/agent-readiness/buildpkg-pnpm-11330/native-inventory-recovery-a02/lifecycle-output-proof.json',10276,'dbb667c85e863c785ebf3c22bf9fdc4fde00a38d5a0319aeda5eb3dd11d31d48'), |
| 'prior_review_tool':_recovery_pin('control/code/agent-readiness/pnpm11330-native-inventory-recovery-a01/code/reparse_pnpm11330_native_inventory_v4_a01.py',31855,'75a6a012fde84e33ccf3ce0b257e07a610512d385045e0920bb05f0f426e55b3'), |
| 'prior_supplement_plan':_recovery_pin('control/agent-readiness/buildpkg-pnpm-11330/native-inventory-recovery-a01/supplement-plan.json',2884,'868fab52ed4af1b0e8025a5046b4d52babd59b78a69fc200a9c8f04704e4a5f5'), |
| 'prior_review_result':_recovery_pin('control/agent-readiness/buildpkg-pnpm-11330/native-inventory-recovery-a01/check-only-a01-result.json',3349,'35df4a1dcef540a59dc5ef298478856a0deb1d12512fbf7cc22d79ff3b37157f'), |
| 'supplement_plan':_recovery_pin('control/agent-readiness/buildpkg-pnpm-11330/native-inventory-recovery-a02/supplement-plan.json',4162,'e6d56cdcd5b9145394f81fc8e424d8fe74ef3a31864a8634cef72af868d21261'), |
| } |
| LIFECYCLE_PREDICATE_PROVENANCE={ |
| 'original_source_sha256':'3f2d553028bc979c996c6f47a2b69e45156c995030446cb72459dcbc2e920274', |
| 'original_function_source_sha256':'73482c44c11dde511be64fa784025e68a163a87a600130f37f33f67f7ed1ece4', |
| 'adapted_function_ast_sha256':'077b2dba00e20d6ab756191d6bcad078ceac48e6170621467066cfc210125742', |
| 'transforms':{'memory_literal_24_to_64':1,'final_stdout_predicate':1}, |
| 'normal_stdout_predicate':'stdout.read_text().strip() == exact_owned_name', |
| 'additional_stop_stdout_exact':'Flag --time has been deprecated, use --timeout instead\n<exact_owned_name>\n', |
| 'original_checks_preserved':True,'raw_normalized_or_changed':False, |
| } |
|
|
|
|
| def require(ok,message): |
| if not ok:raise ValueError(message) |
|
|
|
|
| def digest(path): |
| value=hashlib.sha256() |
| with Path(path).open('rb')as stream: |
| for block in iter(lambda:stream.read(1024*1024),b''):value.update(block) |
| return value.hexdigest() |
|
|
|
|
| def regular(path): |
| path=Path(path).absolute();require(path==path.resolve()and path.is_file()and not path.is_symlink(),'Missing/linked versioned input: '+str(path));return path |
|
|
|
|
| def ref(path): |
| path=regular(path);return {'path':str(path),'bytes':path.stat().st_size,'sha256':digest(path)} |
|
|
|
|
| def bound(path,sha): |
| path=regular(path);require(digest(path)==sha,'Pinned source/evidence SHA differs: '+str(path));return path |
|
|
|
|
| def source_module(name,path): |
| """Compile actual source bytes; a timestamp-matched .pyc is never consulted.""" |
| path=regular(path);spec=importlib.util.spec_from_file_location(name,path);module=importlib.util.module_from_spec(spec) |
| exec(compile(path.read_bytes(),str(path),'exec'),module.__dict__);return module |
|
|
|
|
| def load_adapter(parent=HERE/PARENT): |
| parent=bound(parent,PARENT_SHA);parser=bound(parent.with_name(PARSER),PARSER_SHA) |
| previous=sys.modules.get('batch06_candidate_case_reports_v1');old_bytecode=sys.dont_write_bytecode |
| try: |
| sys.dont_write_bytecode=True;sys.modules['batch06_candidate_case_reports_v1']=source_module('_pnpm_v4_exact_parser',parser) |
| module=source_module('_pnpm_v4_exact_candidate_parent',parent) |
| finally: |
| sys.dont_write_bytecode=old_bytecode |
| if previous is None:sys.modules.pop('batch06_candidate_case_reports_v1',None) |
| else:sys.modules['batch06_candidate_case_reports_v1']=previous |
| module.PROFILES=copy.deepcopy(module.PROFILES) |
| module.PROFILES[IID].update(registry_digest=DIGEST,config_digest=CONFIG) |
| module.OWNER=OWNER |
| |
| |
| module.import_file=source_module |
| return module |
|
|
|
|
| _PUBLIC_ADAPTER=load_adapter() |
| PROFILES=copy.deepcopy(_PUBLIC_ADAPTER.PROFILES) |
| DEFAULT_SUPPORT=_PUBLIC_ADAPTER.DEFAULT_SUPPORT |
|
|
|
|
| def __getattr__(name): |
| """Keep the original parser/patch/classification/support read API available.""" |
| return getattr(_PUBLIC_ADAPTER,name) |
|
|
|
|
| class PendingBaseline(ValueError): |
| def __init__(self,detail): |
| self.detail={'state':'PENDING_MATCHING_PNPM_V4_BASELINE','no_dispatch':True,'runtime_validation':'NOT_RUN',**detail} |
| super().__init__(self.detail['state']) |
|
|
|
|
| class BaselinePaths: |
| """Explicit original-directory locator; it never rewrites evidence bytes.""" |
| def __init__(self,path,module): |
| self.locator=ref(path)if path is not None else None;self.members={};self.module=module |
| if path is not None: |
| for original,target in module.read_json(path).items(): |
| require(isinstance(original,str)and Path(original).is_absolute()and '..'not in Path(original).parts |
| and str(Path(original))==original and isinstance(target,str)and target,'Invalid baseline locator member') |
| supplied=Path(target);require('..'not in supplied.parts,'Escaping baseline locator target') |
| resolved=supplied if supplied.is_absolute()else Path(path).resolve().parent/supplied |
| require(resolved==resolved.resolve(),'Linked baseline locator target');self.members[Path(original)]=resolved |
| def resolve(self,original): |
| original=Path(original);require(original.is_absolute()and '..'not in original.parts,'Invalid original baseline path') |
| matches=[source for source in self.members if original.is_relative_to(source)] |
| if not matches:return original |
| source=max(matches,key=lambda item:len(item.parts));return self.members[source]/original.relative_to(source) |
|
|
|
|
| def load_recovery_reviewer(path=HERE/RECOVERY_REVIEWER): |
| """Load only the approved pure proof API from checked actual source bytes.""" |
| path=bound(path,BASELINE_REVIEWER_SHA) |
| require(path.name==RECOVERY_REVIEWER,'Recovery reviewer source name differs') |
| previous=sys.dont_write_bytecode |
| try: |
| sys.dont_write_bytecode=True |
| return source_module('_pnpm_v4_exact_recovery_proofs',path) |
| finally:sys.dont_write_bytecode=previous |
|
|
|
|
| def same_json(left,right): |
| """Exact JSON types keep bool/int lookalikes out of new provenance.""" |
| if type(left)is not type(right):return False |
| if isinstance(left,dict):return set(left)==set(right)and all(same_json(left[key],right[key])for key in left) |
| if isinstance(left,list):return len(left)==len(right)and all(same_json(a,b)for a,b in zip(left,right)) |
| return left==right |
|
|
|
|
| def operator_sources(module,support_dir): |
| """The original twelve source files plus the approved pure recovery API.""" |
| values={Path(__file__).name:ref(Path(__file__).resolve()),PARENT:ref(bound(module.__file__,PARENT_SHA)), |
| PARSER:ref(bound(Path(module.__file__).with_name(PARSER),PARSER_SHA)), |
| RECOVERY_REVIEWER:ref(bound(HERE/RECOVERY_REVIEWER,BASELINE_REVIEWER_SHA))} |
| values.update({name:ref(bound(Path(support_dir)/name,expected))for name,expected in module.SUPPORT_SHA256.items()}) |
| require(len(values)==13,'Candidate operator must retain all thirteen checked source files') |
| return values |
|
|
|
|
| def verify_recovery_provenance(receipt,module,locator,referenced): |
| """Verify the exact V2 correction over retained small files only. |
| |
| ``referenced`` is baseline_raw's existing retained-reference reader. It |
| resolves every new file through the explicit locator and adds it to the |
| same returned closure/end-rehash as the original native RAW. Neither the |
| full collector nor cold OCI evidence is called or opened here. |
| """ |
| pins=RECOVERY_REFERENCE_PINS;fields=set(pins)-{'supplement_plan'} |
| require(type(receipt.get('schema_version'))is int and receipt['schema_version']==1 |
| and receipt.get('kind')==RECOVERY_KIND and receipt.get('derived')is True,'Baseline is not the exact derived V2 review') |
| provenance=receipt.get('review_provenance') |
| expected_provenance={'kind':RECOVERY_KIND,'derived':True,'original_controller_state':'RECOVERY_OR_VALIDATION_ERROR', |
| **pins,'lifecycle_predicate_derivation':LIFECYCLE_PREDICATE_PROVENANCE} |
| require(same_json(provenance,expected_provenance),'Recovery provenance or exact pinned reference differs') |
| require(all(type(receipt.get(key))is int and receipt[key]==0 for key in ('native_commands_executed_by_review','native_commands_repeated')) |
| and receipt.get('old_failed_baseline_reused')is False and receipt.get('cleanup_performed_by_review')is False, |
| 'Recovery review execution history differs') |
| require(same_json(receipt.get('controller'),pins['original_controller_error'])and same_json(receipt.get('native_status'),pins['native_status']) |
| and all(same_json(receipt.get(key),pins[key])for key in ('reviewed_controller','reviewed_plan','review_tool')), |
| 'Recovery final/original terminal references differ') |
| files={key:referenced(pins[key])for key in sorted(pins)} |
| core=load_recovery_reviewer(files['review_tool']) |
| plan=module.read_json(files['supplement_plan']) |
| require(isinstance(plan,dict)and set(plan)=={'schema_version','kind','instance_id','attempt','image_digest','config_digest',*fields} |
| and type(plan['schema_version'])is int and plan['schema_version']==1 and plan['kind']==RECOVERY_PLAN_KIND |
| and plan['instance_id']==IID and plan['attempt']==BASELINE_ATTEMPT and plan['image_digest']==DIGEST and plan['config_digest']==CONFIG |
| and all(same_json(plan[key],pins[key])for key in fields),'Exact V2 supplement plan identity or twelve-reference closure differs') |
| original_plan=module.read_json(files['reviewed_plan']) |
| require(same_json(original_plan.get('finalizer'),pins['original_review_tool'])and same_json(original_plan.get('controller'),pins['reviewed_controller']), |
| 'Original execution plan/finalizer binding differs') |
| prior=module.read_json(files['prior_supplement_plan']);first_fields=fields-{'lifecycle_output_proof','prior_review_tool','prior_supplement_plan','prior_review_result'} |
| require(isinstance(prior,dict)and set(prior)=={'schema_version','kind','instance_id','attempt','image_digest','config_digest',*first_fields} |
| and type(prior['schema_version'])is int and prior['schema_version']==1 |
| and prior['kind']=='PNPM_V4_NATIVE_UNICODE_INVENTORY_RECOVERY_PLAN_V1' |
| and all(prior[key]==plan[key]for key in ('instance_id','attempt','image_digest','config_digest')) |
| and same_json(prior['review_tool'],pins['prior_review_tool'])and all(same_json(prior[key],pins[key])for key in first_fields-{'review_tool'}), |
| 'Prior failed supplement plan original bindings differ') |
| prior_result=module.read_json(files['prior_review_result']) |
| require(prior_result.get('schema')=='crossswe-root-completed-native-review-execution-v1' |
| and prior_result.get('state')=='READ_ONLY_REVIEW_ERROR'and type(prior_result.get('returncode'))is int and prior_result['returncode']==1 |
| and prior_result.get('ledger_append')is False and type(prior_result.get('native_commands_repeated'))is int and prior_result['native_commands_repeated']==0 |
| and all(prior_result.get(key)is True for key in ('native_status_unchanged','original_error_unchanged','repair_ledger_unchanged')) |
| and isinstance(prior_result.get('terminal_error'),str) |
| and prior_result['terminal_error'].endswith('.ReviewError: Native lifecycle stdout differs: stop\n'), |
| 'Actual prior failed review history differs') |
| controller=module.read_json(files['original_controller_error']);native=module.read_json(files['native_status']) |
| core.verify_terminal_statuses(controller,native,pins['reviewed_plan']) |
| require(controller['validation_path']==pins['native_status']['path']and controller['validation_sha256']==pins['native_status']['sha256'], |
| 'Original controller/native reference scope differs') |
|
|
| merkle=module.read_json(files['merkle_proof']);objects={} |
| for row in merkle['objects']: |
| oid=row['git_oid'];value=row['file'] |
| require(isinstance(oid,str)and oid not in objects |
| and Path(value['path'])==Path(pins['merkle_proof']['path']).parent/'base-git-objects'/(oid+'.raw'), |
| 'Git proof object escaped its fixed retained namespace') |
| objects[oid]=referenced(value).read_bytes() |
| git=core.verify_merkle_payload(merkle,objects) |
| require(git['objects_verified']==15,'Complete fifteen typed Git object proof missing') |
| difference=module.read_json(files['source_difference']) |
| expected_extra=[{'path':name,'value':value['sha256']}for name,value in core.UNICODE_FILES.items()] |
| require(difference.get('schema')=='crossswe-pnpm-v4-readonly-source-fingerprint-difference-v1' |
| and difference.get('source_changed')is False and type(difference.get('tests_repeated'))is int and difference['tests_repeated']==0 |
| and isinstance(difference.get('worlds'),list)and [row.get('world')for row in difference['worlds']]==list(core.WORLDS), |
| 'Source difference correction history differs') |
| for row in difference['worlds']: |
| require(type(row['cache_count'])is int and row['cache_count']==core.ORIGINAL_NODE_COUNT |
| and type(row['actual_count'])is int and row['actual_count']==core.ORIGINAL_NODE_COUNT+4 |
| and row['missing']==row['changed']==[]and row['extra']==expected_extra |
| and row['native_before_after_equal']is True and row['git_before_after_equal']is True, |
| 'Source difference is not exactly the four proven fixed UTF8 files') |
| expected_inventory={**git,'original_cache_proof':controller['cache_preflight'], |
| 'original_expected_counts':{world:core.ORIGINAL_NODE_COUNT for world in core.WORLDS}, |
| 'completed_expected_counts':{world:core.ORIGINAL_NODE_COUNT+4 for world in core.WORLDS}, |
| 'original_cache_proof_unchanged':True,'only_expected_maps_supplemented':True} |
| require(same_json(receipt.get('source_inventory_supplement'),expected_inventory) |
| and same_json(receipt.get('cache_preflight',{}).get('receipt'),controller['cache_preflight']), |
| 'Complete fixed inventory supplement or unchanged original cache proof differs') |
|
|
| lifecycle=module.read_json(files['lifecycle_output_proof']) |
| top=('native_status','original_controller_error','prior_review_result','prior_review_tool','prior_supplement_plan') |
| require(all(same_json(lifecycle.get(key),pins[key])for key in top),'Lifecycle proof/supplement original or prior reference differs') |
| references=[lifecycle[key]for key in top] |
| for world in lifecycle['worlds']: |
| references += [world['create_stdout'],world['final_inspect']] |
| references += [world[label][stream]for label in ('start','stop','remove')for stream in ('execution','stdout','stderr')] |
| raw={} |
| for value in references: |
| require(value['path']not in raw,'Duplicate lifecycle proof reference') |
| raw[value['path']]=referenced(value).read_bytes() |
| verified_lifecycle=core.verify_lifecycle_payload(lifecycle,raw) |
| require(len(verified_lifecycle['reference_refs'])==27,'Complete 27-reference lifecycle proof missing') |
| expected_lifecycle={'kind':'PNPM_V4_EXACT_STOP_STDOUT_COMPATIBILITY_V1','proof':pins['lifecycle_output_proof'], |
| **{key:pins[key]for key in ('prior_review_tool','prior_supplement_plan','prior_review_result')}, |
| 'worlds':verified_lifecycle['worlds'],'reference_refs':verified_lifecycle['reference_refs'], |
| 'predicate_derivation':LIFECYCLE_PREDICATE_PROVENANCE,'native_commands_repeated':0,'raw_files_changed':False, |
| 'original_lifecycle_checks_preserved':True} |
| require(same_json(receipt.get('lifecycle_output_compatibility'),expected_lifecycle),'Exact lifecycle correction/derivation proof differs') |
| return {'controller':controller,'native_original':Path(pins['native_status']['path']), |
| 'native_file':files['native_status'],'native':native,'review':{'kind':RECOVERY_KIND,'derived':True, |
| 'reviewer_source':ref(files['review_tool']),'references':copy.deepcopy(pins), |
| 'git_objects_verified':git['objects_verified'],'git_raw_object_bytes':git['raw_object_bytes'], |
| 'lifecycle_references_verified':len(verified_lifecycle['reference_refs']), |
| 'original_controller_state':controller['state'],'native_commands_executed':0}} |
|
|
|
|
| def baseline_raw(receipt,module,reports,locator): |
| """Reparse only eight native groups and their small SavedEvidence closure.""" |
| refs=receipt.get('retained_evidence') |
| if not isinstance(refs,list):raise PendingBaseline({'missing':['retained_native_raw_references']}) |
| retained={item['path']:item for item in refs};require(len(retained)==len(refs),'Duplicate retained baseline reference') |
| used={} |
| def member(original,expected_sha=None): |
| original=str(original) |
| if original not in retained:raise PendingBaseline({'missing':['actual_native_reference:'+original]}) |
| item=retained[original] |
| require(expected_sha is None or item['sha256']==expected_sha,'Retained native reference SHA contradicts its binding') |
| translated=locator.resolve(original) |
| if not translated.exists():raise PendingBaseline({'missing':['actual_native_file:'+original]}) |
| actual=bound(translated,item['sha256']);require(item['bytes']==actual.stat().st_size,'Retained native reference byte count differs') |
| used[original]={'original':item,'resolved':ref(actual)};return actual |
| def referenced(item): |
| if not isinstance(item,dict)or not item.get('path')or not item.get('sha256'):raise PendingBaseline({'missing':['actual_native_provenance_ref']}) |
| path=member(item['path'],item['sha256']);require('bytes'not in item or item['bytes']==path.stat().st_size,'Provenance reference byte count differs');return path |
| for key,expected in (('reviewed_controller',BASELINE_CONTROLLER_SHA),('reviewed_plan',BASELINE_PLAN_SHA),('review_tool',BASELINE_REVIEWER_SHA)): |
| require(receipt[key]['sha256']==expected,'Unapproved baseline reviewed source');referenced(receipt[key]) |
| recovery=verify_recovery_provenance(receipt,module,locator,referenced) |
| controller=recovery['controller'];native_original=recovery['native_original'] |
| require(tuple(native_original.parts[-4:])==('validation',IID,BASELINE_ATTEMPT,'status.json'),'Baseline native namespace differs') |
| native_file=member(native_original,controller['validation_sha256']);native=module.read_json(native_file) |
| require(native['state']=='LOCAL_VALIDATED'and native['instance_id']==IID and native['image']==DIGEST and native['attempt']==BASELINE_ATTEMPT |
| and native['issues']==[]and native.get('ended_utc')and not native.get('active')and native['effective_policy']=={'worlds':['all_buggy','all_fixed'],'repeat_count':1} |
| and native['contract_sha256']==module.PROFILES[IID]['contract_sha256'],'Actual native result is incomplete or mismatched') |
| require([(world['world'],world['repeat'])for world in native['worlds']]==[('all_buggy',1),('all_fixed',1)],'Actual native worlds differ') |
| original_root=native_original.parents[3];inputs=original_root/'control/inputs'/IID/'current' |
| task=module.read_json(member(inputs/'task.json',module.PROFILES[IID]['task_sha256'])) |
| relative=Path(task['evaluation']['path']);require(not relative.is_absolute()and '..'not in relative.parts,'Escaping baseline contract reference') |
| contract=module.read_json(member(inputs/relative,module.PROFILES[IID]['contract_sha256'])) |
| require(contract.get('network')=='none'and task['instance_id']==IID,'Actual baseline task/network differs') |
| commands={item['repository']:item for item in contract['commands']};require(set(commands)=={'pnpm','node'}and len(contract['commands'])==2,'Actual native command repository inventory differs') |
| reviewed=receipt['frozen_native_review'];groups=reviewed.get('commands') |
| if not isinstance(groups,list):raise PendingBaseline({'missing':['eight_actual_native_group_references']}) |
| indexed={(item['world'],item['repository'],item['kind']):item for item in groups} |
| expected={(world,repo,kind)for world in ('all_buggy','all_fixed')for repo in ('pnpm','node')for kind in ('pass_to_pass','fail_to_pass')} |
| require(len(groups)==len(indexed)==8 and set(indexed)==expected,'Actual eight-group reference inventory differs') |
| recorded={item['path']:item['sha256']for item in reviewed['all_recorded_commands']};actual_rows=[];original_saved=reports.SavedEvidence |
| for world in native['worlds']: |
| world_name=world['world'];original_cell=native_original.parent/world_name/'repeat-1';cell=locator.resolve(original_cell) |
| require(cell.is_dir()and cell==cell.resolve(),'Missing/linked exported native cell') |
| require(module.read_json(member(original_cell/'result.json'))==world and world['issues']==[]and world['container_image_id']==DIGEST,'Actual world result/image differs') |
| require(len(world['commands'])==4 and {(row['repository'],row['kind'])for row in world['commands']}=={(repo,kind)for repo in ('pnpm','node')for kind in ('pass_to_pass','fail_to_pass')},'Actual four-group world inventory differs') |
| class BoundSavedEvidence(original_saved): |
| def __init__(self,actual_cell): |
| require(Path(actual_cell)==cell,'Parser escaped actual native cell');super().__init__(actual_cell) |
| def file(self,relative): |
| actual=super().file(relative);require(member(original_cell/'native-artifacts'/relative)==regular(actual),'Exported artifact locator is incoherent');return actual |
| def source(self): |
| for name in ('source-files.json','source-files-after.json'):require(member(original_cell/name)==regular(cell/name),'Exported source locator is incoherent') |
| return super().source() |
| reports.SavedEvidence=BoundSavedEvidence |
| try: |
| for row in world['commands']: |
| repo,kind=row['repository'],row['kind'];proof=indexed[world_name,repo,kind];label=repo+'-'+kind;original_execution=original_cell/(label+'.execution.json') |
| require(proof['execution']['path']==str(original_execution)and recorded.get(str(original_execution))==proof['execution']['sha256'],'Native execution ref escaped its actual group') |
| execution=module.read_json(referenced(proof['execution']));frozen=commands[repo];env={**module.ENVIRONMENT,**frozen.get('environment',{})} |
| argv=['docker','exec','-w',frozen.get('test_cwd')or frozen['container_path']] |
| for key,value in env.items():argv+=['-e',key+'='+value] |
| name=('d171-'+IID+'-'+BASELINE_ATTEMPT+'-'+world_name).lower().replace('_','-');argv += [name,'bash','-lc',frozen[kind]] |
| require(execution['argv']==argv and row['command']==frozen[kind]and row['issues']==[]and type(execution['returncode'])is int |
| and execution['returncode']==row['returncode']and not execution.get('timed_out')and not execution.get('error'),'Actual native command/exit/error differs') |
| streams={} |
| for stream in ('stdout','stderr'): |
| sha=execution[stream+'_sha256'];require(proof[stream+'_sha256']==sha,'Group/command RAW SHA differs') |
| streams[stream]=member(original_cell/(label+'.'+stream+'.log'),sha).read_text() |
| cases,issues,metadata=reports.parse_report(IID,repo,kind,streams['stdout'],streams['stderr'],row['returncode'],cell) |
| require(not issues and cases and cases==row['cases']and metadata==row['report_metadata']and metadata['native_case_receipts_verified']==len(cases) |
| and row['passed']==sum(case['passed']for case in cases)and row['failed']==sum(not case['passed']for case in cases),'Actual frozen parser/case metadata differs') |
| require(proof['actual_cases']==proof['native_case_receipts_verified']==len(cases),'Reviewed group case count differs') |
| actual_rows += [{'world':world_name,'repeat':1,'repository':repo,'kind':kind,**case}for case in cases] |
| finally:reports.SavedEvidence=original_saved |
| require(actual_rows==reviewed['actual_case_rows'],'Final receipt case rows differ from actual native RAW reparse') |
| for original,entry in used.items():require(ref(bound(locator.resolve(original),entry['original']['sha256']))==entry['resolved'],'Native RAW changed during baseline reparse') |
| return {'native_status':{'original':retained[str(native_original)],'resolved':ref(native_file)},'native_groups_reparsed':8,'actual_cases_reparsed':50, |
| 'parser_sha256':module.SUPPORT_SHA256['reusable_support/batch06_case_reports.py'],'path_map':locator.locator, |
| 'verified_small_references':[used[key]for key in sorted(used)],'large_retained_objects_read':False,'recovery_provenance':recovery['review']} |
|
|
|
|
| def baseline_proof(path,sha,module,support_dir=DEFAULT_SUPPORT,path_map=None): |
| if path is None or sha is None:raise PendingBaseline({'missing':['baseline_receipt','baseline_receipt_sha256']}) |
| if not Path(path).exists():raise PendingBaseline({'missing':['actual_completed_baseline_receipt']}) |
| receipt=module.read_json(bound(path,sha)) |
| if isinstance(receipt,dict)and receipt.get('schema')=='crossswe-frozen-native-behavior-case-review-v1'and receipt.get('state')=='BEHAVIOR_CASES_VERIFIED_FULL_LIFECYCLE_REVIEW_PENDING': |
| require(same_json(receipt.get('native_status'),RECOVERY_REFERENCE_PINS['native_status']) |
| and same_json(receipt.get('original_controller_error'),RECOVERY_REFERENCE_PINS['original_controller_error']) |
| and receipt.get('full_delivery')is False,'Partial baseline original terminal bindings differ') |
| raise PendingBaseline({'baseline_state':receipt['state'],'missing':['completed_full_lifecycle_baseline_review']}) |
| require(isinstance(receipt,dict)and receipt.get('instance_id')==IID and receipt.get('registry_digest',receipt.get('image_digest'))==DIGEST |
| and receipt.get('config_digest',receipt.get('image_config_digest'))==CONFIG,'Baseline receipt has a nonmatching v4 identity') |
| if receipt['state']!=BASELINE_STATE:raise PendingBaseline({'baseline_state':receipt['state']}) |
| require(receipt['repair_identity']==BASELINE_ATTEMPT and receipt['new_formal_instances']==receipt['model_calls']==receipt['score_writes']==0 |
| and receipt['effective_policy']=={'worlds':['all_buggy','all_fixed'],'repeat_count':1,'network':'none'} |
| and receipt['reviewed_controller']['sha256']==BASELINE_CONTROLLER_SHA and receipt['reviewed_plan']['sha256']==BASELINE_PLAN_SHA |
| and receipt['review_tool']['sha256']==BASELINE_REVIEWER_SHA,'Baseline receipt is not the reviewed once-only v4 result') |
| require(all(receipt[key]==module.PROFILES[IID][key]for key in ('task_sha256','contract_sha256')),'Baseline frozen task/contract differs') |
| profile=receipt['resource_profile'];require(profile['cpus']==8 and profile['memory_bytes']==profile['memory_swap_bytes']==64*1024**3 |
| and profile['minimum_host_available_bytes']==80_000_000_000,'Baseline v4 resource profile differs') |
| public=receipt['public_tests'];require(public['image_requested']==DIGEST and public['receipt_sha256']==PUBLIC_RECEIPT_SHA |
| and public['status']=='AGENT_PUBLIC_TESTS_READY_WITH_REVIEW','Actual v4 public proof differs') |
| require(receipt['workspace_overlay']['state']=='SUCCESS_WITH_POSTPROCESS_CORRECTION' |
| and receipt['workspace_overlay']['reader']['sha256']=='183363d70b8781034fd03db104e27cfbe4f742854214c825f2c1b9c447705639','Actual corrected overlay proof differs') |
| native=receipt['frozen_native_review'];require(native['actual_cases_per_world']=={'all_buggy':25,'all_fixed':25},'Baseline full25 cases/world missing') |
| inventories=module.load_support(support_dir).reports.INVENTORIES[IID] |
| expected=collections.Counter((world,1,repo,kind,case)for world in ('all_buggy','all_fixed')for repo in ('pnpm','node') |
| for kind,phase in (('pass_to_pass','p2p'),('fail_to_pass','f2p'))for case in inventories[repo][phase]) |
| rows=native['actual_case_rows'];require(collections.Counter((row['world'],row['repeat'],row['repository'],row['kind'],row['id'])for row in rows)==expected |
| and all(type(row['passed'])is bool for row in rows),'Baseline complete frozen case identities differ') |
| totals={} |
| for world in ('all_buggy','all_fixed'): |
| totals[world]={} |
| for kind,phase in (('pass_to_pass','p2p'),('fail_to_pass','f2p')): |
| cases=[row for row in rows if row['world']==world and row['kind']==kind];passed=sum(row['passed']for row in cases);failed=len(cases)-passed |
| require(not failed if phase=='p2p'or world=='all_fixed'else failed>0,'Baseline frozen endpoint outcomes differ') |
| totals[world][phase]={'passed':passed,'failed':failed} |
| require(native['totals']==totals,'Baseline actual case totals disagree') |
| small=baseline_raw(receipt,module,module.load_support(support_dir).reports,BaselinePaths(path_map,module)) |
| return {'receipt':ref(path),'state':receipt['state'],'repair_identity':receipt['repair_identity'],'image_digest':DIGEST,'config_digest':CONFIG, |
| 'actual_cases_per_world':native['actual_cases_per_world'],'small_raw_review':small,'basis':'externally SHA-bound final receipt plus original frozen parser over actual native RAW; no baseline commands executed'} |
|
|
|
|
| def prepare_inputs(bench_root,iid,mapping_file,output_dir,support_dir=DEFAULT_SUPPORT,evaluator_resource_dir=None,*,baseline_receipt=None,baseline_receipt_sha256=None,baseline_path_map=None): |
| module=load_adapter();require(iid in module.PROFILES,'Unsupported candidate instance') |
| proof=baseline_proof(baseline_receipt,baseline_receipt_sha256,module,support_dir,baseline_path_map)if iid==IID else None |
| prepared=module.prepare_inputs(bench_root,iid,mapping_file,output_dir,support_dir,evaluator_resource_dir) |
| binding={'wrapper':ref(Path(__file__).resolve()),'parent':ref(Path(module.__file__)),'parser':ref(Path(module.__file__).with_name(PARSER)), |
| 'namespace':OWNER,'profile':copy.deepcopy(module.PROFILES[iid]),'baseline':proof,'operator_sources':operator_sources(module,support_dir)} |
| prepared['input_provenance']={**prepared['input_provenance'],'versioned_adapter':binding} |
| prepared['_versioned_module']=module;prepared['_versioned_support_dir']=Path(support_dir);prepared['_baseline_path_map']=baseline_path_map |
| return prepared |
|
|
|
|
| def evaluate(prepared,runner=None): |
| module=prepared['_versioned_module'];binding=prepared['input_provenance']['versioned_adapter'];iid=prepared['iid'] |
| bound(module.__file__,PARENT_SHA);bound(Path(module.__file__).with_name(PARSER),PARSER_SHA) |
| require(binding['wrapper']==ref(Path(__file__).resolve())and binding['namespace']==module.OWNER==OWNER and module.PROFILES[iid]==binding['profile'] |
| and binding['profile']==load_adapter().PROFILES[iid]and all(prepared['image'][key]==value for key,value in binding['profile'].items()),'Prepared versioned profile/source binding differs') |
| require(same_json(binding.get('operator_sources'),operator_sources(module,prepared['_versioned_support_dir'])),'Prepared thirteen-file operator source closure differs') |
| if iid==IID: |
| proof=binding['baseline'];require(proof is not None,'Completed v4 baseline proof missing') |
| require(baseline_proof(proof['receipt']['path'],proof['receipt']['sha256'],module,prepared['_versioned_support_dir'],prepared['_baseline_path_map'])==proof,'Completed baseline drift after preparation') |
| return module.evaluate(prepared,runner) |
|
|
|
|
| def main(argv=None): |
| parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--bench-root',type=Path,required=True);parser.add_argument('--support-dir',type=Path,default=DEFAULT_SUPPORT) |
| parser.add_argument('--instance-id',required=True,choices=sorted(PROFILES));parser.add_argument('--candidate-patches',type=Path,required=True);parser.add_argument('--output-dir',type=Path,required=True) |
| parser.add_argument('--evaluator-resource-dir',type=Path);parser.add_argument('--baseline-receipt',type=Path);parser.add_argument('--baseline-receipt-sha256');parser.add_argument('--baseline-path-map',type=Path);parser.add_argument('--check-only',action='store_true');args=parser.parse_args(argv) |
| try: |
| prepared=prepare_inputs(args.bench_root,args.instance_id,args.candidate_patches,args.output_dir,args.support_dir,args.evaluator_resource_dir, |
| baseline_receipt=args.baseline_receipt,baseline_receipt_sha256=args.baseline_receipt_sha256,baseline_path_map=args.baseline_path_map) |
| if args.check_only: |
| print(json.dumps({'instance_id':args.instance_id,'state':'INPUTS_VERIFIED','world':'candidate','image':prepared['image']['image_ref'],'patches':prepared['patches'], |
| 'evaluator_resources':prepared['resource'],'versioned_adapter':prepared['input_provenance']['versioned_adapter'],'model_calls':0,'score_writes':0,'runtime_validation':'NOT_RUN'}));return 0 |
| status=evaluate(prepared);print(json.dumps({'instance_id':args.instance_id,'state':status['state'],'resolved':status.get('resolved',False),'receipt':str(prepared['out']/'status.json'), |
| 'receipt_persisted':status.get('receipt_persisted',False),'issues':status['issues'],'logging_errors':status['logging_errors']}));return 2 if status['state']=='EVALUATION_ERROR'else 0 |
| except PendingBaseline as error:print(json.dumps(error.detail,sort_keys=True));return 2 |
| except(ValueError,OSError,KeyError,TypeError)as error:print(type(error).__name__+': '+str(error),file=sys.stderr);return 2 |
|
|
|
|
| if __name__=='__main__':raise SystemExit(main()) |
|
|
