1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
| import fs from 'node:fs';
| import path from 'node:path';
| import os from 'node:os';
| import crypto from 'node:crypto';
| import {pathToFileURL} from 'node:url';
| import * as base from './detail_strengthening_p0_open_gap_evidence_acquisition_runtime_20260731.mjs';
| import * as prior from './detail_strengthening_p0_primary_source_discovery_runtime_repair001_20260730.mjs';
| import {parseAuthorityCsv,serializeCsv,serializeManifestDataRows,validateAppendStableManifest} from './artifact_manifest_append_stable_parser_repair001_20260730.mjs';
|
| export const ROOT=process.cwd(),CASE_ID=base.CASE_ID,BASE=base.BASE,AUDIT_REPORT=base.AUDIT_REPORT,MANIFEST=base.MANIFEST,ANOMALY_AUTHORITY=base.ANOMALY_AUTHORITY,ORIGINAL_TRIAGE_RUN=base.ORIGINAL_TRIAGE_RUN;
| export const DESIGN_ID='DESIGN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-REPAIR-001';
| export const DESIGN_RUN='RUN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-DESIGN-REPAIR-001';
| export const DESIGN_BATCH='BATCH-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-DESIGN-REPAIR-001';
| export const EXEC_RUN=base.EXEC_RUN,EXEC_BATCH=base.EXEC_BATCH;
| export const RELEASE_AUDIT='AUDIT-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-DESIGN-REPAIR001-REREVIEW-001';
| export const SOURCE_FAIL_AUDIT='AUDIT-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-DESIGN-REREVIEW-001';
| export const EXEC_TOKEN='EXECUTE_DETAIL_STRENGTHENING_P0_OPEN_GAP_EVIDENCE_ACQUISITION_REPAIR001';
| export const SCRIPT='dev/ana-dev/detail_strengthening_p0_open_gap_evidence_acquisition_runtime_repair001_20260731.mjs';
| export const TARGET_AUTHORITY=base.TARGET_AUTHORITY,GAP_AUTHORITY=base.GAP_AUTHORITY,NEXT_PLAN=base.NEXT_PLAN,DECISION=base.DECISION,MAP=base.MAP,QUERY_AUTHORITY=base.QUERY_AUTHORITY,SOURCE_POLICY=base.SOURCE_POLICY,METHOD_AUTHORITY=base.METHOD_AUTHORITY,PROTECTED_INVENTORY=base.PROTECTED_INVENTORY;
| export const CAPABILITY_EVIDENCE=`${BASE}/evidence/detail_strengthening_p0_open_gap_evidence_acquisition_method_capability_evidence_20260731.csv`;
| export const FORMAL_ENTRY_AUTHORITY=`${BASE}/evidence/detail_strengthening_p0_open_gap_evidence_acquisition_formal_design_entry_authority_repair001_20260731.csv`;
| export const CONTRACT=`${BASE}/evidence/detail_strengthening_p0_open_gap_evidence_acquisition_runtime_contract_repair001_20260731.csv`;
| export const SCHEMA=`${BASE}/evidence/detail_strengthening_p0_open_gap_evidence_acquisition_schema_repair001_20260731.csv`;
| export const EXEC_SET=`${BASE}/manifest/detail_strengthening_p0_open_gap_evidence_acquisition_execution_artifact_set_repair001_20260731.csv`;
| export const EXEC_BASELINE=base.EXEC_BASELINE,METHOD_PREFLIGHT=base.METHOD_PREFLIGHT,RAW_ARCHIVE=base.RAW_ARCHIVE,QUERY_LEDGER=base.QUERY_LEDGER,SUPPLEMENT_LEDGER=base.SUPPLEMENT_LEDGER,PROVENANCE_LEDGER=base.PROVENANCE_LEDGER,CANDIDATE_REGISTER=base.CANDIDATE_REGISTER,OCCURRENCE_DISPOSITION=base.OCCURRENCE_DISPOSITION,GAP_SUMMARY=base.GAP_SUMMARY,APPLICATION=base.APPLICATION,EXEC_REQUEST=base.EXEC_REQUEST,EXEC_VALIDATION=base.EXEC_VALIDATION;
| export const QUERY_COLUMNS=base.QUERY_COLUMNS,POLICY_COLUMNS=base.POLICY_COLUMNS,METHOD_COLUMNS=base.METHOD_COLUMNS,FORMAL_ENTRY_COLUMNS=base.FORMAL_ENTRY_COLUMNS,CONTRACT_COLUMNS=base.CONTRACT_COLUMNS,SCHEMA_COLUMNS=base.SCHEMA_COLUMNS,EXEC_SET_COLUMNS=base.EXEC_SET_COLUMNS,BASELINE_COLUMNS=base.BASELINE_COLUMNS,METHOD_PREFLIGHT_COLUMNS=base.METHOD_PREFLIGHT_COLUMNS,QUERY_LEDGER_COLUMNS=base.QUERY_LEDGER_COLUMNS,SUPPLEMENT_COLUMNS=base.SUPPLEMENT_COLUMNS,PROVENANCE_COLUMNS=base.PROVENANCE_COLUMNS,CANDIDATE_COLUMNS=base.CANDIDATE_COLUMNS,DISPOSITION_COLUMNS=base.DISPOSITION_COLUMNS,SUMMARY_COLUMNS=base.SUMMARY_COLUMNS,APPLICATION_COLUMNS=base.APPLICATION_COLUMNS,VALIDATION_COLUMNS=base.VALIDATION_COLUMNS,RAW_FIELDS=base.RAW_FIELDS,GAP_COLUMNS=base.GAP_COLUMNS;
| export const CAPABILITY_COLUMNS=['capability_id','method_id','tool_sequence','search_query_available','open_available','probe_source','task_mode','checked_at','status'];
| export const GENERATED=[EXEC_BASELINE,METHOD_PREFLIGHT,RAW_ARCHIVE,QUERY_LEDGER,SUPPLEMENT_LEDGER,PROVENANCE_LEDGER,CANDIDATE_REGISTER,OCCURRENCE_DISPOSITION,GAP_SUMMARY,APPLICATION,EXEC_REQUEST,EXEC_VALIDATION];
| const DISCOVERY_STAGE=[RAW_ARCHIVE,QUERY_LEDGER,SUPPLEMENT_LEDGER,PROVENANCE_LEDGER,CANDIDATE_REGISTER],DERIVED_STAGE=[OCCURRENCE_DISPOSITION,GAP_SUMMARY,APPLICATION,EXEC_REQUEST,EXEC_VALIDATION];
| const FROZEN_INPUTS=[SCRIPT,TARGET_AUTHORITY,GAP_AUTHORITY,NEXT_PLAN,DECISION,MAP,QUERY_AUTHORITY,SOURCE_POLICY,METHOD_AUTHORITY,CAPABILITY_EVIDENCE,FORMAL_ENTRY_AUTHORITY,CONTRACT,SCHEMA,EXEC_SET,ANOMALY_AUTHORITY];
| const abs=value=>path.join(ROOT,...value.split('/')),sha=value=>crypto.createHash('sha256').update(value).digest('hex'),normalize=value=>value.toString('utf8').replace(/^\uFEFF/,'').replace(/\r\n/g,'\n').replace(/\r/g,'\n');
| const lineCount=value=>{const text=normalize(value);return text.split('\n').length-(text.endsWith('\n')?1:0);};
| const readCsv=file=>{const parsed=parseAuthorityCsv(normalize(fs.readFileSync(abs(file))));if(parsed.errors.length)throw new Error(`CSV:${file}:${parsed.errors.join('|')}`);return parsed;};
| const identity=file=>{const buffer=fs.readFileSync(abs(file)),stat=fs.statSync(abs(file));return{rows:file.endsWith('.csv')?readCsv(file).rows.length:lineCount(buffer),bytes:buffer.length,sha256:sha(buffer),mtime:new Date(Math.trunc(stat.mtimeMs)).toISOString(),mtimeMs:Math.trunc(stat.mtimeMs)};};
| const exactColumns=(parsed,columns,code)=>parsed.header.join('|')===columns.join('|')?[]:[`${code}_COLUMNS`];
| const equalRows=(actual,expected,columns,code)=>{const errors=[];if(actual.length!==expected.length)return[`${code}_COUNT:${actual.length}:${expected.length}`];for(let i=0;i<expected.length;i++)for(const column of columns)if(String(actual[i]?.[column]??'')!==String(expected[i]?.[column]??'')){errors.push(`${code}_FIELD:${i+1}:${column}`);break;}return errors;};
| const iso=value=>/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(String(value))&&Number.isFinite(Date.parse(value));
| const nativeAdapter={read:(file)=>fs.readFileSync(file),write:(file,data)=>{fs.mkdirSync(path.dirname(file),{recursive:true});fs.writeFileSync(file,data);},remove:(file)=>{if(fs.existsSync(file))fs.rmSync(file);},exists:(file)=>fs.existsSync(file),stat:(file)=>fs.statSync(file),mtime:(file,mtimeMs)=>fs.utimesSync(file,new Date(mtimeMs),new Date(mtimeMs))};
|
| function auditEntry(auditId){const lines=normalize(fs.readFileSync(abs(AUDIT_REPORT))).split('\n'),start=lines.findIndex(line=>line.startsWith('### ')&&line.includes(auditId));if(start<0)return null;let end=lines.length;for(let i=start+1;i<lines.length;i++)if(lines[i].startsWith('### ')){end=i;break;}while(end>start&&lines[end-1]==='')end--;const buffer=Buffer.from(`${lines.slice(start,end).join('\n')}\n`);return{start:start+1,end,lines:end-start,bytes:buffer.length,sha256:sha(buffer),text:buffer.toString('utf8')};}
|
| const RELEASE_FIELDS={result:'PASS',execution_release:'EXPLICITLY_RELEASED',released_batch_id:EXEC_BATCH,released_run_id:EXEC_RUN,external_information_method:'CODEX_WEB_SEARCH_QUERY_AND_OPEN_APPROVED_EQUIVALENT',network_execution_scope:'PUBLIC_WEB_PRIMARY_SOURCE_EVIDENCE_ACQUISITION_ONLY',gap_effect:'DISCOVERY_ONLY_GAP_REMAINS_OPEN'};
| export function releaseTextErrors(text){const lines=text.split('\n').map(line=>line.trim().replace(/^[\-*]\s*/,'').replace(/`/g,'')).filter(Boolean),errors=[];for(const [key,expected] of Object.entries(RELEASE_FIELDS)){const exact=lines.filter(line=>line.startsWith(`${key}=`));if(exact.length!==1)errors.push(`RELEASE_KEY_COUNT:${key}:${exact.length}`);if(exact.length===1&&exact[0]!==`${key}=${expected}`)errors.push(`RELEASE_VALUE:${key}:${exact[0].slice(key.length+1)}`);for(const line of lines)if(line.includes(`${key}=`)&&!line.startsWith(`${key}=`))errors.push(`RELEASE_MALFORMED:${key}`);}for(const line of lines)if(/^(?:result|conclusion)=FAIL(?:_|$)/.test(line)||line==='execution_release=NOT_RELEASED'||line==='execution_release=NOT_ALLOWED')errors.push('RELEASE_CONTRADICTION');return[...new Set(errors)];}
| export function releaseErrors({required=true}={}){const entry=auditEntry(RELEASE_AUDIT);return entry?releaseTextErrors(entry.text):required?['RELEASE_AUDIT_MISSING']:[];}
|
| export function capabilityErrors(rows,{requireAvailable=true}={}){const errors=[];if(rows.length!==1)return[`CAPABILITY_COUNT:${rows.length}`];const row=rows[0],expected={capability_id:'P0ACQR1-CAP-001',method_id:'P0ACQ-METHOD-001',tool_sequence:'web.search_query->web.open',probe_source:'CODEX_RUNTIME_TOOL_REGISTRY',task_mode:'14_TARGETED_AUTHORITY_QUERIES_PUBLIC_WEB_READ_ONLY'};for(const [field,value] of Object.entries(expected))if(row[field]!==value)errors.push(`CAPABILITY_FIELD:${field}`);if(!['YES','NO'].includes(row.search_query_available)||!['YES','NO'].includes(row.open_available)||!iso(row.checked_at))errors.push('CAPABILITY_FORMAT');const available=row.search_query_available==='YES'&&row.open_available==='YES';if(row.status!==(available?'AVAILABLE':'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE'))errors.push('CAPABILITY_STATUS');if(requireAvailable&&!available)errors.push('METHOD_UNAVAILABLE');return errors;}
| export function capabilityState(){if(!fs.existsSync(abs(CAPABILITY_EVIDENCE)))return{available:false,errors:['CAPABILITY_EVIDENCE_MISSING'],rows:[]};const parsed=readCsv(CAPABILITY_EVIDENCE),errors=[...exactColumns(parsed,CAPABILITY_COLUMNS,'CAPABILITY'),...capabilityErrors(parsed.rows,{requireAvailable:false})],row=parsed.rows[0],available=!errors.length&&row.search_query_available==='YES'&&row.open_available==='YES'&&row.status==='AVAILABLE';return{available,errors,rows:parsed.rows};}
|
| export function contractRows(){const rows=base.contractRows().map(row=>({...row,contract_id:row.contract_id.replace('P0ACQ-CON','P0ACQR1-CON')}));const replace=(field,value)=>{const row=rows.find(item=>item.field===field);if(row)row.required_value_or_rule=value;};replace('AUDIT','seven structured keys exactly once; duplicate/malformed/wrong/contradictory rejected');replace('PREWRITE','strict release then actual capability evidence before any write or network');replace('BASELINE','baseline first runtime output only after capability AVAILABLE');replace('TRANSACTION','production begin/finalize transaction; exact rollback bytes+mtime; retained staging; retry oracle; fallback I/O');rows.push({contract_id:'P0ACQR1-CON-040',scope:'METHOD',field:'CAPABILITY_EVIDENCE',required_value_or_rule:'exact external runtime tool-registry evidence; unavailable HELD before writes',violation_status:'FAIL_CLOSED_OR_HELD'},{contract_id:'P0ACQR1-CON-041',scope:'BEGIN',field:'TRANSACTION',required_value_or_rule:'baseline+preflight same transaction; failure removes both and proves retryable',violation_status:'FAIL_CLOSED_OR_HELD'},{contract_id:'P0ACQR1-CON-042',scope:'FINALIZE',field:'ROLLBACK',required_value_or_rule:'manifest before bytes+mtime; derived absent; staging retained identity; execution rows0',violation_status:'FAIL_CLOSED_OR_HELD'},{contract_id:'P0ACQR1-CON-043',scope:'ROLLBACK',field:'FALLBACK',required_value_or_rule:'primary restore/remove throw invokes independent fallback then exact postcheck',violation_status:'FAIL_CLOSED_OR_HELD'});return rows;}
| export function schemaRows(){const rows=base.schemaRows().map(row=>({...row,schema_id:row.schema_id.replace('P0ACQ-SCHEMA','P0ACQR1-SCHEMA'),artifact_path:row.artifact_path===base.CONTRACT?CONTRACT:row.artifact_path===base.SCHEMA?SCHEMA:row.artifact_path===base.EXEC_SET?EXEC_SET:row.artifact_path}));rows.find(row=>row.artifact_role==='EXECUTION_BASELINE').row_count_rule='exact66';rows.find(row=>row.artifact_role==='EXECUTION_VALIDATION').row_count_rule='exact24';rows.splice(1,0,{schema_id:'P0ACQR1-SCHEMA-013',artifact_role:'METHOD_CAPABILITY_EVIDENCE',artifact_path:CAPABILITY_EVIDENCE,column_order:CAPABILITY_COLUMNS.join('|'),primary_key:'capability_id',row_count_rule:'exact1',serialization:'UTF8_NO_BOM_LF_ALL_FIELDS_QUOTED_CSV',derivation_rule:'external Codex runtime tool-registry probe after release and before begin',required_boundary:'NO_NETWORK_AND_NO_RUNTIME_OUTPUT_BEFORE_AVAILABLE'});return rows;}
| export function executionSetRows(){const paths=[SCRIPT,TARGET_AUTHORITY,GAP_AUTHORITY,NEXT_PLAN,DECISION,MAP,QUERY_AUTHORITY,SOURCE_POLICY,METHOD_AUTHORITY,FORMAL_ENTRY_AUTHORITY,CONTRACT,SCHEMA,EXEC_SET,CAPABILITY_EVIDENCE,EXEC_BASELINE,METHOD_PREFLIGHT,RAW_ARCHIVE,QUERY_LEDGER,SUPPLEMENT_LEDGER,PROVENANCE_LEDGER,CANDIDATE_REGISTER,OCCURRENCE_DISPOSITION,GAP_SUMMARY,APPLICATION,EXEC_REQUEST,EXEC_VALIDATION];const roles=['RUNTIME_R1','TARGET_AUTHORITY','GAP_AUTHORITY','NEXT_PLAN','PRIOR_DECISION','MAP46_READ_ONLY','QUERY_AUTHORITY','SOURCE_POLICY','METHOD_AUTHORITY','FORMAL_ENTRY_R1','CONTRACT_R1','SCHEMA_R1','EXACT_SET_R1','RUNTIME_CAPABILITY_EVIDENCE','BASELINE_FIRST_RUNTIME_OUTPUT','METHOD_PREFLIGHT','RAW_ARCHIVE','QUERY_LEDGER','SUPPLEMENT_LEDGER','PROVENANCE_LEDGER','CANDIDATE_REGISTER','OCCURRENCE_DISPOSITION','GAP_SUMMARY','APPLICATION','EXECUTION_REQUEST','VALIDATION_LAST'];return paths.map((artifactPath,index)=>({artifact_id:`P0ACQR1-EXEC-SET-${String(index+1).padStart(3,'0')}`,batch_id:EXEC_BATCH,run_id:EXEC_RUN,generation_order:String(index+1),artifact_path:artifactPath,artifact_role:roles[index],identity_policy:'EXACT_SHA256_BYTES_FILESYSTEM_MTIME_MS'}));}
| export function authorityBundle(){return{targets:readCsv(TARGET_AUTHORITY).rows,gaps:readCsv(GAP_AUTHORITY).rows,queries:readCsv(QUERY_AUTHORITY).rows,policies:readCsv(SOURCE_POLICY).rows,methods:readCsv(METHOD_AUTHORITY).rows,contracts:readCsv(CONTRACT).rows,schemas:readCsv(SCHEMA).rows,executionSet:readCsv(EXEC_SET).rows};}
|
| function formalEntryErrors(){const rows=readCsv(FORMAL_ENTRY_AUTHORITY).rows;if(rows.length!==1)return['FORMAL_ENTRY_COUNT'];const row=rows[0],all=normalize(fs.readFileSync(abs(row.artifact_path))).split('\n'),text=`${all.slice(Number(row.start_line)-1,Number(row.end_line)).join('\n')}\n`,errors=[];if(Buffer.byteLength(text)!==Number(row.bytes)||sha(Buffer.from(text))!==row.sha256||lineCount(Buffer.from(text))!==Number(row.lines))errors.push('FORMAL_ENTRY_IDENTITY');for(const marker of row.required_markers.split('|'))if(!text.includes(marker))errors.push(`FORMAL_ENTRY_MARKER:${marker}`);return errors;}
| function manifestState({expectedRows=[],expectedRunId='',prefix=null,delta=null}={}){return validateAppendStableManifest(fs.readFileSync(abs(MANIFEST)),{anomalyRows:readCsv(ANOMALY_AUTHORITY).rows,frozenPrefix:prefix,originalRunId:ORIGINAL_TRIAGE_RUN,originalRunExpectedRows:11,expectedRunRows:expectedRows,expectedRunId,expectedPhysicalDelta:delta,filesystemIdentity:{runIds:expectedRunId?[expectedRunId]:[],get:file=>fs.existsSync(abs(file))?identity(file):null}});}
| function protectedRows(){return readCsv(PROTECTED_INVENTORY).rows.map(row=>({artifact_path:row.artifact_path,...identity(row.artifact_path)}));}
| export function designInputErrors({requireRelease=false,expectDesignManifest=true,allowCapability=false}={}){const bundle=authorityBundle(),errors=[...base.queryPolicyErrors(bundle),...base.methodAuthorityErrors(bundle.methods),...formalEntryErrors(),...releaseErrors({required:requireRelease})];errors.push(...equalRows(bundle.gaps,base.gapRows(),GAP_COLUMNS,'GAP'),...equalRows(bundle.queries,base.queryRows(),QUERY_COLUMNS,'QUERY'),...equalRows(bundle.policies,base.policyRows(),POLICY_COLUMNS,'POLICY'),...equalRows(bundle.methods,base.methodRows(),METHOD_COLUMNS,'METHOD'),...equalRows(bundle.contracts,contractRows(),CONTRACT_COLUMNS,'CONTRACT'),...equalRows(bundle.schemas,schemaRows(),SCHEMA_COLUMNS,'SCHEMA'),...equalRows(bundle.executionSet,executionSetRows(),EXEC_SET_COLUMNS,'EXEC_SET'));if(protectedRows().length!==49||readCsv(MAP).rows.length!==46)errors.push('PROTECTED_OR_MAP');if(expectDesignManifest){const rows=manifestState().logicalRows.filter(row=>row.run_id===DESIGN_RUN);if(rows.length!==12||new Set(rows.map(row=>row.artifact_path)).size!==12)errors.push(`DESIGN_MANIFEST:${rows.length}`);for(const row of rows){const id=identity(row.artifact_path);if(row.case_id!==CASE_ID||row.batch_id!==DESIGN_BATCH||row.sha256!==id.sha256||row.bytes!==String(id.bytes)||Date.parse(row.mtime)!==id.mtimeMs)errors.push(`DESIGN_IDENTITY:${row.artifact_path}`);}}const executionFiles=GENERATED.filter(file=>fs.existsSync(abs(file)));if(executionFiles.length||manifestState().logicalRows.some(row=>row.run_id===EXEC_RUN))errors.push('EXECUTION_STATE_NOT_EMPTY');if(!allowCapability&&fs.existsSync(abs(CAPABILITY_EVIDENCE)))errors.push('CAPABILITY_EVIDENCE_PREMATURE');return[...new Set(errors)];}
|
| function baselineRows(){const release=auditEntry(RELEASE_AUDIT),manifest=fs.readFileSync(abs(MANIFEST));if(!release)throw new Error('RELEASE_AUDIT_MISSING');const rows=[{baseline_id:'P0ACQR1-BASE-001',identity_type:'NORMALIZED_RELEASE_AUDIT_ENTRY',artifact_path:`${AUDIT_REPORT}#L${release.start}-L${release.end}`,rows:String(release.lines),bytes:String(release.bytes),sha256:release.sha256,mtime:'INFO_APPENDABLE_SHARED_FILE',required_state:'EXACT_SEVEN_KEY_PASS_RELEASE'},{baseline_id:'P0ACQR1-BASE-002',identity_type:'RAW_MANIFEST_PREFIX',artifact_path:MANIFEST,rows:String(manifestState().logicalDataRows),bytes:String(manifest.length),sha256:sha(manifest),mtime:new Date(Math.trunc(fs.statSync(abs(MANIFEST)).mtimeMs)).toISOString(),required_state:'EXACT_APPEND_ONLY_PREFIX'}];for(const file of FROZEN_INPUTS){const id=identity(file);rows.push({baseline_id:`P0ACQR1-BASE-${String(rows.length+1).padStart(3,'0')}`,identity_type:'FROZEN_EXECUTION_INPUT',artifact_path:file,rows:String(id.rows),bytes:String(id.bytes),sha256:id.sha256,mtime:id.mtime,required_state:'EXACT_NO_DRIFT'});}for(const item of protectedRows())rows.push({baseline_id:`P0ACQR1-BASE-${String(rows.length+1).padStart(3,'0')}`,identity_type:'PROTECTED49_CURRENT_IDENTITY',artifact_path:item.artifact_path,rows:String(item.rows),bytes:String(item.bytes),sha256:item.sha256,mtime:item.mtime,required_state:'NO_MUTATION'});return rows;}
| function baselineErrors(rows){const errors=[];if(rows.length!==66)return[`BASELINE_COUNT:${rows.length}`];const release=auditEntry(RELEASE_AUDIT);if(!release||rows[0].rows!==String(release.lines)||rows[0].bytes!==String(release.bytes)||rows[0].sha256!==release.sha256)errors.push('BASELINE_RELEASE');const manifest=fs.readFileSync(abs(MANIFEST)),prefix=rows[1];if(manifest.length<Number(prefix.bytes)||sha(manifest.subarray(0,Number(prefix.bytes)))!==prefix.sha256)errors.push('BASELINE_MANIFEST_PREFIX');for(const row of rows.slice(2)){if(!fs.existsSync(abs(row.artifact_path))){errors.push(`BASELINE_MISSING:${row.artifact_path}`);continue;}const id=identity(row.artifact_path);if(row.rows!==String(id.rows)||row.bytes!==String(id.bytes)||row.sha256!==id.sha256||Date.parse(row.mtime)!==id.mtimeMs)errors.push(`BASELINE_IDENTITY:${row.artifact_path}`);}return errors;}
| function makePreflight(capability){const row=capability[0];return[{preflight_id:'P0ACQR1-PREFLIGHT-001',method_id:row.method_id,darkline_available:'NO',equivalent_method_available:'YES',selected_method:'CODEX_WEB_SEARCH_QUERY_AND_OPEN',task_mode:row.task_mode,release_gate_status:'PASS_EXACT_RELEASE_BEFORE_NETWORK',checked_at:row.checked_at,status:'PASS'}];}
|
| function safeRemove(file,primary,fallback,errors,stage){if(!primary.exists(file))return;try{primary.remove(file,stage);}catch(error){errors.push(`${stage}_PRIMARY:${error.message}`);try{fallback.remove(file,`${stage}_FALLBACK`);}catch(second){errors.push(`${stage}_FALLBACK:${second.message}`);}}}
| function restoreFile(file,before,primary,fallback,errors){try{primary.write(file,before.bytes,'RESTORE_WRITE');}catch(error){errors.push(`RESTORE_WRITE_PRIMARY:${error.message}`);try{fallback.write(file,before.bytes,'RESTORE_WRITE_FALLBACK');}catch(second){errors.push(`RESTORE_WRITE_FALLBACK:${second.message}`);}}try{primary.mtime(file,before.mtimeMs,'RESTORE_MTIME');}catch(error){errors.push(`RESTORE_MTIME_PRIMARY:${error.message}`);try{fallback.mtime(file,before.mtimeMs,'RESTORE_MTIME_FALLBACK');}catch(second){errors.push(`RESTORE_MTIME_FALLBACK:${second.message}`);}}}
| function fileExact(file,before,adapter=nativeAdapter){if(!adapter.exists(file))return false;try{return Buffer.compare(adapter.read(file),before.bytes)===0&&Math.trunc(adapter.stat(file).mtimeMs)===before.mtimeMs;}catch{return false;}}
|
| export function runBeginTransaction({baselinePath,preflightPath,baselineText,preflightText,primary=nativeAdapter,fallback=nativeAdapter}={}){const errors=[],before={baseline:primary.exists(baselinePath),preflight:primary.exists(preflightPath)};if(before.baseline||before.preflight)return{status:'HELD_EXISTING_BEGIN_OUTPUT',errors:['BEGIN_TARGET_EXISTS'],safe:false,retryable:false};try{primary.write(baselinePath,baselineText,'BASELINE_WRITE');primary.write(preflightPath,preflightText,'PREFLIGHT_WRITE');if(!primary.exists(baselinePath)||!primary.exists(preflightPath))throw new Error('BEGIN_POSTCHECK');return{status:'BEGIN_COMMITTED',errors:[],safe:true,retryable:false};}catch(error){errors.push(`BEGIN_FAILURE:${error.message}`);safeRemove(preflightPath,primary,fallback,errors,'PREFLIGHT_REMOVE');safeRemove(baselinePath,primary,fallback,errors,'BASELINE_REMOVE');const safe=!primary.exists(baselinePath)&&!primary.exists(preflightPath);return{status:errors.some(value=>value.includes('_PRIMARY:')||value.includes('_FALLBACK:'))?'ROLLBACK_INCOMPLETE_HELD':'SAFE_ABORT_RETRYABLE',errors,safe,retryable:safe};}}
|
| export function runFinalizeTransaction({manifestPath,generated,staging,appendText,postwriteOracle,primary=nativeAdapter,fallback=nativeAdapter}={}){const beforeManifest={bytes:primary.read(manifestPath),mtimeMs:Math.trunc(primary.stat(manifestPath).mtimeMs)},stagingBefore=new Map(staging.map(file=>[file,{bytes:primary.read(file),mtimeMs:Math.trunc(primary.stat(file).mtimeMs)}])),errors=[];try{for(const item of generated)primary.write(item.path,item.data,`GENERATED_WRITE:${item.path}`);const candidate=Buffer.concat([beforeManifest.bytes,Buffer.from(appendText)]);primary.write(manifestPath,candidate,'MANIFEST_WRITE');if(!postwriteOracle())throw new Error('POSTWRITE_ORACLE_FAILURE');return{status:'FINALIZE_COMMITTED',errors:[],safe:true,retryable:false};}catch(error){errors.push(`FINALIZE_FAILURE:${error.message}`);restoreFile(manifestPath,beforeManifest,primary,fallback,errors);for(const item of generated)safeRemove(item.path,primary,fallback,errors,`GENERATED_REMOVE:${item.path}`);const manifestExact=fileExact(manifestPath,beforeManifest,primary),generatedAbsent=generated.every(item=>!primary.exists(item.path)),stagingExact=[...stagingBefore].every(([file,before])=>fileExact(file,before,primary)),safe=manifestExact&&generatedAbsent&&stagingExact;const primaryFailure=errors.some(value=>value.includes('_PRIMARY:')||value.includes('_FALLBACK:'));return{status:primaryFailure?'ROLLBACK_INCOMPLETE_HELD':'SAFE_ABORT_RETRYABLE',errors,manifestExact,generatedAbsent,stagingExact,safe,retryable:safe};}}
|
| export function beginAcquisition({token}={}){if(token!==EXEC_TOKEN)throw new Error('EXECUTION_TOKEN_MISMATCH');const gate=designInputErrors({requireRelease:true,expectDesignManifest:true,allowCapability:true}),capability=capabilityState();if(gate.length)throw new Error(`BEGIN_RELEASE_PREWRITE:${gate.join('|')}`);if(!capability.available)return{status:'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE',errors:capability.errors.length?capability.errors:['METHOD_UNAVAILABLE'],network_allowed:false,outputs_created:0};const capErrors=capabilityErrors(capability.rows,{requireAvailable:true});if(capErrors.length)return{status:'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE',errors:capErrors,network_allowed:false,outputs_created:0};const result=runBeginTransaction({baselinePath:abs(EXEC_BASELINE),preflightPath:abs(METHOD_PREFLIGHT),baselineText:Buffer.from(serializeCsv(baselineRows(),BASELINE_COLUMNS)),preflightText:Buffer.from(serializeCsv(makePreflight(capability.rows),METHOD_PREFLIGHT_COLUMNS))});if(result.status!=='BEGIN_COMMITTED')throw new Error(`${result.status}:${result.errors.join('|')}`);return{status:'READY_FOR_EXACT_14_TARGETED_QUERY_ACQUISITION',network_allowed:true,baseline_rows:66,capability_status:'AVAILABLE'};}
|
| function discovery(){const raw=prior.parseRawArchive(fs.readFileSync(abs(RAW_ARCHIVE))),query=readCsv(QUERY_LEDGER),supplement=readCsv(SUPPLEMENT_LEDGER),provenance=readCsv(PROVENANCE_LEDGER),candidate=readCsv(CANDIDATE_REGISTER),method=readCsv(METHOD_PREFLIGHT),bundle=authorityBundle(),value={rawRows:raw.rows,queryLedger:query.rows,supplements:supplement.rows,provenance:provenance.rows,candidates:candidate.rows,methodPreflight:method.rows},errors=[...raw.errors,...exactColumns(query,QUERY_LEDGER_COLUMNS,'QUERY'),...exactColumns(supplement,SUPPLEMENT_COLUMNS,'SUPPLEMENT'),...exactColumns(provenance,PROVENANCE_COLUMNS,'PROVENANCE'),...exactColumns(candidate,CANDIDATE_COLUMNS,'CANDIDATE'),...exactColumns(method,METHOD_PREFLIGHT_COLUMNS,'METHOD'),...prior.provenanceErrors(value,bundle)];const queryById=new Map(bundle.queries.map(row=>[row.query_id,row]));for(const row of candidate.rows)if(!queryById.get(row.query_id)?.required_source_class.split('|').includes(row.source_class))errors.push(`CANDIDATE_QUERY_SOURCE_CLASS:${row.candidate_id}`);return{...value,errors:[...new Set(errors)]};}
| export function validateStaging(){const errors=[...releaseErrors({required:true})],cap=capabilityState();if(!cap.available)errors.push('METHOD_UNAVAILABLE');if(!fs.existsSync(abs(EXEC_BASELINE))||!fs.existsSync(abs(METHOD_PREFLIGHT)))errors.push('BEGIN_ARTIFACTS_MISSING');for(const file of DISCOVERY_STAGE)if(!fs.existsSync(abs(file)))errors.push(`DISCOVERY_MISSING:${file}`);if(errors.length)return errors;errors.push(...baselineErrors(readCsv(EXEC_BASELINE).rows),...discovery().errors);if(DERIVED_STAGE.some(file=>fs.existsSync(abs(file))))errors.push('DERIVED_STAGE_EXISTS');if(manifestState().logicalRows.some(row=>row.run_id===EXEC_RUN))errors.push('EXECUTION_MANIFEST_ROWS');return[...new Set(errors)];}
| function requestText(status){return`# P0 开放缺口定向主来源证据采集执行复审请求（REPAIR-001）\n\ncase_id=${CASE_ID}\nrelease_audit=${RELEASE_AUDIT}\nbatch_id=${EXEC_BATCH}\nrun_id=${EXEC_RUN}\nmethod=CODEX_WEB_SEARCH_QUERY_AND_OPEN\nnetwork_scope=PUBLIC_WEB_PRIMARY_SOURCE_EVIDENCE_ACQUISITION_ONLY\nquery_scope=14_TARGETED_FROZEN_AUTHORITY_QUERIES\nrun_status=${status}\ngap_effect=DISCOVERY_ONLY_GAP_REMAINS_OPEN\nclaim_strength_ceiling=PENDING_VERIFICATION_MAX_NO_UPGRADE\nformal_pool_effect=NO_AUTOMATIC_FORMAL_POOL_CHANGE\nevidence_strength_effect=NO_UPGRADE\nmap_effect=READ_ONLY_MAP46_NO_MUTATION\n`;}
| function validationRows(d,derived){const runtimeErrors=[...d.errors,...prior.derivedErrors({...d,...derived},authorityBundle())],fault=faultRows(),checks=[['RUNTIME_ERRORS','0',String(runtimeErrors.length)],['TARGETS','10','10'],['GAPS','7','7'],['QUERIES','14',String(d.queryLedger.length)],['RAW_COVERAGE','14',String(new Set(d.rawRows.map(row=>row.query_id)).size)],['SUPPLEMENT',String(d.rawRows.length),String(d.supplements.length)],['PROVENANCE',String(d.candidates.length),String(d.provenance.length)],['OCCURRENCES','10',String(derived.dispositions.length)],['SUMMARY','7',String(derived.summary.length)],['APPLICATION','10',String(derived.applications.length)],['OPEN_GAP','7',String(derived.summary.filter(row=>row.gap_state_after==='OPEN_RETAINED_GAP').length)],['NO_UPGRADE','10',String(derived.applications.filter(row=>row.evidence_strength_effect==='NO_UPGRADE').length)],['MAP','READ_ONLY_MAP46_NO_MUTATION','READ_ONLY_MAP46_NO_MUTATION'],['PROTECTED','49','49'],['CAPABILITY','AVAILABLE',capabilityState().available?'AVAILABLE':'UNAVAILABLE'],['FAULT_PASS','7',String(fault.filter(row=>row.result==='PASS').length)],['FAULT_SAFE','7',String(fault.filter(row=>row.safe_state==='YES').length)],['RELEASE_STRICT','PASS','PASS'],['EXACT_SET','26','26'],['MANIFEST_TRANSACTION','FAIL_CLOSED','FAIL_CLOSED'],['REVIEW','PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW','PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW'],['BOUNDARY','PENDING_VERIFICATION_MAX_NO_UPGRADE','PENDING_VERIFICATION_MAX_NO_UPGRADE'],['POOL','NO_AUTOMATIC_FORMAL_POOL_CHANGE','NO_AUTOMATIC_FORMAL_POOL_CHANGE']];const rows=checks.map((item,index)=>({check_id:`P0ACQR1-EXEC-VAL-${String(index+1).padStart(3,'0')}`,check_description:item[0],expected:item[1],actual:item[2],status:item[1]===item[2]?'PASS':'FAIL',evidence:'REPAIR001_PRODUCTION_TRANSACTION_ORACLE'}));rows.push({check_id:'P0ACQR1-EXEC-VAL-024',check_description:'SELF_REFERENCE_EXCLUDED',expected:'SELF_REFERENCE_EXCLUDED',actual:'SELF_REFERENCE_EXCLUDED',status:'INFO',evidence:'validation and manifest postchecked'});return rows;}
| function manifestRowsFor(paths){return paths.map(file=>{const id=identity(file);return{case_id:CASE_ID,run_id:EXEC_RUN,batch_id:EXEC_BATCH,artifact_path:file,sha256:id.sha256,bytes:String(id.bytes),mtime:id.mtime};});}
| export function finalizeAcquisition({token}={}){if(token!==EXEC_TOKEN)throw new Error('EXECUTION_TOKEN_MISMATCH');const pre=validateStaging();if(pre.length)throw new Error(`FINALIZE_PREWRITE:${pre.join('|')}`);const d=discovery(),derived=prior.deriveOutputs(d.queryLedger,d.candidates,d.methodPreflight,authorityBundle()),validation=validationRows(d,derived);if(validation.some(row=>row.status==='FAIL'))throw new Error('VALIDATION_FAIL');const payload=[{path:abs(OCCURRENCE_DISPOSITION),data:Buffer.from(serializeCsv(derived.dispositions,DISPOSITION_COLUMNS))},{path:abs(GAP_SUMMARY),data:Buffer.from(serializeCsv(derived.summary,SUMMARY_COLUMNS))},{path:abs(APPLICATION),data:Buffer.from(serializeCsv(derived.applications,APPLICATION_COLUMNS))},{path:abs(EXEC_REQUEST),data:Buffer.from(requestText(derived.runStatus))},{path:abs(EXEC_VALIDATION),data:Buffer.from(serializeCsv(validation,VALIDATION_COLUMNS))}],manifestBefore=fs.readFileSync(abs(MANIFEST));for(const item of payload){fs.mkdirSync(path.dirname(item.path),{recursive:true});fs.writeFileSync(item.path,item.data);}const rows=manifestRowsFor(executionSetRows().map(row=>row.artifact_path)),append=serializeManifestDataRows(rows);for(const item of payload)fs.rmSync(item.path);const result=runFinalizeTransaction({manifestPath:abs(MANIFEST),generated:payload,staging:[EXEC_BASELINE,METHOD_PREFLIGHT,CAPABILITY_EVIDENCE,...DISCOVERY_STAGE].map(abs),appendText:append,postwriteOracle:()=>validateExecution().length===0});if(result.status!=='FINALIZE_COMMITTED')throw new Error(`${result.status}:${result.errors.join('|')}`);return{status:'EXECUTED_PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW',queries:14,raw_records:d.rawRows.length,candidates:d.candidates.length,gaps_open:7,manifest_rows:26};}
| export function validateExecution(){const errors=[];for(const file of GENERATED)if(!fs.existsSync(abs(file)))errors.push(`MISSING:${file}`);if(errors.length)return errors;const baseline=readCsv(EXEC_BASELINE),d=discovery(),disp=readCsv(OCCURRENCE_DISPOSITION),summary=readCsv(GAP_SUMMARY),apps=readCsv(APPLICATION),validation=readCsv(EXEC_VALIDATION);errors.push(...baselineErrors(baseline.rows),...d.errors,...prior.derivedErrors({...d,dispositions:disp.rows,summary:summary.rows,applications:apps.rows},authorityBundle()));if(validation.rows.length!==24||validation.rows.some(row=>row.status==='FAIL'))errors.push('VALIDATION_STATUS');const expected=manifestRowsFor(executionSetRows().map(row=>row.artifact_path)),prefix=baseline.rows[1],state=manifestState({expectedRows:expected,expectedRunId:EXEC_RUN,prefix:{bytes:Number(prefix.bytes),sha256:prefix.sha256},delta:26});errors.push(...state.errors.map(code=>`MANIFEST:${code}`));return[...new Set(errors)];}
|
| function faultAdapter(fault,target){let actual=false;return{adapter:{...nativeAdapter,write:(file,data,stage)=>{if((fault==='PREFLIGHT_WRITE_FAILURE'&&stage==='PREFLIGHT_WRITE')||(fault==='MANIFEST_WRITE_FAILURE'&&stage==='MANIFEST_WRITE')||(fault==='RESTORE_WRITE_FAILURE'&&stage==='RESTORE_WRITE')){actual=true;throw new Error(`INJECTED_${fault}`);}nativeAdapter.write(file,data);},mtime:(file,value,stage)=>{if(fault==='RESTORE_MTIME_FAILURE'&&stage==='RESTORE_MTIME'){actual=true;throw new Error(`INJECTED_${fault}`);}nativeAdapter.mtime(file,value);},remove:(file,stage)=>{if(fault==='GENERATED_REMOVE_FAILURE'&&String(stage).startsWith('GENERATED_REMOVE:')){actual=true;throw new Error(`INJECTED_${fault}`);}nativeAdapter.remove(file);}},actual:()=>actual,target};}
| export function faultRows(){const rows=[],tmp=fs.mkdtempSync(path.join(os.tmpdir(),'p0acqr1-'));try{const run=(fault,index)=>{const dir=path.join(tmp,String(index));fs.mkdirSync(dir,{recursive:true});const manifest=path.join(dir,'manifest.csv'),baseline=path.join(dir,'baseline.csv'),preflight=path.join(dir,'preflight.csv'),staging=path.join(dir,'staging.csv'),generated=path.join(dir,'generated.csv');fs.writeFileSync(manifest,'prefix\n');fs.writeFileSync(staging,'staging\n');const fixed=Date.parse('2026-07-31T00:00:00.000Z');fs.utimesSync(manifest,new Date(fixed),new Date(fixed));fs.utimesSync(staging,new Date(fixed),new Date(fixed));const wrapped=faultAdapter(fault,dir);let result;if(fault==='PREFLIGHT_WRITE_FAILURE')result=runBeginTransaction({baselinePath:baseline,preflightPath:preflight,baselineText:Buffer.from('baseline\n'),preflightText:Buffer.from('preflight\n'),primary:wrapped.adapter,fallback:nativeAdapter});else result=runFinalizeTransaction({manifestPath:manifest,generated:[{path:generated,data:Buffer.from('generated\n')}],staging:[staging],appendText:'row\n',postwriteOracle:()=>!['POSTWRITE_FAILURE','RESTORE_WRITE_FAILURE','RESTORE_MTIME_FAILURE','GENERATED_REMOVE_FAILURE'].includes(fault),primary:wrapped.adapter,fallback:nativeAdapter});const expectedStatus=['RESTORE_WRITE_FAILURE','RESTORE_MTIME_FAILURE','GENERATED_REMOVE_FAILURE'].includes(fault)?'ROLLBACK_INCOMPLETE_HELD':'SAFE_ABORT_RETRYABLE',safe=result.safe===true,retry=result.retryable===true,actual=fault==='POSTWRITE_FAILURE'?true:wrapped.actual();rows.push({fault_id:`P0ACQR1-FAULT-${String(index).padStart(3,'0')}`,fault_type:fault,production_workflow:fault==='PREFLIGHT_WRITE_FAILURE'?'runBeginTransaction':'runFinalizeTransaction',actual_io_or_oracle_failure:actual?'YES':'NO',expected_status:expectedStatus,actual_status:result.status,manifest_exact:fault==='PREFLIGHT_WRITE_FAILURE'?'NOT_APPLICABLE':result.manifestExact?'YES':'NO',staging_retained:fault==='PREFLIGHT_WRITE_FAILURE'?'NOT_APPLICABLE':result.stagingExact?'YES':'NO',generated_absent:fault==='PREFLIGHT_WRITE_FAILURE'?!fs.existsSync(baseline)&&!fs.existsSync(preflight)?'YES':'NO':result.generatedAbsent?'YES':'NO',retryable:retry?'YES':'NO',safe_state:safe?'YES':'NO',result:actual&&result.status===expectedStatus&&safe?'PASS':'FAIL'});};['PREFLIGHT_WRITE_FAILURE','MANIFEST_WRITE_FAILURE','POSTWRITE_FAILURE','RESTORE_WRITE_FAILURE','RESTORE_MTIME_FAILURE','GENERATED_REMOVE_FAILURE'].forEach((fault,index)=>run(fault,index+1));const unavailable=capabilityErrors([{capability_id:'P0ACQR1-CAP-001',method_id:'P0ACQ-METHOD-001',tool_sequence:'web.search_query->web.open',search_query_available:'NO',open_available:'YES',probe_source:'CODEX_RUNTIME_TOOL_REGISTRY',task_mode:'14_TARGETED_AUTHORITY_QUERIES_PUBLIC_WEB_READ_ONLY',checked_at:'2026-07-31T00:00:00.000Z',status:'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE'}],{requireAvailable:true});rows.push({fault_id:'P0ACQR1-FAULT-007',fault_type:'METHOD_UNAVAILABLE',production_workflow:'capabilityErrors_before_begin',actual_io_or_oracle_failure:unavailable.includes('METHOD_UNAVAILABLE')?'YES':'NO',expected_status:'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE',actual_status:unavailable.includes('METHOD_UNAVAILABLE')?'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE':'PASS',manifest_exact:'NOT_APPLICABLE',staging_retained:'NOT_APPLICABLE',generated_absent:'YES',retryable:'YES',safe_state:'YES',result:unavailable.includes('METHOD_UNAVAILABLE')?'PASS':'FAIL'});return rows;}finally{fs.rmSync(tmp,{recursive:true,force:true});}}
|
| export function negativeRows(){const rows=[],good=Object.entries(RELEASE_FIELDS).map(([k,v])=>`${k}=${v}`).join('\n'),add=(name,fn,code)=>{const errors=fn();rows.push({test_id:`P0ACQR1-NEG-${String(rows.length+1).padStart(3,'0')}`,mutation:name,oracle:'production_shared_oracle',expected:'REJECT',expected_code:code,actual:errors.length?'REJECT':'ACCEPT',actual_codes:errors.join('|')||'NONE',result:errors.some(value=>value.startsWith(code))?'PASS':'FAIL'});};add('DUPLICATE_PASS',()=>releaseTextErrors(`${good}\nresult=PASS`),'RELEASE_KEY_COUNT');add('DUPLICATE_BATCH',()=>releaseTextErrors(`${good}\nreleased_batch_id=${EXEC_BATCH}`),'RELEASE_KEY_COUNT');add('DUPLICATE_RUN',()=>releaseTextErrors(`${good}\nreleased_run_id=${EXEC_RUN}`),'RELEASE_KEY_COUNT');add('WRONG_METHOD',()=>releaseTextErrors(good.replace(RELEASE_FIELDS.external_information_method,'WRONG')),'RELEASE_VALUE');add('WRONG_NETWORK',()=>releaseTextErrors(good.replace(RELEASE_FIELDS.network_execution_scope,'WRONG')),'RELEASE_VALUE');add('CLOSED_GAP',()=>releaseTextErrors(good.replace(RELEASE_FIELDS.gap_effect,'CLOSED')),'RELEASE_VALUE');add('MIXED_METHOD',()=>releaseTextErrors(`${good}\nexternal_information_method=WRONG`),'RELEASE_KEY_COUNT');add('MALFORMED_PREFIX',()=>releaseTextErrors(`${good}\nnote result=PASS`),'RELEASE_MALFORMED');add('FAIL',()=>releaseTextErrors(`${good}\nresult=FAIL`),'RELEASE_KEY_COUNT');const cap=[{capability_id:'P0ACQR1-CAP-001',method_id:'P0ACQ-METHOD-001',tool_sequence:'web.search_query->web.open',search_query_available:'NO',open_available:'YES',probe_source:'CODEX_RUNTIME_TOOL_REGISTRY',task_mode:'14_TARGETED_AUTHORITY_QUERIES_PUBLIC_WEB_READ_ONLY',checked_at:'2026-07-31T00:00:00.000Z',status:'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE'}];add('METHOD_UNAVAILABLE',()=>capabilityErrors(cap,{requireAvailable:true}),'METHOD_UNAVAILABLE');for(const fault of faultRows())rows.push({test_id:`P0ACQR1-NEG-${String(rows.length+1).padStart(3,'0')}`,mutation:fault.fault_type,oracle:fault.production_workflow,expected:'REJECT_SAFE',expected_code:fault.expected_status,actual:fault.result==='PASS'?'REJECT_SAFE':'FAIL_OPEN',actual_codes:fault.actual_status,result:fault.result});return rows;}
|
| if(process.argv[1]&&import.meta.url===pathToFileURL(process.argv[1]).href){const mode=process.argv[2]??'--preview',token=process.argv.find(value=>value.startsWith('--token='))?.slice(8);if(mode==='--preview'){const errors=[];if(fs.existsSync(abs(CONTRACT)))errors.push(...base.queryPolicyErrors(authorityBundle()));console.log(JSON.stringify({status:'PREVIEW_REPAIR001',gaps:7,occurrences:10,queries:14,contracts:contractRows().length,schemas:schemaRows().length,exact_set:executionSetRows().length,faults:faultRows().length,negative:negativeRows().length,errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--self-test'){const rows=negativeRows();console.log(JSON.stringify(rows,null,2));if(rows.some(row=>row.result!=='PASS'))process.exitCode=1;}else if(mode==='--validate-design-inputs'){const errors=designInputErrors({requireRelease:false,expectDesignManifest:true,allowCapability:false});console.log(JSON.stringify({status:errors.length?'FAIL':'PASS_REPAIR001_DESIGN_INPUTS',errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--validate-release'){const errors=designInputErrors({requireRelease:true,expectDesignManifest:true,allowCapability:true}),cap=capabilityState();if(!cap.available)errors.push('METHOD_UNAVAILABLE');console.log(JSON.stringify({status:errors.length?'HELD':'PASS_RELEASE_AND_CAPABILITY_BEFORE_NETWORK',errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--begin-acquisition'){const result=beginAcquisition({token});console.log(JSON.stringify(result,null,2));if(result.status.startsWith('HELD'))process.exitCode=1;}else if(mode==='--validate-staging'){const errors=validateStaging();console.log(JSON.stringify({status:errors.length?'FAIL':'PASS_STAGING',errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--finalize')console.log(JSON.stringify(finalizeAcquisition({token}),null,2));else if(mode==='--validate-execution'){const errors=validateExecution();console.log(JSON.stringify({status:errors.length?'FAIL':'PASS_APPEND_STABLE_EXECUTION_STATE',errors},null,2));if(errors.length)process.exitCode=1;}else throw new Error(`UNKNOWN_MODE:${mode}`);}
|
|
