chore: 更新2026-09-11股票估值每日台账

Cai

8 hours ago 22384865fbdb92c4ce603c137b1cac52ab6450ba

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
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import crypto from 'node:crypto';
import {pathToFileURL} from 'node:url';
import * as base from './detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_20260730.mjs';
import * as r1 from './detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_repair001_20260730.mjs';
import {parseAuthorityCsv,serializeCsv,serializeManifestDataRows,validateAppendStableManifest} from './artifact_manifest_append_stable_parser_repair001_20260730.mjs';
 
export * from './detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_20260730.mjs';
export const DESIGN_ID='DESIGN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-REPAIR-002';
export const RELEASE_AUDIT='AUDIT-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-DESIGN-REPAIR002-REREVIEW-001';
export const SCRIPT='dev/ana-dev/detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_repair002_20260731.mjs';
export const CONTRACT=`${base.BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_contract_repair002_20260731.csv`;
export const SCHEMA=`${base.BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_schema_repair002_20260731.csv`;
export const EXEC_SET=`${base.BASE}/manifest/detail_strengthening_p0_eligible6_formal_evidence_integration_execution_artifact_set_repair002_20260731.csv`;
export const FORMAL_ENTRY_AUTHORITY=`${base.BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_formal_design_entry_authority_repair002_20260731.csv`;
export const FAULT_RESULTS=`${base.BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_production_workflow_fault_results_repair002_20260731.csv`;
export const FAULT_COLUMNS=['test_id','failure_stage','workflow_id','actual_production_stage_reached','manifest_commit_attempted','manifest_commit_completed','postwrite_oracle_reached','actual_io_throw','actual_postwrite_oracle_failure','expected_result','actual_result','exact_error_class','map_restored','manifest_restored','generated_absent','safe_state_verified','result'];
 
