mbx/mb-project-info.git

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 core from './detail_strengthening_p0_open_gap_evidence_acquisition_runtime_20260731.mjs';
import * as r1 from './detail_strengthening_p0_open_gap_evidence_acquisition_runtime_repair001_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();
export const CASE_ID=r1.CASE_ID,BASE=r1.BASE,AUDIT_REPORT=r1.AUDIT_REPORT,MANIFEST=r1.MANIFEST;
export const ANOMALY_AUTHORITY=r1.ANOMALY_AUTHORITY,ORIGINAL_TRIAGE_RUN=r1.ORIGINAL_TRIAGE_RUN;
export const DESIGN_ID='DESIGN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-REPAIR-002';
export const DESIGN_RUN='RUN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-DESIGN-REPAIR-002';
export const DESIGN_BATCH='BATCH-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-DESIGN-REPAIR-002';
export const EXEC_RUN=r1.EXEC_RUN,EXEC_BATCH=r1.EXEC_BATCH;
export const RELEASE_AUDIT='AUDIT-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-DESIGN-REPAIR002-REREVIEW-001';
export const SOURCE_FAIL_AUDIT='AUDIT-ANA-ROBOT-DETAIL-STRENGTHENING-P0-OPEN-GAP-EVIDENCE-ACQUISITION-DESIGN-REPAIR001-REREVIEW-001';
export const EXEC_TOKEN='EXECUTE_DETAIL_STRENGTHENING_P0_OPEN_GAP_EVIDENCE_ACQUISITION_REPAIR002';
export const SCRIPT='dev/ana-dev/detail_strengthening_p0_open_gap_evidence_acquisition_runtime_repair002_20260731.mjs';
 
export const TARGET_AUTHORITY=r1.TARGET_AUTHORITY,GAP_AUTHORITY=r1.GAP_AUTHORITY,NEXT_PLAN=r1.NEXT_PLAN,DECISION=r1.DECISION,MAP=r1.MAP;
export const QUERY_AUTHORITY=r1.QUERY_AUTHORITY,SOURCE_POLICY=r1.SOURCE_POLICY,METHOD_AUTHORITY=r1.METHOD_AUTHORITY,PROTECTED_INVENTORY=r1.PROTECTED_INVENTORY;
export const CAPABILITY_EVIDENCE=r1.CAPABILITY_EVIDENCE;
export const FORMAL_ENTRY_AUTHORITY=`${BASE}/evidence/detail_strengthening_p0_open_gap_evidence_acquisition_formal_design_entry_authority_repair002_20260731.csv`;
export const CONTRACT=`${BASE}/evidence/detail_strengthening_p0_open_gap_evidence_acquisition_runtime_contract_repair002_20260731.csv`;
export const SCHEMA=`${BASE}/evidence/detail_strengthening_p0_open_gap_evidence_acquisition_schema_repair002_20260731.csv`;
export const EXEC_SET=`${BASE}/manifest/detail_strengthening_p0_open_gap_evidence_acquisition_execution_artifact_set_repair002_20260731.csv`;
export const EXEC_BASELINE=r1.EXEC_BASELINE,METHOD_PREFLIGHT=r1.METHOD_PREFLIGHT,RAW_ARCHIVE=r1.RAW_ARCHIVE,QUERY_LEDGER=r1.QUERY_LEDGER;
export const SUPPLEMENT_LEDGER=r1.SUPPLEMENT_LEDGER,PROVENANCE_LEDGER=r1.PROVENANCE_LEDGER,CANDIDATE_REGISTER=r1.CANDIDATE_REGISTER;
export const OCCURRENCE_DISPOSITION=r1.OCCURRENCE_DISPOSITION,GAP_SUMMARY=r1.GAP_SUMMARY,APPLICATION=r1.APPLICATION,EXEC_REQUEST=r1.EXEC_REQUEST,EXEC_VALIDATION=r1.EXEC_VALIDATION;
export const QUERY_COLUMNS=r1.QUERY_COLUMNS,POLICY_COLUMNS=r1.POLICY_COLUMNS,METHOD_COLUMNS=r1.METHOD_COLUMNS,FORMAL_ENTRY_COLUMNS=r1.FORMAL_ENTRY_COLUMNS;
export const CONTRACT_COLUMNS=r1.CONTRACT_COLUMNS,SCHEMA_COLUMNS=r1.SCHEMA_COLUMNS,EXEC_SET_COLUMNS=r1.EXEC_SET_COLUMNS,BASELINE_COLUMNS=r1.BASELINE_COLUMNS;
export const METHOD_PREFLIGHT_COLUMNS=r1.METHOD_PREFLIGHT_COLUMNS,QUERY_LEDGER_COLUMNS=r1.QUERY_LEDGER_COLUMNS,SUPPLEMENT_COLUMNS=r1.SUPPLEMENT_COLUMNS;
export const PROVENANCE_COLUMNS=r1.PROVENANCE_COLUMNS,CANDIDATE_COLUMNS=r1.CANDIDATE_COLUMNS,DISPOSITION_COLUMNS=r1.DISPOSITION_COLUMNS;
export const SUMMARY_COLUMNS=r1.SUMMARY_COLUMNS,APPLICATION_COLUMNS=r1.APPLICATION_COLUMNS,VALIDATION_COLUMNS=r1.VALIDATION_COLUMNS,RAW_FIELDS=r1.RAW_FIELDS,GAP_COLUMNS=r1.GAP_COLUMNS;
export const CAPABILITY_COLUMNS=r1.CAPABILITY_COLUMNS;
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];
const 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('/'));
const sha=value=>crypto.createHash('sha256').update(value).digest('hex');
const 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 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 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 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')};}
 