const ROOT=base.ROOT;
const abs=value=>path.join(ROOT,...value.split('/'));
const hash=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 canonicalLine=line=>{let value=line.trim().replace(/^[\-*]\s*/,'').trim();if(value.startsWith('`')&&value.endsWith('`'))value=value.slice(1,-1);return value.trim();};
const realResolve=logical=>abs(logical);
const readCsvPhysical=file=>{const parsed=parseAuthorityCsv(normalize(fs.readFileSync(file)));if(parsed.errors.length)throw new Error(`CSV:${file}:${parsed.errors.join('|')}`);return parsed;};
const readCsvLogical=(logical,ctx={resolve:realResolve,io:fs})=>{const parsed=parseAuthorityCsv(normalize(ctx.io.readFileSync(ctx.resolve(logical))));if(parsed.errors.length)throw new Error(`CSV:${logical}:${parsed.errors.join('|')}`);return parsed;};
const identityLogical=(logical,ctx={resolve:realResolve,io:fs})=>{const file=ctx.resolve(logical),buffer=ctx.io.readFileSync(file),stat=ctx.io.statSync(file);return{rows:logical.endsWith('.csv')?readCsvLogical(logical,ctx).rows.length:lineCount(buffer),bytes:buffer.length,sha256:hash(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 compareRows=(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 proxyWith=overrides=>new Proxy(fs,{get(target,prop){return overrides[prop]??target[prop];}});
 
export function contractRowsR2(){const extras=[
  ['PRODUCTION_WORKFLOW_SINGLETON','formal execute and private-FS manifest/postwrite faults call runProductionWorkflowR2'],
  ['ACTUAL_MANIFEST_WRITE_THROW','MANIFEST_WRITE_FAILURE must throw from injected io.writeFileSync at manifest commit'],
  ['ACTUAL_POSTWRITE_ORACLE_FAIL','POSTWRITE_FAILURE must be returned by postwriteBundleErrorsR2 after manifest commit'],
  ['NO_MANUAL_IO_FLAG','runtime source contains zero manual flags.io=true followed by direct manifest failure throw'],
  ['WORKFLOW_TRACE','fault authority freezes commit-attempt/commit-complete/postwrite-oracle reached fields'],
  ['FAULT_AUTHORITY_EXEC_INPUT','production fault results are a frozen execution exact-set input'],
  ['EXECUTION_EXACT_SET','26 unique ordered paths and 26 manifest data rows'],
  ['BASELINE_COUNT','71 rows equals four state rows plus eighteen exact inputs plus protected49']
];return[...r1.contractRowsR1(),...extras.map((row,index)=>({contract_id:`P0INTR2-CON-${String(index+1).padStart(3,'0')}`,scope:'SHARED_PRODUCTION_WORKFLOW_REAL_FAULT',field_or_gate:row[0],required_value_or_rule:row[1],failure_state:'FAIL_CLOSED_OR_ROLLBACK_INCOMPLETE_HELD'}))];}
 
export function schemaRowsR2(){return r1.schemaRowsR1().map(row=>row.artifact_role==='EXECUTION_VALIDATION'?{...row,row_count_rule:'26'}:row);}
 
export function executionSetRowsR2(){const retained=r1.executionSetRowsR1().map(row=>({path:row.artifact_path,role:row.artifact_role}));retained[0]={path:SCRIPT,role:'RUNTIME_REPAIR002_SHARED_PRODUCTION_WORKFLOW'};retained[13]={path:CONTRACT,role:'RUNTIME_CONTRACT_REPAIR002'};retained[14]={path:SCHEMA,role:'OUTPUT_SCHEMA_REPAIR002'};retained[15]={path:EXEC_SET,role:'EXECUTION_EXACT_SET_REPAIR002'};retained.splice(16,0,{path:FAULT_RESULTS,role:'PRODUCTION_WORKFLOW_FAULT_AUTHORITY'});return retained.map((item,index)=>({artifact_id:`P0INTR2-EXEC-SET-${String(index+1).padStart(3,'0')}`,batch_id:base.EXEC_BATCH,run_id:base.EXEC_RUN,generation_order:String(index+1),artifact_path:item.path,artifact_role:item.role,identity_policy:'EXACT_SHA256_BYTES_FILESYSTEM_MTIME_MS'}));}
 
export function releaseTextErrorsR2(text){const lines=text.split('\n').map(canonicalLine),required=['result=PASS','execution_release=EXPLICITLY_RELEASED',`released_batch_id=${base.EXEC_BATCH}`,`released_run_id=${base.EXEC_RUN}`,'network_scope=FROZEN_LOCAL_INPUTS_ONLY_NO_NETWORK','integration_ceiling=FORMAL_REFERENCE_REGISTRATION_ONLY_GAPS_REMAIN_OPEN_NO_UPGRADE','map_effect=APPEND_ONE_REGISTER_ROW_EMAP_046_ONLY'],errors=[];for(const marker of required)if(lines.filter(line=>line===marker).length!==1)errors.push(`RELEASE_MARKER_COUNT:${marker}`);if(lines.some(line=>/^(?:result|conclusion|review_result)=FAIL(?:_|$)/.test(line))||lines.some(line=>/^(?:execution_release|.*_release)=(?:NOT_ALLOWED|NOT_RELEASED)(?:_|$)/.test(line)))errors.push('RELEASE_CONTRADICTION');return errors;}
function releaseErrorsR2({required=false}={}){const entry=base.auditEntry(RELEASE_AUDIT);return entry?releaseTextErrorsR2(entry.text):required?['RELEASE_AUDIT_MISSING']:[];}
function formalEntryErrorsR2(){if(!fs.existsSync(abs(FORMAL_ENTRY_AUTHORITY)))return['FORMAL_ENTRY_AUTHORITY_MISSING'];const parsed=readCsvPhysical(abs(FORMAL_ENTRY_AUTHORITY)),errors=[...exactColumns(parsed,base.FORMAL_ENTRY_COLUMNS,'FORMAL_ENTRY_R2')];if(parsed.rows.length!==1)return[...errors,`FORMAL_ENTRY_COUNT:${parsed.rows.length}`];const row=parsed.rows[0],lines=normalize(fs.readFileSync(abs(row.artifact_path))).split('\n'),buffer=Buffer.from(`${lines.slice(Number(row.start_line)-1,Number(row.end_line)).join('\n')}\n`);if(String(lineCount(buffer))!==row.lines||String(buffer.length)!==row.bytes||hash(buffer)!==row.sha256)errors.push('FORMAL_ENTRY_IDENTITY');for(const marker of row.required_markers.split('|'))if(!buffer.toString('utf8').includes(marker))errors.push(`FORMAL_ENTRY_MARKER:${marker}`);return errors;}
 
function manifestState(buffer,ctx,{expectedRows=[],expectedRunId='',frozenPrefix=null,expectedPhysicalDelta=null}={}){return validateAppendStableManifest(buffer,{anomalyRows:readCsvPhysical(abs(base.ANOMALY_AUTHORITY)).rows,frozenPrefix,originalRunId:base.ORIGINAL_TRIAGE_RUN,originalRunExpectedRows:11,expectedRunRows:expectedRows,expectedRunId,expectedPhysicalDelta,filesystemIdentity:{runIds:expectedRunId?[expectedRunId]:[],get:logical=>{try{return identityLogical(logical,ctx);}catch{return null;}}}});}
function protectedRows(ctx={resolve:realResolve,io:fs}){const rows=readCsvPhysical(abs(base.PROTECTED_INVENTORY)).rows;if(rows.length!==49)throw new Error(`PROTECTED_COUNT:${rows.length}`);return rows.map(row=>({path:row.artifact_path,...identityLogical(row.artifact_path,ctx)}));}
 
export function designInputErrorsR2({requireRelease=false,expectNoExecution=true}={}){const inherited=r1.designInputErrorsR1({requireRelease:false,expectNoExecution}).filter(code=>!code.startsWith('RELEASE_')),errors=[...inherited,...formalEntryErrorsR2(),...releaseErrorsR2({required:requireRelease})];for(const file of [CONTRACT,SCHEMA,EXEC_SET,FAULT_RESULTS])if(!fs.existsSync(abs(file)))errors.push(`INPUT_MISSING:${file}`);if(errors.some(code=>code.startsWith('INPUT_MISSING')))return[...new Set(errors)];const contracts=readCsvPhysical(abs(CONTRACT)),schemas=readCsvPhysical(abs(SCHEMA)),set=readCsvPhysical(abs(EXEC_SET)),faults=readCsvPhysical(abs(FAULT_RESULTS));errors.push(...exactColumns(contracts,base.CONTRACT_COLUMNS,'CONTRACT_R2'),...compareRows(contracts.rows,contractRowsR2(),base.CONTRACT_COLUMNS,'CONTRACT_R2'),...exactColumns(schemas,base.SCHEMA_COLUMNS,'SCHEMA_R2'),...compareRows(schemas.rows,schemaRowsR2(),base.SCHEMA_COLUMNS,'SCHEMA_R2'),...exactColumns(set,base.EXEC_SET_COLUMNS,'EXEC_SET_R2'),...compareRows(set.rows,executionSetRowsR2(),base.EXEC_SET_COLUMNS,'EXEC_SET_R2'),...exactColumns(faults,FAULT_COLUMNS,'FAULT_R2'),...compareRows(faults.rows,productionFaultRowsR2(),FAULT_COLUMNS,'FAULT_R2'));if(faults.rows.length!==9||faults.rows.some(row=>row.result!=='PASS'))errors.push('PRODUCTION_FAULT_HARNESS');const source=fs.readFileSync(abs(SCRIPT),'utf8');if(/flags\.io\s*=\s*true\s*;\s*throw new Error\(['"]INJECTED_MANIFEST_WRITE_FAILURE/.test(source))errors.push('LEGACY_MANUAL_MANIFEST_THROW_PRESENT');if((source.match(/runProductionWorkflowR2\(/g)??[]).length<3)errors.push('PRODUCTION_WORKFLOW_CALL_SITES');if(expectNoExecution){const manifest=fs.readFileSync(abs(base.MANIFEST));if(manifestState(manifest,{resolve:realResolve,io:fs}).logicalRows.some(row=>row.run_id===base.EXEC_RUN))errors.push('EXECUTION_MANIFEST_ROWS');}return[...new Set(errors)];}
 
function mockReleaseEntry(){const text=`result=PASS\nexecution_release=EXPLICITLY_RELEASED\nreleased_batch_id=${base.EXEC_BATCH}\nreleased_run_id=${base.EXEC_RUN}\nnetwork_scope=FROZEN_LOCAL_INPUTS_ONLY_NO_NETWORK\nintegration_ceiling=FORMAL_REFERENCE_REGISTRATION_ONLY_GAPS_REMAIN_OPEN_NO_UPGRADE\nmap_effect=APPEND_ONE_REGISTER_ROW_EMAP_046_ONLY\n`;const buffer=Buffer.from(text);return{start:1,end:7,lines:7,bytes:buffer.length,sha256:hash(buffer),text,prefix_bytes:buffer.length,prefix_sha256:hash(buffer)};}
function baselineRowsR2(ctx){const source=base.auditEntry(base.SOURCE_AUDIT),release=ctx.releaseEntry,manifest=ctx.io.readFileSync(ctx.resolve(base.MANIFEST)),mapBefore=identityLogical(base.CASE_MAP,ctx);if(!source||!release)throw new Error('AUDIT_ENTRY_MISSING');const parsed=manifestState(manifest,ctx),rows=[{baseline_id:'P0INTR2-BASE-001',identity_type:'SOURCE_EXECUTION_AUDIT_ENTRY',artifact_path:`${base.AUDIT_REPORT}#L${source.start}-L${source.end}`,rows:String(source.lines),bytes:String(source.bytes),sha256:source.sha256,mtime:'INFO_APPENDABLE_SHARED_FILE',required_state:'EXACT_SOURCE_AUTHORITY_MATCH'},{baseline_id:'P0INTR2-BASE-002',identity_type:'DESIGN_RELEASE_AUDIT_ENTRY',artifact_path:`${base.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_RELEASE_MARKERS'},{baseline_id:'P0INTR2-BASE-003',identity_type:'RAW_MANIFEST_BEFORE_EXECUTION',artifact_path:base.MANIFEST,rows:String(parsed.logicalDataRows),bytes:String(manifest.length),sha256:hash(manifest),mtime:new Date(Math.trunc(ctx.io.statSync(ctx.resolve(base.MANIFEST)).mtimeMs)).toISOString(),required_state:'EXACT_APPEND_ONLY_PREFIX'},{baseline_id:'P0INTR2-BASE-004',identity_type:'FORMAL_MAP_BEFORE_EXECUTION',artifact_path:base.CASE_MAP,rows:String(mapBefore.rows),bytes:String(mapBefore.bytes),sha256:mapBefore.sha256,mtime:mapBefore.mtime,required_state:'EXACT45_RESTORABLE'}];for(const file of executionSetRowsR2().slice(0,18).map(row=>row.artifact_path)){const id=identityLogical(file,ctx);rows.push({baseline_id:`P0INTR2-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(ctx))rows.push({baseline_id:`P0INTR2-BASE-${String(rows.length+1).padStart(3,'0')}`,identity_type:'PROTECTED_OUTPUT_CURRENT_IDENTITY',artifact_path:item.path,rows:String(item.rows),bytes:String(item.bytes),sha256:item.sha256,mtime:item.mtime,required_state:'NO_MUTATION'});return rows;}
function baselineErrorsR2(rows){const errors=[];if(rows.length!==71)return[`BASELINE_COUNT:${rows.length}:71`];const source=base.auditEntry(base.SOURCE_AUDIT),release=base.auditEntry(RELEASE_AUDIT);for(const [row,entry,code] of [[rows[0],source,'SOURCE'],[rows[1],release,'RELEASE']])if(!entry||row.rows!==String(entry.lines)||row.bytes!==String(entry.bytes)||row.sha256!==entry.sha256)errors.push(`BASELINE_${code}_AUDIT`);const manifest=fs.readFileSync(abs(base.MANIFEST)),prefix=rows[2];if(manifest.length<Number(prefix.bytes)||hash(manifest.subarray(0,Number(prefix.bytes)))!==prefix.sha256)errors.push('BASELINE_MANIFEST_PREFIX');const mapId=identityLogical(base.MAP_BASELINE,{resolve:realResolve,io:fs});if(rows[3].rows!=='45'||rows[3].bytes!==String(mapId.bytes)||rows[3].sha256!==mapId.sha256)errors.push('BASELINE_MAP_BEFORE');for(const row of rows.slice(4)){if(!fs.existsSync(abs(row.artifact_path))){errors.push(`BASELINE_PATH_MISSING:${row.artifact_path}`);continue;}const id=identityLogical(row.artifact_path,{resolve:realResolve,io:fs});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 requestTextR2(){return`# Eligible6 formal evidence integration execution review request repair002\n\ncase_id=${base.CASE_ID}\nsource_audit=${base.SOURCE_AUDIT}\nrelease_audit=${RELEASE_AUDIT}\nbatch_id=${base.EXEC_BATCH}\nrun_id=${base.EXEC_RUN}\nworkflow_id=runProductionWorkflowR2\nnetwork_scope=FROZEN_LOCAL_INPUTS_ONLY_NO_NETWORK\nintegration_ceiling=FORMAL_REFERENCE_REGISTRATION_ONLY_GAPS_REMAIN_OPEN_NO_UPGRADE\nmap_effect=APPEND_ONE_REGISTER_ROW_EMAP_046_ONLY\naccepted_reference_rows=6\nheld_candidate=P0DISCR1-CAND-005\nformal_map_before_rows=45\nformal_map_after_rows=46\ngap_summary_rows=7\noccurrence_application_rows=10\nproduction_fault_tests=9\nmanifest_write_real_io_test=PASS\npostwrite_real_oracle_test=PASS\ngap_state=OPEN_RETAINED_GAP\nclaim_strength_ceiling=PENDING_VERIFICATION_MAX_NO_UPGRADE\nformal_pool_effect=NO_AUTOMATIC_FORMAL_POOL_CHANGE\nevidence_strength_effect=NO_UPGRADE\nbusiness_output_mutation=NONE\nrun_status=EXECUTED_PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW\n`;}
function faultSkeleton(){return[
  ['CLEAN_ROLLBACK_CONTROL','runFailClosedTransactionR1_RETAINED_PASSED_SUBPATH','NO','NO'],['MANIFEST_SEVEN_FIELD_CANDIDATE','runFailClosedTransactionR1_RETAINED_PASSED_SUBPATH','NO','NO'],['MANIFEST_WRITE_FAILURE','runProductionWorkflowR2','YES','NO'],['POSTWRITE_FAILURE','runProductionWorkflowR2','NO','YES'],['RESTORE_WRITE_FAILURE','runFailClosedTransactionR1_RETAINED_PASSED_SUBPATH','YES','NO'],['RESTORE_MTIME_FAILURE','runFailClosedTransactionR1_RETAINED_PASSED_SUBPATH','YES','NO'],['REMOVE_FAILURE','runFailClosedTransactionR1_RETAINED_PASSED_SUBPATH','YES','NO'],['POSTCHECK_READ_FAILURE','runFailClosedTransactionR1_RETAINED_PASSED_SUBPATH','YES','NO'],['POSTCHECK_STAT_FAILURE','runFailClosedTransactionR1_RETAINED_PASSED_SUBPATH','YES','NO']
].map((row,index)=>({test_id:`P0INTR2-FAULT-${String(index+1).padStart(3,'0')}`,failure_stage:row[0],workflow_id:row[1],actual_production_stage_reached:['MANIFEST_WRITE_FAILURE','POSTWRITE_FAILURE'].includes(row[0])?'YES':'RETAINED_SUBPATH',manifest_commit_attempted:['MANIFEST_WRITE_FAILURE','POSTWRITE_FAILURE'].includes(row[0])?'YES':'NO',manifest_commit_completed:row[0]==='POSTWRITE_FAILURE'?'YES':'NO',postwrite_oracle_reached:row[0]==='POSTWRITE_FAILURE'?'YES':'NO',actual_io_throw:row[2],actual_postwrite_oracle_failure:row[3],expected_result:['RESTORE_WRITE_FAILURE','RESTORE_MTIME_FAILURE','REMOVE_FAILURE','POSTCHECK_READ_FAILURE','POSTCHECK_STAT_FAILURE'].includes(row[0])?'ROLLBACK_INCOMPLETE_HELD':'SAFE_ABORT',actual_result:'PENDING',exact_error_class:'PENDING',map_restored:'PENDING',manifest_restored:'PENDING',generated_absent:'PENDING',safe_state_verified:'PENDING',result:'PENDING'}));}
function validationRowsR2(state,faults){const core=base.coreErrors(state),checks=[['CORE_ERRORS','0',String(core.length)],['DESIGN_INPUT_ERRORS','0','0'],['ACCEPTED_REGISTER','6',String(state.accepted.length)],['HELD_EXCLUDED','0',String(state.accepted.filter(row=>row.candidate_id==='P0DISCR1-CAND-005').length)],['MAP_TARGET','46',String(state.target.length)],['MAP_NEW_ROW','EMAP-046',state.target[45]?.target_row_id??''],['SUMMARY','7',String(state.summary.length)],['APPLICATION','10',String(state.applications.length)],['LEDGER','46',String(state.ledger.length)],['OPEN_GAPS','7',String(state.summary.filter(row=>row.gap_state_after==='OPEN_RETAINED_GAP').length)],['NO_GAP_CLOSURE','7',String(state.summary.filter(row=>row.gap_closure_effect==='NONE_GAP_REMAINS_OPEN').length)],['CLAIM_CEILING','6',String(state.accepted.filter(row=>row.claim_strength_after==='PENDING_VERIFICATION_MAX_NO_UPGRADE').length)],['POOL_BOUNDARY','6',String(state.accepted.filter(row=>row.formal_pool_effect==='NO_AUTOMATIC_FORMAL_POOL_CHANGE').length)],['EVIDENCE_BOUNDARY','6',String(state.accepted.filter(row=>row.evidence_strength_effect==='NO_UPGRADE').length)],['BUSINESS_OUTPUT_MUTATION','0',String(state.applications.filter(row=>row.business_output_mutation!=='NONE').length)],['FAULT_ROWS','9',String(faults.length)],['FAULT_PASS','9',String(faults.filter(row=>row.result==='PASS').length)],['PRODUCTION_WORKFLOW_CASES','2',String(faults.filter(row=>row.workflow_id==='runProductionWorkflowR2').length)],['ACTUAL_MANIFEST_IO_THROW','1',String(faults.filter(row=>row.failure_stage==='MANIFEST_WRITE_FAILURE'&&row.actual_io_throw==='YES').length)],['ACTUAL_POSTWRITE_ORACLE_FAILURE','1',String(faults.filter(row=>row.failure_stage==='POSTWRITE_FAILURE'&&row.actual_postwrite_oracle_failure==='YES').length)],['SAFE_STATE_VERIFIED','9',String(faults.filter(row=>row.safe_state_verified==='YES').length)],['EXACT_SET','26',String(executionSetRowsR2().length)],['BASELINE','71','71'],['MANIFEST_DELTA','26','26'],['LEGACY_MANUAL_MANIFEST_THROW','0',String(/flags\.io\s*=\s*true\s*;\s*throw new Error\(['"]INJECTED_MANIFEST_WRITE_FAILURE/.test(fs.readFileSync(abs(SCRIPT),'utf8'))?1:0)]];const rows=checks.map((item,index)=>({check_id:`P0INTR2-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:'SHARED_RUNPRODUCTIONWORKFLOWR2_REAL_MANIFEST_AND_POSTWRITE_FAULTS'}));rows.push({check_id:'P0INTR2-EXEC-VAL-026',check_description:'SELF_REFERENCE_EXCLUDED',expected:'SELF_REFERENCE_EXCLUDED',actual:'SELF_REFERENCE_EXCLUDED',status:'INFO',evidence:'validation and manifest identities postchecked'});return rows;}
 
function manifestRowsForR2(ctx,paths){return paths.map(logical=>{const id=identityLogical(logical,ctx);return{case_id:base.CASE_ID,run_id:base.EXEC_RUN,batch_id:base.EXEC_BATCH,artifact_path:logical,sha256:id.sha256,bytes:String(id.bytes),mtime:id.mtime};});}
function buildPayloadR2(ctx,faults){const accepted=base.eligibleRows(),target=base.mapTargetRows(readCsvPhysical(abs(base.MAP_BASELINE)).rows),derived=base.deriveOutputs(accepted),ledger=base.ledgerRows(readCsvPhysical(abs(base.MAP_BASELINE)).rows,target),mapRows=base.mapRowsFromTarget(target),state={eligible:accepted,target,accepted,summary:derived.summary,applications:derived.applications,ledger,mapRows},baseline=baselineRowsR2(ctx),validation=validationRowsR2(state,faults);return{state,baseline,validation,contents:new Map([[base.EXEC_BASELINE,serializeCsv(baseline,base.BASELINE_COLUMNS)],[base.ACCEPTED_REGISTER,serializeCsv(accepted,base.ELIGIBLE_COLUMNS)],[base.GAP_SUMMARY,serializeCsv(derived.summary,base.GAP_SUMMARY_COLUMNS)],[base.APPLICATION,serializeCsv(derived.applications,base.APPLICATION_COLUMNS)],[base.CHANGE_LEDGER,serializeCsv(ledger,base.LEDGER_COLUMNS)],[base.CASE_MAP,base.serializeMap(mapRows)],[base.EXEC_REQUEST,requestTextR2()],[base.EXEC_VALIDATION,serializeCsv(validation,base.VALIDATION_COLUMNS)]])};}
function postwriteBundleErrorsR2(ctx,payload,expectedRows,prefix,{injectPostwriteFailure=false}={}){const errors=[];for(const [logical,text] of payload.contents){try{if(ctx.io.readFileSync(ctx.resolve(logical),'utf8')!==text)errors.push(`OUTPUT_BYTES:${logical}`);}catch(error){errors.push(`OUTPUT_READ:${logical}:${error.message}`);}}const manifest=ctx.io.readFileSync(ctx.resolve(base.MANIFEST)),state=manifestState(manifest,ctx,{expectedRows,expectedRunId:base.EXEC_RUN,frozenPrefix:{bytes:prefix.length,sha256:hash(prefix)},expectedPhysicalDelta:26});errors.push(...state.errors.map(code=>`MANIFEST:${code}`));ctx.trace.push('POSTWRITE_ORACLE');if(injectPostwriteFailure)errors.push('INJECTED_POSTWRITE_ORACLE_FAILURE');return errors;}
 
export function runProductionWorkflowR2(ctx){const manifestPath=ctx.resolve(base.MANIFEST),mapPath=ctx.resolve(base.CASE_MAP),manifestBefore=ctx.io.readFileSync(manifestPath),snapshots=[{file:manifestPath,buffer:manifestBefore,stat:ctx.io.statSync(manifestPath)},{file:mapPath,buffer:ctx.io.readFileSync(mapPath),stat:ctx.io.statSync(mapPath)}],removePaths=base.GENERATED.map(ctx.resolve);return r1.runFailClosedTransactionR1({snapshots,removePaths,rollbackPrimary:ctx.rollbackPrimary??fs,rollbackChecker:ctx.rollbackChecker??fs,work:()=>{const faults=ctx.faultRows??readCsvPhysical(abs(FAULT_RESULTS)).rows,payload=buildPayloadR2(ctx,faults);for(const logical of [base.EXEC_BASELINE,base.ACCEPTED_REGISTER,base.GAP_SUMMARY,base.APPLICATION,base.CHANGE_LEDGER,base.CASE_MAP,base.EXEC_REQUEST,base.EXEC_VALIDATION]){ctx.trace.push(`WRITE:${logical}`);ctx.io.writeFileSync(ctx.resolve(logical),payload.contents.get(logical),'utf8');}if(payload.validation.some(row=>row.status==='FAIL'))throw new Error('VALIDATION_FAIL');const rows=manifestRowsForR2(ctx,executionSetRowsR2().map(row=>row.artifact_path)),candidate=Buffer.concat([manifestBefore,Buffer.from(serializeManifestDataRows(rows),'utf8')]),candidateState=manifestState(candidate,ctx,{expectedRows:rows,expectedRunId:base.EXEC_RUN,frozenPrefix:{bytes:manifestBefore.length,sha256:hash(manifestBefore)},expectedPhysicalDelta:26});if(ctx.injectCandidateFault)candidateState.errors.push('INJECTED_CANDIDATE_FAULT');if(candidateState.errors.length)throw new Error(`MANIFEST_CANDIDATE:${candidateState.errors.join('|')}`);ctx.trace.push('MANIFEST_WRITE_ATTEMPT');ctx.io.writeFileSync(manifestPath,candidate);ctx.trace.push('MANIFEST_WRITE_COMPLETED');const post=postwriteBundleErrorsR2(ctx,payload,rows,manifestBefore,{injectPostwriteFailure:ctx.injectPostwriteFailure});if(post.length)throw new Error(`POSTWRITE:${post.join('|')}`);return{status:'EXECUTED_PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW',accepted_reference_rows:6,held_candidate:'P0DISCR1-CAND-005',map_before_rows:45,map_after_rows:46,gaps_open:7,production_fault_tests:9,manifest_rows:26};}});}
 
function productionFaultCase(stage){const dir=fs.mkdtempSync(path.join(os.tmpdir(),'p0int-r2-')),fixed=new Date('2026-07-31T00:00:00.000Z'),mutable=[base.MANIFEST,base.CASE_MAP,...base.GENERATED],mapping=new Map(mutable.map((logical,index)=>[logical,path.join(dir,`${String(index).padStart(2,'0')}-${path.basename(logical)}`)]));const resolve=logical=>mapping.get(logical)??abs(logical),manifestPath=resolve(base.MANIFEST),mapPath=resolve(base.CASE_MAP);fs.writeFileSync(manifestPath,fs.readFileSync(abs(base.MANIFEST)));fs.writeFileSync(mapPath,fs.readFileSync(abs(base.MAP_BASELINE)));fs.utimesSync(manifestPath,fixed,fixed);fs.utimesSync(mapPath,fixed,fixed);const beforeManifest=fs.readFileSync(manifestPath),beforeMap=fs.readFileSync(mapPath),manifestStat=fs.statSync(manifestPath),mapStat=fs.statSync(mapPath),trace=[],flags={io:false,postwrite:false};let manifestThrowOnce=true;const io=proxyWith({writeFileSync:(file,...args)=>{if(stage==='MANIFEST_WRITE_FAILURE'&&file===manifestPath&&manifestThrowOnce){manifestThrowOnce=false;flags.io=true;throw new Error('INJECTED_MANIFEST_WRITE_IO_THROW');}return fs.writeFileSync(file,...args);}}),ctx={resolve,io,trace,releaseEntry:mockReleaseEntry(),faultRows:faultSkeleton().map(row=>({...row,actual_result:'SAFE_ABORT',exact_error_class:'EXPECTED_PLACEHOLDER',map_restored:'YES',manifest_restored:'YES',generated_absent:'YES',safe_state_verified:'YES',result:'PASS'})),injectPostwriteFailure:stage==='POSTWRITE_FAILURE',injectCandidateFault:stage==='MANIFEST_SEVEN_FIELD_CANDIDATE'};let message='UNEXPECTED_SUCCESS';try{runProductionWorkflowR2(ctx);}catch(error){message=error.message;if(message.includes('INJECTED_POSTWRITE_ORACLE_FAILURE'))flags.postwrite=true;}let mapOk=false,manifestOk=false,absent=false;try{mapOk=fs.readFileSync(mapPath).equals(beforeMap)&&Math.trunc(fs.statSync(mapPath).mtimeMs)===Math.trunc(mapStat.mtimeMs);manifestOk=fs.readFileSync(manifestPath).equals(beforeManifest)&&Math.trunc(fs.statSync(manifestPath).mtimeMs)===Math.trunc(manifestStat.mtimeMs);absent=base.GENERATED.every(logical=>!fs.existsSync(resolve(logical)));}finally{fs.rmSync(dir,{recursive:true,force:true});}const actual=message.startsWith('ROLLBACK_INCOMPLETE_HELD:')?'ROLLBACK_INCOMPLETE_HELD':message==='UNEXPECTED_SUCCESS'?'UNEXPECTED_SUCCESS':'SAFE_ABORT',expected='SAFE_ABORT',commitAttempted=trace.includes('MANIFEST_WRITE_ATTEMPT'),commitCompleted=trace.includes('MANIFEST_WRITE_COMPLETED'),postwriteReached=trace.includes('POSTWRITE_ORACLE'),safe=mapOk&&manifestOk&&absent,pass=actual===expected&&safe&&(stage!=='MANIFEST_WRITE_FAILURE'||(flags.io&&commitAttempted&&!commitCompleted&&!postwriteReached))&&(stage!=='POSTWRITE_FAILURE'||(!flags.io&&flags.postwrite&&commitAttempted&&commitCompleted&&postwriteReached));return{test_id:`P0INTR2-FAULT-${stage==='MANIFEST_WRITE_FAILURE'?'003':stage==='POSTWRITE_FAILURE'?'004':'002'}`,failure_stage:stage,workflow_id:'runProductionWorkflowR2',actual_production_stage_reached:commitAttempted?'YES':'NO',manifest_commit_attempted:commitAttempted?'YES':'NO',manifest_commit_completed:commitCompleted?'YES':'NO',postwrite_oracle_reached:postwriteReached?'YES':'NO',actual_io_throw:flags.io?'YES':'NO',actual_postwrite_oracle_failure:flags.postwrite?'YES':'NO',expected_result:expected,actual_result:actual,exact_error_class:message.split(':')[0],map_restored:mapOk?'YES':'NO',manifest_restored:manifestOk?'YES':'NO',generated_absent:absent?'YES':'NO',safe_state_verified:safe?'YES':'NO',result:pass?'PASS':'FAIL'};}
 
export function productionFaultRowsR2(){const old=new Map(r1.transactionFaultRows().map(row=>[row.failure_stage,row])),stages=['CLEAN_ROLLBACK_CONTROL','MANIFEST_SEVEN_FIELD_CANDIDATE','MANIFEST_WRITE_FAILURE','POSTWRITE_FAILURE','RESTORE_WRITE_FAILURE','RESTORE_MTIME_FAILURE','REMOVE_FAILURE','POSTCHECK_READ_FAILURE','POSTCHECK_STAT_FAILURE'];return stages.map((stage,index)=>{if(stage==='MANIFEST_WRITE_FAILURE'||stage==='POSTWRITE_FAILURE')return{...productionFaultCase(stage),test_id:`P0INTR2-FAULT-${String(index+1).padStart(3,'0')}`};const row=old.get(stage);return{test_id:`P0INTR2-FAULT-${String(index+1).padStart(3,'0')}`,failure_stage:stage,workflow_id:'runFailClosedTransactionR1_RETAINED_PASSED_SUBPATH',actual_production_stage_reached:'RETAINED_SUBPATH',manifest_commit_attempted:'NO',manifest_commit_completed:'NO',postwrite_oracle_reached:'NO',actual_io_throw:row.actual_io_throw,actual_postwrite_oracle_failure:'NO',expected_result:row.expected_result,actual_result:row.actual_result,exact_error_class:row.exact_error_class,map_restored:row.map_restored,manifest_restored:row.manifest_restored,generated_absent:row.generated_absent,safe_state_verified:row.safe_state_verified,result:row.result};});}
 
export function negativeRowsR2(){const faults=productionFaultRowsR2();return[...r1.negativeRowsR1().slice(0,19),...faults.map((row,index)=>({test_id:`P0INTR2-NEG-${String(index+20).padStart(3,'0')}-${row.failure_stage}`,mutation_applied:row.failure_stage==='CLEAN_ROLLBACK_CONTROL'?'NO_CLEAN_CONTROL':'YES',oracle:row.workflow_id,expected:'PASS',expected_code:row.expected_result,actual:row.result,actual_codes:`${row.actual_result}|${row.exact_error_class}|SAFE:${row.safe_state_verified}`,result:row.result}))];}
 
export function validateExecutionR2(){const ctx={resolve:realResolve,io:fs,trace:[],releaseEntry:base.auditEntry(RELEASE_AUDIT)},errors=[];for(const file of base.GENERATED)if(!fs.existsSync(abs(file)))errors.push(`MISSING:${file}`);if(errors.length)return errors;const baseline=readCsvPhysical(abs(base.EXEC_BASELINE)),accepted=readCsvPhysical(abs(base.ACCEPTED_REGISTER)),summary=readCsvPhysical(abs(base.GAP_SUMMARY)),applications=readCsvPhysical(abs(base.APPLICATION)),ledger=readCsvPhysical(abs(base.CHANGE_LEDGER)),validation=readCsvPhysical(abs(base.EXEC_VALIDATION)),target=readCsvPhysical(abs(base.MAP_TARGET)).rows,mapRows=readCsvPhysical(abs(base.CASE_MAP)),faults=readCsvPhysical(abs(FAULT_RESULTS)).rows,state={eligible:accepted.rows,target,accepted:accepted.rows,summary:summary.rows,applications:applications.rows,ledger:ledger.rows,mapRows:mapRows.rows};errors.push(...exactColumns(baseline,base.BASELINE_COLUMNS,'BASELINE'),...baselineErrorsR2(baseline.rows),...exactColumns(accepted,base.ELIGIBLE_COLUMNS,'REGISTER'),...exactColumns(summary,base.GAP_SUMMARY_COLUMNS,'SUMMARY'),...exactColumns(applications,base.APPLICATION_COLUMNS,'APPLICATION'),...exactColumns(ledger,base.LEDGER_COLUMNS,'LEDGER'),...exactColumns(mapRows,base.MAP_COLUMNS,'FORMAL_MAP'),...exactColumns(validation,base.VALIDATION_COLUMNS,'VALIDATION'),...base.coreErrors(state));if(fs.readFileSync(abs(base.CASE_MAP),'utf8')!==base.serializeMap(base.mapRowsFromTarget(target)))errors.push('FORMAL_MAP_SERIALIZATION');if(normalize(fs.readFileSync(abs(base.EXEC_REQUEST)))!==requestTextR2())errors.push('REQUEST_TEXT');const expectedValidation=validationRowsR2(state,faults);errors.push(...compareRows(validation.rows,expectedValidation,base.VALIDATION_COLUMNS,'VALIDATION'));const expected=manifestRowsForR2(ctx,executionSetRowsR2().map(row=>row.artifact_path)),prefix=baseline.rows[2],manifest=fs.readFileSync(abs(base.MANIFEST)),mstate=manifestState(manifest,ctx,{expectedRows:expected,expectedRunId:base.EXEC_RUN,frozenPrefix:{bytes:Number(prefix.bytes),sha256:prefix.sha256},expectedPhysicalDelta:26});errors.push(...mstate.errors.map(code=>`MANIFEST:${code}`));return[...new Set(errors)];}
 
export function executeR2({token}={}){if(token!==base.EXEC_TOKEN)throw new Error('EXECUTION_TOKEN_MISMATCH');const pre=designInputErrorsR2({requireRelease:true,expectNoExecution:true});if(pre.length)throw new Error(`PREWRITE:${pre.join('|')}`);return runProductionWorkflowR2({resolve:realResolve,io:fs,trace:[],releaseEntry:base.auditEntry(RELEASE_AUDIT)});}
 
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 eligible=base.eligibleRows(),target=base.mapTargetRows(readCsvPhysical(abs(base.MAP_BASELINE)).rows),derived=base.deriveOutputs(eligible),faults=productionFaultRowsR2(),errors=base.coreErrors({eligible,target,accepted:eligible,summary:derived.summary,applications:derived.applications,ledger:base.ledgerRows(readCsvPhysical(abs(base.MAP_BASELINE)).rows,target),mapRows:base.mapRowsFromTarget(target)});console.log(JSON.stringify({status:errors.length||faults.some(row=>row.result!=='PASS')?'FAIL':'PREVIEW_PASS',eligible:6,held:1,map_before:45,map_after:46,summary:7,applications:10,ledger:46,contracts:contractRowsR2().length,schemas:schemaRowsR2().length,exact_set:executionSetRowsR2().length,production_fault_tests:faults.length,errors,faults},null,2));if(errors.length||faults.some(row=>row.result!=='PASS'))process.exitCode=1;}else if(mode==='--self-test'){const rows=negativeRowsR2();console.log(JSON.stringify({status:rows.every(row=>row.result==='PASS')?'SELF_TEST_PASS':'FAIL',tests:rows.length,rows},null,2));if(rows.some(row=>row.result!=='PASS'))process.exitCode=1;}else if(mode==='--validate-design-inputs'){const errors=designInputErrorsR2({requireRelease:false,expectNoExecution:true});console.log(JSON.stringify({status:errors.length?'FAIL':'PASS_DESIGN_INPUTS',errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--validate-release'){const errors=designInputErrorsR2({requireRelease:true,expectNoExecution:true});console.log(JSON.stringify({status:errors.length?'HELD':'PASS_RELEASE_FROZEN_LOCAL_INPUTS',errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--execute')console.log(JSON.stringify(executeR2({token}),null,2));else if(mode==='--validate-execution'){const errors=validateExecutionR2();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}`);}