export const releaseTextErrors=r1.releaseTextErrors;
export function releaseErrors({required=true}={}){const entry=auditEntry(RELEASE_AUDIT);return entry?releaseTextErrors(entry.text):required?['RELEASE_AUDIT_MISSING']:[];}
export const capabilityErrors=r1.capabilityErrors;
export const capabilityState=r1.capabilityState;
 
export function contractRows(){
  const rows=r1.contractRows().map(row=>({...row,contract_id:row.contract_id.replace('P0ACQR1-CON','P0ACQR2-CON')}));
  const replace=(field,value)=>{const row=rows.find(item=>item.field===field);if(row)row.required_value_or_rule=value;};
  replace('TRANSACTION','all production payload writes plus manifest commit and postwrite oracle occur inside one transaction; no transaction-external payload I/O');
  const rollback=rows.find(row=>row.scope==='FINALIZE'&&row.field==='ROLLBACK');if(rollback)rollback.required_value_or_rule='every cleanup/postcheck exists/read/stat/write/mtime/remove exception is captured; safe-abort only if exact safe state is verified without cleanup/postcheck exception';
  const fallback=rows.find(row=>row.scope==='ROLLBACK'&&row.field==='FALLBACK');if(fallback)fallback.required_value_or_rule='primary cleanup/postcheck exception invokes independent fallback; status remains ROLLBACK_INCOMPLETE_HELD even when fallback proves safe state';
  rows.push(
    {contract_id:'P0ACQR2-CON-044',scope:'PRODUCTION_FINALIZE',field:'SINGLE_TRANSACTION',required_value_or_rule:'derive payload in memory; runProductionFinalizeWorkflowR2 performs every generated write, dynamic manifest-row derivation, append and final oracle',violation_status:'FAIL_CLOSED_OR_HELD'},
    {contract_id:'P0ACQR2-CON-045',scope:'ROLLBACK',field:'POSTCHECK_EXCEPTION',required_value_or_rule:'any cleanup or postcheck exists/read/stat exception => ROLLBACK_INCOMPLETE_HELD; never SAFE_ABORT_RETRYABLE',violation_status:'FAIL_CLOSED_OR_HELD'},
    {contract_id:'P0ACQR2-CON-046',scope:'ROLLBACK',field:'STATUS_SAFE_COUPLING',required_value_or_rule:'SAFE_ABORT_RETRYABLE iff manifest exact, generated absent, staging exact and cleanup/postcheck exception count zero',violation_status:'FAIL_CLOSED_OR_HELD'},
    {contract_id:'P0ACQR2-CON-047',scope:'FAULT_EVIDENCE',field:'PRODUCTION_WORKFLOW',required_value_or_rule:'private-FS faults invoke runProductionFinalizeWorkflowR2 used by finalizeAcquisition; transaction-external writes forbidden',violation_status:'FAIL_CLOSED_OR_HELD'}
  );
  return rows;
}
 
export function schemaRows(){
  const rows=r1.schemaRows().map(row=>({...row,schema_id:row.schema_id.replace('P0ACQR1-SCHEMA','P0ACQR2-SCHEMA'),artifact_path:row.artifact_path===r1.CONTRACT?CONTRACT:row.artifact_path===r1.SCHEMA?SCHEMA:row.artifact_path===r1.EXEC_SET?EXEC_SET:row.artifact_path}));
  rows.find(row=>row.artifact_role==='EXECUTION_VALIDATION').row_count_rule='exact25';
  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_R2','TARGET_AUTHORITY','GAP_AUTHORITY','NEXT_PLAN','PRIOR_DECISION','MAP46_READ_ONLY','QUERY_AUTHORITY','SOURCE_POLICY','METHOD_AUTHORITY','FORMAL_ENTRY_R2','CONTRACT_R2','SCHEMA_R2','EXACT_SET_R2','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:`P0ACQR2-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=[...core.queryPolicyErrors(bundle),...core.methodAuthorityErrors(bundle.methods),...formalEntryErrors(),...releaseErrors({required:requireRelease})];
  errors.push(...equalRows(bundle.gaps,core.gapRows(),GAP_COLUMNS,'GAP'),...equalRows(bundle.queries,core.queryRows(),QUERY_COLUMNS,'QUERY'),...equalRows(bundle.policies,core.policyRows(),POLICY_COLUMNS,'POLICY'),...equalRows(bundle.methods,core.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:'P0ACQR2-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:'P0ACQR2-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:`P0ACQR2-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:`P0ACQR2-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:'P0ACQR2-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'}];}
 
export const runBeginTransaction=r1.runBeginTransaction;
 
function callWithFallback(primaryCall,fallbackCall,errors,stage){try{return{ok:true,value:primaryCall(),usedFallback:false};}catch(error){errors.push(`${stage}_PRIMARY:${error.message}`);try{return{ok:true,value:fallbackCall(),usedFallback:true};}catch(second){errors.push(`${stage}_FALLBACK:${second.message}`);return{ok:false,value:undefined,usedFallback:true};}}}
function exactPostcheck(file,before,primary,fallback,errors,stage){const exists=callWithFallback(()=>primary.exists(file,`${stage}_EXISTS`),()=>fallback.exists(file,`${stage}_EXISTS_FALLBACK`),errors,`${stage}_EXISTS`);if(!exists.ok||!exists.value)return false;const bytes=callWithFallback(()=>primary.read(file,`${stage}_READ`),()=>fallback.read(file,`${stage}_READ_FALLBACK`),errors,`${stage}_READ`);const stat=callWithFallback(()=>primary.stat(file,`${stage}_STAT`),()=>fallback.stat(file,`${stage}_STAT_FALLBACK`),errors,`${stage}_STAT`);return bytes.ok&&stat.ok&&Buffer.compare(bytes.value,before.bytes)===0&&Math.trunc(stat.value.mtimeMs)===before.mtimeMs;}
function absentPostcheck(file,primary,fallback,errors,stage){const exists=callWithFallback(()=>primary.exists(file,`${stage}_EXISTS`),()=>fallback.exists(file,`${stage}_EXISTS_FALLBACK`),errors,`${stage}_EXISTS`);return exists.ok&&!exists.value;}
function restoreFile(file,before,primary,fallback,errors){callWithFallback(()=>primary.write(file,before.bytes,'ROLLBACK_RESTORE_WRITE'),()=>fallback.write(file,before.bytes,'ROLLBACK_RESTORE_WRITE_FALLBACK'),errors,'ROLLBACK_RESTORE_WRITE');callWithFallback(()=>primary.mtime(file,before.mtimeMs,'ROLLBACK_RESTORE_MTIME'),()=>fallback.mtime(file,before.mtimeMs,'ROLLBACK_RESTORE_MTIME_FALLBACK'),errors,'ROLLBACK_RESTORE_MTIME');}
function removeFile(file,primary,fallback,errors,stage){const exists=callWithFallback(()=>primary.exists(file,`${stage}_EXISTS`),()=>fallback.exists(file,`${stage}_EXISTS_FALLBACK`),errors,`${stage}_EXISTS`);if(!exists.ok||!exists.value)return;callWithFallback(()=>primary.remove(file,stage),()=>fallback.remove(file,`${stage}_FALLBACK`),errors,stage);}
 
export function runFinalizeTransactionR2({manifestPath,generated,staging,buildAppendText,postwriteOracle,primary=nativeAdapter,fallback=nativeAdapter}={}){
  const errors=[];let beforeManifest;const stagingBefore=new Map();
  try{beforeManifest={bytes:primary.read(manifestPath,'PREWRITE_MANIFEST_READ'),mtimeMs:Math.trunc(primary.stat(manifestPath,'PREWRITE_MANIFEST_STAT').mtimeMs)};for(const file of staging)stagingBefore.set(file,{bytes:primary.read(file,'PREWRITE_STAGING_READ'),mtimeMs:Math.trunc(primary.stat(file,'PREWRITE_STAGING_STAT').mtimeMs)});for(const item of generated)if(primary.exists(item.path,'PREWRITE_GENERATED_EXISTS'))return{status:'HELD_EXISTING_FINALIZE_OUTPUT',errors:[`GENERATED_TARGET_EXISTS:${item.path}`],safe:false,retryable:false};}catch(error){return{status:'HELD_PREWRITE_IO_FAILURE',errors:[`PREWRITE_IO_FAILURE:${error.message}`],safe:false,retryable:false};}
  try{
    for(const item of generated)primary.write(item.path,item.data,`GENERATED_WRITE:${item.path}`);
    const appendText=buildAppendText();
    const candidate=Buffer.concat([beforeManifest.bytes,Buffer.from(appendText)]);
    primary.write(manifestPath,candidate,'MANIFEST_WRITE');
    const oracle=postwriteOracle();if(oracle!==true)throw new Error('POSTWRITE_ORACLE_FAILURE');
    return{status:'FINALIZE_COMMITTED',errors:[],safe:true,retryable:false,manifestExact:true,generatedAbsent:false,stagingExact:true};
  }catch(error){
    errors.push(`FINALIZE_FAILURE:${error.message}`);
    restoreFile(manifestPath,beforeManifest,primary,fallback,errors);
    for(const item of generated)removeFile(item.path,primary,fallback,errors,`ROLLBACK_GENERATED_REMOVE:${item.path}`);
    const manifestExact=exactPostcheck(manifestPath,beforeManifest,primary,fallback,errors,'POSTCHECK_MANIFEST');
    const generatedAbsent=generated.every(item=>absentPostcheck(item.path,primary,fallback,errors,`POSTCHECK_GENERATED:${item.path}`));
    const stagingExact=[...stagingBefore].every(([file,before])=>exactPostcheck(file,before,primary,fallback,errors,`POSTCHECK_STAGING:${file}`));
    const safe=manifestExact&&generatedAbsent&&stagingExact;
    const cleanupOrPostcheckError=errors.some(value=>value.startsWith('ROLLBACK_')||value.startsWith('POSTCHECK_'));
    const status=safe&&!cleanupOrPostcheckError?'SAFE_ABORT_RETRYABLE':'ROLLBACK_INCOMPLETE_HELD';
    return{status,errors,manifestExact,generatedAbsent,stagingExact,safe,retryable:status==='SAFE_ABORT_RETRYABLE'};
  }
}
 
export function runProductionFinalizeWorkflowR2(options){return runFinalizeTransactionR2(options);}
 
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 open-gap targeted primary-source acquisition execution review request (REPAIR-002)\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',String(fault.length),String(fault.filter(row=>row.result==='PASS').length)],['FAULT_SAFE',String(fault.length),String(fault.filter(row=>row.independent_safe_state==='YES').length)],['RELEASE_STRICT','PASS','PASS'],['EXACT_SET','26','26'],['PAYLOAD_TRANSACTION','NO_EXTERNAL_WRITES','NO_EXTERNAL_WRITES'],['ROLLBACK_STATUS','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:`P0ACQR2-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:'REPAIR002_SINGLE_PRODUCTION_TRANSACTION_ORACLE'}));rows.push({check_id:'P0ACQR2-EXEC-VAL-025',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))}
  ];
  const result=runProductionFinalizeWorkflowR2({manifestPath:abs(MANIFEST),generated:payload,staging:[EXEC_BASELINE,METHOD_PREFLIGHT,CAPABILITY_EVIDENCE,...DISCOVERY_STAGE].map(abs),buildAppendText:()=>serializeManifestDataRows(manifestRowsFor(executionSetRows().map(row=>row.artifact_path))),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!==25||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){let actual=false;const hit=stage=>{actual=true;throw new Error(`INJECTED_${fault}:${stage}`);};return{adapter:{...nativeAdapter,write:(file,data,stage)=>{if((fault==='PAYLOAD_WRITE_FAILURE'&&String(stage).startsWith('GENERATED_WRITE:'))||(fault==='MANIFEST_WRITE_FAILURE'&&stage==='MANIFEST_WRITE')||(fault==='RESTORE_WRITE_FAILURE'&&stage==='ROLLBACK_RESTORE_WRITE'))return hit(stage);nativeAdapter.write(file,data);},mtime:(file,value,stage)=>{if(fault==='RESTORE_MTIME_FAILURE'&&stage==='ROLLBACK_RESTORE_MTIME')return hit(stage);nativeAdapter.mtime(file,value);},remove:(file,stage)=>{if(fault==='GENERATED_REMOVE_FAILURE'&&String(stage).startsWith('ROLLBACK_GENERATED_REMOVE:'))return hit(stage);nativeAdapter.remove(file);},exists:(file,stage)=>{if(fault==='POSTCHECK_EXISTS_FAILURE'&&String(stage).startsWith('POSTCHECK_'))return hit(stage);return nativeAdapter.exists(file);},read:(file,stage)=>{if(fault==='POSTCHECK_READ_FAILURE'&&String(stage).startsWith('POSTCHECK_'))return hit(stage);return nativeAdapter.read(file);},stat:(file,stage)=>{if(fault==='POSTCHECK_STAT_FAILURE'&&String(stage).startsWith('POSTCHECK_'))return hit(stage);return nativeAdapter.stat(file);}},actual:()=>actual};}
function independentSafe(manifest,before,generated,staging){try{return Buffer.compare(fs.readFileSync(manifest),before.bytes)===0&&Math.trunc(fs.statSync(manifest).mtimeMs)===before.mtimeMs&&generated.every(file=>!fs.existsSync(file))&&staging.every(item=>Buffer.compare(fs.readFileSync(item.path),item.bytes)===0&&Math.trunc(fs.statSync(item.path).mtimeMs)===item.mtimeMs);}catch{return false;}}
 
export function faultRows(){
  const rows=[],tmp=fs.mkdtempSync(path.join(os.tmpdir(),'p0acqr2-'));
  try{
    const faults=['PAYLOAD_WRITE_FAILURE','MANIFEST_WRITE_FAILURE','POSTWRITE_FAILURE','RESTORE_WRITE_FAILURE','RESTORE_MTIME_FAILURE','GENERATED_REMOVE_FAILURE','POSTCHECK_EXISTS_FAILURE','POSTCHECK_READ_FAILURE','POSTCHECK_STAT_FAILURE','CLEAN_ROLLBACK_CONTROL'];
    faults.forEach((fault,index)=>{
      const dir=path.join(tmp,String(index+1));fs.mkdirSync(dir,{recursive:true});const manifest=path.join(dir,'manifest.csv'),stagingPath=path.join(dir,'staging.csv'),generatedPath=path.join(dir,'generated.csv');fs.writeFileSync(manifest,'prefix\n');fs.writeFileSync(stagingPath,'staging\n');const fixed=Date.parse('2026-07-31T00:00:00.000Z');fs.utimesSync(manifest,new Date(fixed),new Date(fixed));fs.utimesSync(stagingPath,new Date(fixed),new Date(fixed));const before={bytes:fs.readFileSync(manifest),mtimeMs:Math.trunc(fs.statSync(manifest).mtimeMs)},staging=[{path:stagingPath,bytes:fs.readFileSync(stagingPath),mtimeMs:Math.trunc(fs.statSync(stagingPath).mtimeMs)}],wrapped=faultAdapter(fault);let reached=false;
      const result=runProductionFinalizeWorkflowR2({manifestPath:manifest,generated:[{path:generatedPath,data:Buffer.from('generated\n')}],staging:[stagingPath],buildAppendText:()=>{reached=true;return'row\n';},postwriteOracle:()=>!['POSTWRITE_FAILURE','RESTORE_WRITE_FAILURE','RESTORE_MTIME_FAILURE','GENERATED_REMOVE_FAILURE','POSTCHECK_EXISTS_FAILURE','POSTCHECK_READ_FAILURE','POSTCHECK_STAT_FAILURE','CLEAN_ROLLBACK_CONTROL'].includes(fault),primary:wrapped.adapter,fallback:nativeAdapter});
      const held=['RESTORE_WRITE_FAILURE','RESTORE_MTIME_FAILURE','GENERATED_REMOVE_FAILURE','POSTCHECK_EXISTS_FAILURE','POSTCHECK_READ_FAILURE','POSTCHECK_STAT_FAILURE'].includes(fault),expected=held?'ROLLBACK_INCOMPLETE_HELD':'SAFE_ABORT_RETRYABLE',safe=independentSafe(manifest,before,[generatedPath],staging),actual=fault==='POSTWRITE_FAILURE'||fault==='CLEAN_ROLLBACK_CONTROL'?true:wrapped.actual();
      rows.push({fault_id:`P0ACQR2-FAULT-${String(index+1).padStart(3,'0')}`,fault_type:fault,production_workflow:'runProductionFinalizeWorkflowR2',actual_production_stage_reached:reached||fault==='PAYLOAD_WRITE_FAILURE'?'YES':'NO',actual_io_or_oracle_failure:actual?'YES':'NO',expected_status:expected,actual_status:result.status,manifest_exact:Buffer.compare(fs.readFileSync(manifest),before.bytes)===0?'YES':'NO',staging_retained:Buffer.compare(fs.readFileSync(stagingPath),staging[0].bytes)===0?'YES':'NO',generated_absent:!fs.existsSync(generatedPath)?'YES':'NO',transaction_reported_safe:result.safe?'YES':'NO',independent_safe_state:safe?'YES':'NO',retryable:result.retryable?'YES':'NO',result:actual&&result.status===expected&&safe?'PASS':'FAIL'});
    });
    const cap=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:'P0ACQR2-FAULT-011',fault_type:'METHOD_UNAVAILABLE',production_workflow:'capabilityErrors_before_begin',actual_production_stage_reached:'YES',actual_io_or_oracle_failure:cap.includes('METHOD_UNAVAILABLE')?'YES':'NO',expected_status:'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE',actual_status:cap.includes('METHOD_UNAVAILABLE')?'HELD_BY_REQUIRED_EXTERNAL_INFORMATION_METHOD_UNAVAILABLE':'PASS',manifest_exact:'NOT_APPLICABLE',staging_retained:'NOT_APPLICABLE',generated_absent:'YES',transaction_reported_safe:'YES',independent_safe_state:'YES',retryable:'YES',result:cap.includes('METHOD_UNAVAILABLE')?'PASS':'FAIL'});
    return rows;
  }finally{fs.rmSync(tmp,{recursive:true,force:true});}
}
 
export function negativeRows(){const rows=[],releaseFields={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'},good=Object.entries(releaseFields).map(([k,v])=>`${k}=${v}`).join('\n'),add=(name,errors,code)=>rows.push({test_id:`P0ACQR2-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_RESULT',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(releaseFields.external_information_method,'WRONG')),'RELEASE_VALUE');add('WRONG_NETWORK',releaseTextErrors(good.replace(releaseFields.network_execution_scope,'WRONG')),'RELEASE_VALUE');add('CLOSED_GAP',releaseTextErrors(good.replace(releaseFields.gap_effect,'CLOSED')),'RELEASE_VALUE');add('MALFORMED_PREFIX',releaseTextErrors(`${good}\nnote result=PASS`),'RELEASE_MALFORMED');add('FAIL_WITH_PASS',releaseTextErrors(`${good}\nresult=FAIL`),'RELEASE_KEY_COUNT');for(const fault of faultRows())rows.push({test_id:`P0ACQR2-NEG-${String(rows.length+1).padStart(3,'0')}`,mutation:fault.fault_type,oracle:fault.production_workflow,expected:'REJECT_FAIL_CLOSED',expected_code:fault.expected_status,actual:fault.result==='PASS'?'REJECT_FAIL_CLOSED':'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(...core.queryPolicyErrors(authorityBundle()));console.log(JSON.stringify({status:'PREVIEW_REPAIR002',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_REPAIR002_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}`);}