mbx/mb-project-info.git

import fs from 'node:fs';
import path from 'node:path';
import crypto from 'node:crypto';
import {pathToFileURL} from 'node:url';
import * as prior from './detail_strengthening_p0_qualified7_evidence_acceptance_verification_runtime_repair002_20260730.mjs';
import {parseAuthorityCsv,serializeCsv,serializeManifestDataRows,validateAppendStableManifest} from './artifact_manifest_append_stable_parser_repair001_20260730.mjs';
 
export const ROOT=prior.ROOT,CASE_ID=prior.CASE_ID,BASE=prior.BASE,AUDIT_REPORT=prior.AUDIT_REPORT,MANIFEST=prior.MANIFEST,ANOMALY_AUTHORITY=prior.ANOMALY_AUTHORITY,ORIGINAL_TRIAGE_RUN=prior.ORIGINAL_TRIAGE_RUN;
export const DESIGN_ID='DESIGN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-001';
export const DESIGN_BATCH='BATCH-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-DESIGN-001';
export const DESIGN_RUN='RUN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-DESIGN-001';
export const EXEC_BATCH='BATCH-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-001';
export const EXEC_RUN='RUN-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-001';
export const EXEC_TOKEN='EXECUTE_DETAIL_STRENGTHENING_P0_ELIGIBLE6_FORMAL_EVIDENCE_INTEGRATION_001';
export const SOURCE_AUDIT='AUDIT-ANA-ROBOT-DETAIL-STRENGTHENING-P0-QUALIFIED7-EVIDENCE-ACCEPTANCE-VERIFICATION-EXEC-OUTPUT-001';
export const RELEASE_AUDIT='AUDIT-ANA-ROBOT-DETAIL-STRENGTHENING-P0-ELIGIBLE6-FORMAL-EVIDENCE-INTEGRATION-DESIGN-REREVIEW-001';
export const SCRIPT='dev/ana-dev/detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_20260730.mjs';
export const PROPOSAL_INPUT=prior.ACCEPTANCE_LEDGER,GAP_INPUT=prior.GAP_SUMMARY,APPLICATION_INPUT=prior.APPLICATION,CANDIDATES=prior.CANDIDATES,PROVENANCE=prior.PROVENANCE,RAW_ARCHIVE=prior.RAW_ARCHIVE,PROTECTED_INVENTORY=prior.PROTECTED_INVENTORY;
export const SOURCE_ENTRY_AUTHORITY=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_source_audit_authority_20260730.csv`;
export const CRITERIA=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_criteria_20260730.csv`;
export const ELIGIBLE_AUTHORITY=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_authority_20260730.csv`;
export const MAP_BASELINE=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_map_baseline_20260730.csv`;
export const MAP_TARGET=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_map_target_authority_20260730.csv`;
export const LEDGER_SCHEMA=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_map_change_ledger_schema_20260730.csv`;
export const CONTRACT=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_runtime_contract_20260730.csv`;
export const SCHEMA=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_schema_20260730.csv`;
export const FORMAL_ENTRY_AUTHORITY=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_formal_design_entry_authority_20260730.csv`;
export const EXEC_SET=`${BASE}/manifest/detail_strengthening_p0_eligible6_formal_evidence_integration_execution_artifact_set_20260730.csv`;
export const CASE_MAP=`${BASE}/evidence/case_evidence_map.csv`;
export const EXEC_BASELINE=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_execution_baseline_20260730.csv`;
export const ACCEPTED_REGISTER=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_register_20260730.csv`;
export const GAP_SUMMARY=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_gap_summary_20260730.csv`;
export const APPLICATION=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_integration_occurrence_application_20260730.csv`;
export const CHANGE_LEDGER=`${BASE}/evidence/detail_strengthening_p0_eligible6_formal_evidence_map_change_ledger_20260730.csv`;
export const EXEC_REQUEST=`${BASE}/manifest/review_request_detail_strengthening_p0_eligible6_formal_evidence_integration_execution_20260730.md`;
export const EXEC_VALIDATION=`${BASE}/manifest/detail_strengthening_p0_eligible6_formal_evidence_integration_execution_validation_20260730.csv`;
export const GENERATED=[EXEC_BASELINE,ACCEPTED_REGISTER,GAP_SUMMARY,APPLICATION,CHANGE_LEDGER,EXEC_REQUEST,EXEC_VALIDATION];
 
export const SOURCE_ENTRY_COLUMNS=prior.SOURCE_ENTRY_COLUMNS,EXEC_SET_COLUMNS=prior.EXEC_SET_COLUMNS,BASELINE_COLUMNS=prior.BASELINE_COLUMNS,VALIDATION_COLUMNS=prior.VALIDATION_COLUMNS,FORMAL_ENTRY_COLUMNS=prior.FORMAL_ENTRY_COLUMNS;
export const MAP_COLUMNS=['case_id','artifact','source_rel','evidence_status','evidence_entry','source_binding_ref','evidence_fact_plan_ref','review_status'];
export const CRITERIA_COLUMNS=['criterion_id','scope','gate','required_value_or_rule','failure_state'];
export const ELIGIBLE_COLUMNS=[...prior.DECISION_COLUMNS,'integration_id','integration_decision','formal_reference_state','gap_closure_effect'];
export const MAP_TARGET_COLUMNS=['target_row_id','row_action',...MAP_COLUMNS,'gap_state_after','claim_strength_after','formal_pool_effect','evidence_strength_effect'];
export const LEDGER_COLUMNS=['change_id','target_row_id','row_action','before_case_id','before_artifact','before_source_rel','before_evidence_status','before_evidence_entry','before_source_binding_ref','before_evidence_fact_plan_ref','before_review_status','after_case_id','after_artifact','after_source_rel','after_evidence_status','after_evidence_entry','after_source_binding_ref','after_evidence_fact_plan_ref','after_review_status','gap_state_after','claim_strength_after','formal_pool_effect','evidence_strength_effect','change_reason','validation_state'];
export const LEDGER_SCHEMA_COLUMNS=['column_order','column_name','data_type','nullable','source_rule','allowed_values','conditional_rule'];
export const GAP_SUMMARY_COLUMNS=['summary_id','conceptual_gap_key','accepted_reference_count','held_reference_count','formal_reference_state','gap_state_after','claim_strength_after','formal_pool_effect','evidence_strength_effect','gap_closure_effect'];
export const APPLICATION_COLUMNS=['application_id','target_id','source_occurrence_key','conceptual_gap_key','accepted_reference_count','held_reference_count','action','gap_state_after','claim_strength_after','formal_pool_effect','evidence_strength_effect','formal_map_effect','business_output_mutation'];
export const CONTRACT_COLUMNS=prior.CONTRACT_COLUMNS,SCHEMA_COLUMNS=prior.SCHEMA_COLUMNS;
 
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 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 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 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:hash(buffer),mtime:new Date(Math.trunc(stat.mtimeMs)).toISOString(),mtimeMs:Math.trunc(stat.mtimeMs)};};
const write=(file,text)=>{fs.mkdirSync(path.dirname(abs(file)),{recursive:true});fs.writeFileSync(abs(file),text,'utf8');};
const q=value=>`"${String(value??'').replaceAll('"','""')}"`;
export const serializeMap=rows=>`${[MAP_COLUMNS,...rows.map(row=>MAP_COLUMNS.map(column=>row[column]??''))].map(row=>row.map(q).join(',')).join('\r\n')}\r\n`;
 
export 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`),prefix=Buffer.from(`${lines.slice(0,end).join('\n')}\n`);return{start:start+1,end,lines:end-start,bytes:buffer.length,sha256:hash(buffer),text:buffer.toString('utf8'),prefix_bytes:prefix.length,prefix_sha256:hash(prefix)};}
export function sourceAuthorityRow(){const entry=auditEntry(SOURCE_AUDIT);if(!entry)throw new Error('SOURCE_AUDIT_MISSING');return{authority_id:'P0INT-SOURCE-AUDIT-001',audit_id:SOURCE_AUDIT,artifact_path:AUDIT_REPORT,start_line:String(entry.start),end_line:String(entry.end),normalized_lines:String(entry.lines),normalized_bytes:String(entry.bytes),normalized_sha256:entry.sha256,normalization:'UTF8_NO_BOM_LF_JOIN_LINES_WITH_TERMINAL_LF_V1',normalized_prefix_bytes:String(entry.prefix_bytes),normalized_prefix_sha256:entry.prefix_sha256,required_pass_literal:'result=PASS',required_allowed_literal:'Qualified7_evidence_acceptance_verification_execution_status=EXACT_RUN_PROPOSAL_PACKAGE_REVIEW_PASSED'};}
function sourceTextErrors(text,row){const lines=text.split('\n').map(canonicalLine),errors=[];for(const marker of [row.required_pass_literal,row.required_allowed_literal])if(lines.filter(line=>line===marker).length!==1)errors.push(`SOURCE_MARKER_COUNT:${marker}`);if(lines.some(line=>/^(?:result|conclusion|review_result)=FAIL(?:_|$)/.test(line))||lines.some(line=>/^Qualified7_evidence_acceptance_verification_execution_status=(?:FAIL|HELD|NOT_ALLOWED)/.test(line)))errors.push('SOURCE_AUDIT_CONTRADICTION');return errors;}
export function sourceAuthorityErrors(){if(!fs.existsSync(abs(SOURCE_ENTRY_AUTHORITY)))return['SOURCE_AUTHORITY_MISSING'];const parsed=readCsv(SOURCE_ENTRY_AUTHORITY),errors=[...exactColumns(parsed,SOURCE_ENTRY_COLUMNS,'SOURCE_AUTHORITY')];if(parsed.rows.length!==1)return[...errors,`SOURCE_AUTHORITY_COUNT:${parsed.rows.length}`];const row=parsed.rows[0],entry=auditEntry(row.audit_id),expected=sourceAuthorityRow();if(!entry)return[...errors,'SOURCE_ENTRY_MISSING'];for(const column of SOURCE_ENTRY_COLUMNS)if(String(row[column]??'')!==String(expected[column]??''))errors.push(`SOURCE_AUTHORITY_FIELD:${column}`);errors.push(...sourceTextErrors(entry.text,row));return[...new Set(errors)];}
 
export function criteriaRows(){return[
  ['P0INT-CRIT-001','SOURCE_AUDIT','source execution terminal','exact source entry PASS and proposal-package review passed','HELD_SOURCE_AUDIT'],
  ['P0INT-CRIT-002','ELIGIBLE_UNIVERSE','proposal outcome','exactly6 ACCEPTANCE_PROPOSAL_ELIGIBLE_PENDING_INDEPENDENT_REVIEW','HELD_ELIGIBLE_SET'],
  ['P0INT-CRIT-003','HELD_EXCLUSION','CAND-005','must remain HELD_BY_SUBJECT_IDENTITY_OR_SCOPE and absent from accepted register/map claim facts','HELD_SUBJECT_IDENTITY'],
  ['P0INT-CRIT-004','SOURCE_PROVENANCE','candidate/provenance/raw','candidate_id/query/url/locator/snippet hash/raw identity exact','HELD_PROVENANCE'],
  ['P0INT-CRIT-005','CLAIM_SCOPE','claim fields','subject/predicate/object/period/geography/qualifiers/exclusions exact and nonempty','HELD_CLAIM_SCOPE'],
  ['P0INT-CRIT-006','FORMAL_MAP_BASELINE','existing rows','45/45 rows byte and field exact before execution','HELD_MAP_BASELINE'],
  ['P0INT-CRIT-007','FORMAL_MAP_TARGET','controlled delta','exactly one new row EMAP-046 pointing to accepted register; existing45 unchanged','HELD_MAP_TARGET'],
  ['P0INT-CRIT-008','GAP_BOUNDARY','all conceptual gaps','7/7 OPEN_RETAINED_GAP after integration','HELD_GAP_STATE'],
  ['P0INT-CRIT-009','STRENGTH_AND_POOL','all accepted references','PENDING_VERIFICATION_MAX_NO_UPGRADE|NO_AUTOMATIC_FORMAL_POOL_CHANGE|NO_UPGRADE','HELD_UPGRADE'],
  ['P0INT-CRIT-010','TRANSACTION','map+manifest+outputs','baseline-first validation-last unified commit and exact rollback safety verification','ROLLBACK_INCOMPLETE_HELD'],
].map(([criterion_id,scope,gate,required_value_or_rule,failure_state])=>({criterion_id,scope,gate,required_value_or_rule,failure_state}));}
 
export function eligibleRows(){const proposals=readCsv(PROPOSAL_INPUT).rows.filter(row=>row.proposal_outcome==='ACCEPTANCE_PROPOSAL_ELIGIBLE_PENDING_INDEPENDENT_REVIEW');return proposals.map((row,index)=>({...row,integration_id:`P0INT-REF-${String(index+1).padStart(3,'0')}`,integration_decision:'ACCEPT_FOR_CONTROLLED_FORMAL_REFERENCE_REGISTRATION_PENDING_INDEPENDENT_EXECUTION_REVIEW',formal_reference_state:'CONTROLLED_FORMAL_REFERENCE_INTEGRATION_EXECUTED_PENDING_INDEPENDENT_REVIEW_WITH_OPEN_GAPS',gap_closure_effect:'NONE_GAP_REMAINS_OPEN'}));}
export function currentMapRows(){return readCsv(CASE_MAP).rows;}
export function mapTargetRows(baseline=currentMapRows()){const rows=baseline.map((row,index)=>({target_row_id:`EMAP-${String(index+1).padStart(3,'0')}`,row_action:'PRESERVE_EXISTING_EXACT',...row,gap_state_after:'INHERITED_RETAINED_GAPS',claim_strength_after:'INHERITED_NO_UPGRADE',formal_pool_effect:'NO_AUTOMATIC_FORMAL_POOL_CHANGE',evidence_strength_effect:'NO_UPGRADE'}));rows.push({target_row_id:'EMAP-046',row_action:'APPEND_ONE_ACCEPTED_REFERENCE_REGISTER',case_id:CASE_ID,artifact:ACCEPTED_REGISTER,source_rel:PROPOSAL_INPUT,evidence_status:'CONTROLLED_FORMAL_REFERENCE_INTEGRATION_EXECUTED_PENDING_INDEPENDENT_REVIEW_WITH_OPEN_GAPS',evidence_entry:`eligible6 controlled formal reference register; audit:${SOURCE_AUDIT}`,source_binding_ref:PROVENANCE,evidence_fact_plan_ref:`${CRITERIA}; ${ELIGIBLE_AUTHORITY}`,review_status:'PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW_NO_UPGRADE',gap_state_after:'OPEN_RETAINED_GAP',claim_strength_after:'PENDING_VERIFICATION_MAX_NO_UPGRADE',formal_pool_effect:'NO_AUTOMATIC_FORMAL_POOL_CHANGE',evidence_strength_effect:'NO_UPGRADE'});return rows;}
export function mapRowsFromTarget(target=mapTargetRows()){return target.map(row=>Object.fromEntries(MAP_COLUMNS.map(column=>[column,row[column]])));}
export function ledgerRows(baseline=currentMapRows(),target=mapTargetRows(baseline)){return target.map((row,index)=>{const before=baseline[index];return{change_id:`P0INT-MAPCHG-${String(index+1).padStart(3,'0')}`,target_row_id:row.target_row_id,row_action:row.row_action,before_case_id:before?.case_id??'',before_artifact:before?.artifact??'',before_source_rel:before?.source_rel??'',before_evidence_status:before?.evidence_status??'',before_evidence_entry:before?.evidence_entry??'',before_source_binding_ref:before?.source_binding_ref??'',before_evidence_fact_plan_ref:before?.evidence_fact_plan_ref??'',before_review_status:before?.review_status??'',after_case_id:row.case_id,after_artifact:row.artifact,after_source_rel:row.source_rel,after_evidence_status:row.evidence_status,after_evidence_entry:row.evidence_entry,after_source_binding_ref:row.source_binding_ref,after_evidence_fact_plan_ref:row.evidence_fact_plan_ref,after_review_status:row.review_status,gap_state_after:row.gap_state_after,claim_strength_after:row.claim_strength_after,formal_pool_effect:row.formal_pool_effect,evidence_strength_effect:row.evidence_strength_effect,change_reason:before?'PRESERVE_EXISTING_FORMAL_MAP_ROW_EXACT':'APPEND_ELIGIBLE6_REGISTER_REFERENCE_ONLY',validation_state:'GENERATED_PENDING_INDEPENDENT_EXECUTION_AND_OUTPUT_QUALITY_REVIEW'};});}
export function ledgerSchemaRows(){return LEDGER_COLUMNS.map((column,index)=>({column_order:String(index+1),column_name:column,data_type:['row_action','formal_pool_effect','evidence_strength_effect','validation_state'].includes(column)?'ENUM':'STRING',nullable:column.startsWith('before_')?'CONDITIONAL':'NO',source_rule:column.startsWith('before_')?'MAP_BASELINE_OR_EMPTY_FOR_EMAP046':column.startsWith('after_')?'MAP_TARGET':'DETERMINISTIC_RUNTIME',allowed_values:column==='row_action'?'PRESERVE_EXISTING_EXACT|APPEND_ONE_ACCEPTED_REFERENCE_REGISTER':column==='evidence_strength_effect'?'NO_UPGRADE':column==='formal_pool_effect'?'NO_AUTOMATIC_FORMAL_POOL_CHANGE':'FROZEN_AUTHORITY_VALUE',conditional_rule:column.startsWith('before_')?'NONEMPTY_FOR_EXISTING45_EMPTY_FOR_EMAP046':'EXACT_FIELD_BINDING'}));}
export function deriveOutputs(accepted=eligibleRows()){const sourceGaps=readCsv(GAP_INPUT).rows,sourceApps=readCsv(APPLICATION_INPUT).rows,proposals=readCsv(PROPOSAL_INPUT).rows,acceptedByGap=new Map(),heldByGap=new Map();for(const row of accepted)acceptedByGap.set(row.conceptual_gap_key,(acceptedByGap.get(row.conceptual_gap_key)??0)+1);for(const row of proposals.filter(row=>row.proposal_outcome==='HELD_BY_SUBJECT_IDENTITY_OR_SCOPE'))heldByGap.set(row.conceptual_gap_key,(heldByGap.get(row.conceptual_gap_key)??0)+1);const summary=sourceGaps.map((row,index)=>({summary_id:`P0INT-SUM-${String(index+1).padStart(3,'0')}`,conceptual_gap_key:row.conceptual_gap_key,accepted_reference_count:String(acceptedByGap.get(row.conceptual_gap_key)??0),held_reference_count:String(heldByGap.get(row.conceptual_gap_key)??0),formal_reference_state:(acceptedByGap.get(row.conceptual_gap_key)??0)>0?'CONTROLLED_REFERENCE_AVAILABLE_PENDING_GAP_CLOSURE_REVIEW':(heldByGap.get(row.conceptual_gap_key)??0)>0?'HELD_IDENTITY_NO_ACCEPTED_REFERENCE':'NO_ACCEPTED_REFERENCE',gap_state_after:'OPEN_RETAINED_GAP',claim_strength_after:'PENDING_VERIFICATION_MAX_NO_UPGRADE',formal_pool_effect:'NO_AUTOMATIC_FORMAL_POOL_CHANGE',evidence_strength_effect:'NO_UPGRADE',gap_closure_effect:'NONE_GAP_REMAINS_OPEN'}));const byGap=new Map(summary.map(row=>[row.conceptual_gap_key,row]));const applications=sourceApps.map((row,index)=>{const item=byGap.get(row.conceptual_gap_key);return{application_id:`P0INT-APP-${String(index+1).padStart(3,'0')}`,target_id:row.target_id,source_occurrence_key:row.source_occurrence_key,conceptual_gap_key:row.conceptual_gap_key,accepted_reference_count:item.accepted_reference_count,held_reference_count:item.held_reference_count,action:Number(item.accepted_reference_count)>0?'RETAIN_OPEN_WITH_CONTROLLED_FORMAL_REFERENCE_PENDING_GAP_CLOSURE_REVIEW':Number(item.held_reference_count)>0?'RETAIN_OPEN_HELD_IDENTITY':'RETAIN_OPEN_NO_ACCEPTED_REFERENCE',gap_state_after:'OPEN_RETAINED_GAP',claim_strength_after:'PENDING_VERIFICATION_MAX_NO_UPGRADE',formal_pool_effect:'NO_AUTOMATIC_FORMAL_POOL_CHANGE',evidence_strength_effect:'NO_UPGRADE',formal_map_effect:Number(item.accepted_reference_count)>0?'LINKED_VIA_SINGLE_EMAP046_REGISTER':'NONE',business_output_mutation:'NONE'};});return{summary,applications};}
 
export function contractRows(){const values=[
['SOURCE_ENTRY','exact entry identity and unique PASS/status markers'],['RELEASE_ENTRY','exact PASS/release/batch/run/network/ceiling/map effect'],['ELIGIBLE_SET','exact6 bidirectional and CAND005 excluded'],['PROPOSAL_FIELDS','all accepted rows exact against proposal input'],['PROVENANCE','candidate/query/url/locator/hash/raw closure'],['MAP_BASELINE_BYTES','current map exact 45-row baseline bytes'],['MAP_TARGET_ROWS','46 rows exact; existing45 unchanged; EMAP046 only new'],['MAP_SERIALIZATION','UTF8_NO_BOM_ALL_FIELDS_QUOTED_CRLF_TERMINAL_CRLF'],['REGISTER_ROWS','6 exact ordered by acceptance_id'],['SUMMARY_ROWS','7 exact and gaps open'],['APPLICATION_ROWS','10 exact and business_output_mutation NONE'],['CHANGE_LEDGER_ROWS','46 exact before/after rows'],['CAND005_HELD','absent from register and accepted claim'],['GAP_STATE','OPEN_RETAINED_GAP all7'],['CLAIM_CEILING','PENDING_VERIFICATION_MAX_NO_UPGRADE'],['FORMAL_POOL','NO_AUTOMATIC_FORMAL_POOL_CHANGE'],['EVIDENCE_STRENGTH','NO_UPGRADE'],['NETWORK','FROZEN_LOCAL_INPUTS_ONLY_NO_NETWORK'],['BASELINE_FIRST','runtime baseline first generated artifact'],['VALIDATION_LAST','validation final generated artifact'],['EXACT_SET','25 unique paths order1..25'],['MANIFEST','append25 data rows only seven-field exact mtime'],['PROTECTED49','identity unchanged'],['TRANSACTION','map outputs validation manifest under one try/catch'],['ROLLBACK_MAP','exact before bytes and mtime restored'],['ROLLBACK_MANIFEST','exact prefix bytes and mtime restored'],['ROLLBACK_GENERATED','all seven generated non-map files absent'],['ROLLBACK_POSTCHECK','unsafe rollback returns ROLLBACK_INCOMPLETE_HELD'],['NO_BUSINESS_OUTPUT','no business output or formal view mutation'],['NO_GAP_CLOSURE','formal reference availability does not close gap'],['NO_STRENGTH_UPGRADE','registration does not upgrade claim/evidence'],['POSTWRITE','full output and manifest oracle errors0'],['RETRY','existing execution outputs or run rows block retry'],['MAP_ROW_UNIQUENESS','46 artifact paths unique'],['VALIDATION_FAIL','any FAIL row blocks manifest commit']];return values.map((row,index)=>({contract_id:`P0INT-CON-${String(index+1).padStart(3,'0')}`,scope:index<18?'SEMANTIC_AND_AUTHORITY':'RUNTIME_AND_TRANSACTION',field_or_gate:row[0],required_value_or_rule:row[1],failure_state:row[0].startsWith('ROLLBACK')?'ROLLBACK_INCOMPLETE_HELD':'HELD_FAIL_CLOSED'}));}
export function schemaRows(){return[
  ['P0INT-SCHEMA-001','EXECUTION_BASELINE',BASELINE_COLUMNS.join('|'),'baseline_id','70','CSV_ALL_FIELDS_QUOTED_LF','runtime audit/manifest/map/input/protected identity snapshot'],
  ['P0INT-SCHEMA-002','ACCEPTED_REGISTER',ELIGIBLE_COLUMNS.join('|'),'integration_id','6','CSV_ALL_FIELDS_QUOTED_LF','eligible authority exact copy'],
  ['P0INT-SCHEMA-003','GAP_SUMMARY',GAP_SUMMARY_COLUMNS.join('|'),'summary_id','7','CSV_ALL_FIELDS_QUOTED_LF','accepted+held per conceptual gap'],
  ['P0INT-SCHEMA-004','OCCURRENCE_APPLICATION',APPLICATION_COLUMNS.join('|'),'application_id','10','CSV_ALL_FIELDS_QUOTED_LF','summary projected to frozen occurrences'],
  ['P0INT-SCHEMA-005','MAP_CHANGE_LEDGER',LEDGER_COLUMNS.join('|'),'change_id','46','CSV_ALL_FIELDS_QUOTED_LF','baseline45+target46 before/after'],
  ['P0INT-SCHEMA-006','FORMAL_EVIDENCE_MAP',MAP_COLUMNS.join('|'),'artifact','46','UTF8_NO_BOM_ALL_FIELDS_QUOTED_CRLF_TERMINAL_CRLF','target authority exact projection'],
  ['P0INT-SCHEMA-007','EXECUTION_REQUEST','MARKDOWN_KEY_VALUE','NOT_APPLICABLE','1','UTF8_NO_BOM_LF_TERMINAL_LF','exact requestText'],
  ['P0INT-SCHEMA-008','EXECUTION_VALIDATION',VALIDATION_COLUMNS.join('|'),'check_id','22','CSV_ALL_FIELDS_QUOTED_LF','validation-last fail closed'],
].map(([schema_id,artifact_role,column_order,primary_key,row_count_rule,serialization,derivation_rule])=>({schema_id,artifact_role,column_order,primary_key,row_count_rule,serialization,derivation_rule}));}
export function executionSetRows(){const paths=[SCRIPT,SOURCE_ENTRY_AUTHORITY,PROPOSAL_INPUT,GAP_INPUT,APPLICATION_INPUT,CANDIDATES,PROVENANCE,RAW_ARCHIVE,CRITERIA,ELIGIBLE_AUTHORITY,MAP_BASELINE,MAP_TARGET,LEDGER_SCHEMA,CONTRACT,SCHEMA,EXEC_SET,PROTECTED_INVENTORY,EXEC_BASELINE,ACCEPTED_REGISTER,GAP_SUMMARY,APPLICATION,CHANGE_LEDGER,CASE_MAP,EXEC_REQUEST,EXEC_VALIDATION],roles=['RUNTIME','SOURCE_AUDIT_AUTHORITY','PROPOSAL_INPUT','PREDECESSOR_GAP_INPUT','PREDECESSOR_APPLICATION_INPUT','CANDIDATE_INPUT','PROVENANCE_INPUT','RAW_ARCHIVE_INPUT','INTEGRATION_CRITERIA','ELIGIBLE6_AUTHORITY','FORMAL_MAP_BASELINE','FORMAL_MAP_TARGET_AUTHORITY','CHANGE_LEDGER_SCHEMA','RUNTIME_CONTRACT','OUTPUT_SCHEMA','EXECUTION_EXACT_SET','PROTECTED49_AUTHORITY','RUNTIME_BASELINE_FIRST_GENERATED','ACCEPTED_REFERENCE_REGISTER','GAP_SUMMARY','OCCURRENCE_APPLICATION','MAP_CHANGE_LEDGER','FORMAL_EVIDENCE_MAP_CONTROLLED_AFTER','EXECUTION_REQUEST','VALIDATION_LAST'];return paths.map((artifactPath,index)=>({artifact_id:`P0INT-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'}));}
 
function manifestState({expectedRows=[],expectedRunId='',frozenPrefix=null,expectedPhysicalDelta=null}={}){return validateAppendStableManifest(fs.readFileSync(abs(MANIFEST)),{anomalyRows:readCsv(ANOMALY_AUTHORITY).rows,frozenPrefix,originalRunId:ORIGINAL_TRIAGE_RUN,originalRunExpectedRows:11,expectedRunRows:expectedRows,expectedRunId,expectedPhysicalDelta,filesystemIdentity:{runIds:expectedRunId?[expectedRunId]:[],get:file=>fs.existsSync(abs(file))?identity(file):null}});}
function protectedRows(){const rows=readCsv(PROTECTED_INVENTORY).rows;if(rows.length!==49)throw new Error(`PROTECTED_COUNT:${rows.length}`);return rows.map(row=>({path:row.artifact_path,...identity(row.artifact_path)}));}
function formalEntryErrors(){if(!fs.existsSync(abs(FORMAL_ENTRY_AUTHORITY)))return['FORMAL_ENTRY_AUTHORITY_MISSING'];const parsed=readCsv(FORMAL_ENTRY_AUTHORITY),errors=[...exactColumns(parsed,FORMAL_ENTRY_COLUMNS,'FORMAL_ENTRY')];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;}
export function releaseTextErrors(text){const lines=text.split('\n').map(canonicalLine),required=['result=PASS','execution_release=EXPLICITLY_RELEASED',`released_batch_id=${EXEC_BATCH}`,`released_run_id=${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 releaseErrors({required=false}={}){const entry=auditEntry(RELEASE_AUDIT);return entry?releaseTextErrors(entry.text):required?['RELEASE_AUDIT_MISSING']:[];}
export function predecessorAppendStableErrors(rawErrors=prior.validateExecution()){const delta=rawErrors.filter(code=>/^MANIFEST:PHYSICAL_RECORD_DELTA:\d+:18$/.test(code)),errors=rawErrors.filter(code=>!/^MANIFEST:PHYSICAL_RECORD_DELTA:\d+:18$/.test(code));if(delta.length>1)errors.push(`PREDECESSOR_APPEND_DELTA_SIGNAL_COUNT:${delta.length}`);return errors;}
 
export function coreErrors({eligible=eligibleRows(),target=mapTargetRows(readCsv(MAP_BASELINE).rows),accepted=null,summary=null,applications=null,ledger=null,mapRows=null}={}){const errors=[],expectedEligible=eligibleRows(),baseline=readCsv(MAP_BASELINE).rows,expectedTarget=mapTargetRows(baseline),derived=deriveOutputs(eligible);errors.push(...predecessorAppendStableErrors().map(code=>`PREDECESSOR:${code}`),...compareRows(eligible,expectedEligible,ELIGIBLE_COLUMNS,'ELIGIBLE'),...compareRows(target,expectedTarget,MAP_TARGET_COLUMNS,'MAP_TARGET'));if(expectedEligible.length!==6)errors.push(`ELIGIBLE_COUNT:${expectedEligible.length}:6`);if(new Set(expectedEligible.map(row=>row.candidate_id)).size!==6)errors.push('ELIGIBLE_UNIQUE');if(expectedEligible.some(row=>row.candidate_id==='P0DISCR1-CAND-005'))errors.push('HELD_CAND005_INCLUDED');if(baseline.length!==45)errors.push(`MAP_BASELINE_COUNT:${baseline.length}:45`);if(target.length!==46)errors.push(`MAP_TARGET_COUNT:${target.length}:46`);if(new Set(target.map(row=>row.artifact)).size!==46)errors.push('MAP_ARTIFACT_UNIQUE');for(let i=0;i<45;i++)for(const column of MAP_COLUMNS)if(String(target[i]?.[column]??'')!==String(baseline[i]?.[column]??'')){errors.push(`MAP_EXISTING_DRIFT:${i+1}:${column}`);break;}const added=target[45];if(!added||added.target_row_id!=='EMAP-046'||added.artifact!==ACCEPTED_REGISTER||added.gap_state_after!=='OPEN_RETAINED_GAP'||added.claim_strength_after!=='PENDING_VERIFICATION_MAX_NO_UPGRADE'||added.formal_pool_effect!=='NO_AUTOMATIC_FORMAL_POOL_CHANGE'||added.evidence_strength_effect!=='NO_UPGRADE')errors.push('MAP_EMAP046_BOUNDARY');for(const row of eligible){if(row.gap_state_after!=='OPEN_RETAINED_GAP'||row.claim_strength_after!=='PENDING_VERIFICATION_MAX_NO_UPGRADE'||row.formal_pool_effect!=='NO_AUTOMATIC_FORMAL_POOL_CHANGE'||row.evidence_strength_effect!=='NO_UPGRADE'||row.gap_closure_effect!=='NONE_GAP_REMAINS_OPEN')errors.push(`ELIGIBLE_BOUNDARY:${row.candidate_id}`);if(!row.accepted_claim_text||!row.excluded_inferences||!row.content_locator||!row.snippet_text_sha256)errors.push(`ELIGIBLE_FIELDS:${row.candidate_id}`);}if(accepted)errors.push(...compareRows(accepted,expectedEligible,ELIGIBLE_COLUMNS,'REGISTER'));if(summary)errors.push(...compareRows(summary,derived.summary,GAP_SUMMARY_COLUMNS,'SUMMARY'));if(applications)errors.push(...compareRows(applications,derived.applications,APPLICATION_COLUMNS,'APPLICATION'));if(ledger)errors.push(...compareRows(ledger,ledgerRows(baseline,expectedTarget),LEDGER_COLUMNS,'LEDGER'));if(mapRows)errors.push(...compareRows(mapRows,mapRowsFromTarget(expectedTarget),MAP_COLUMNS,'FORMAL_MAP'));if(summary&&summary.some(row=>row.gap_state_after!=='OPEN_RETAINED_GAP'||row.gap_closure_effect!=='NONE_GAP_REMAINS_OPEN'))errors.push('SUMMARY_GAP_CLOSED');if(applications&&applications.some(row=>row.business_output_mutation!=='NONE'||row.evidence_strength_effect!=='NO_UPGRADE'))errors.push('APPLICATION_MUTATION');return[...new Set(errors)];}
 
export function designInputErrors({requireRelease=false,expectNoExecution=true}={}){const errors=[...sourceAuthorityErrors(),...formalEntryErrors(),...releaseErrors({required:requireRelease})],files=[PROPOSAL_INPUT,GAP_INPUT,APPLICATION_INPUT,CANDIDATES,PROVENANCE,RAW_ARCHIVE,CRITERIA,ELIGIBLE_AUTHORITY,MAP_BASELINE,MAP_TARGET,LEDGER_SCHEMA,CONTRACT,SCHEMA,EXEC_SET,PROTECTED_INVENTORY];for(const file of files)if(!fs.existsSync(abs(file)))errors.push(`INPUT_MISSING:${file}`);if(errors.some(error=>error.startsWith('INPUT_MISSING')))return[...new Set(errors)];const criteria=readCsv(CRITERIA),eligible=readCsv(ELIGIBLE_AUTHORITY),baseline=readCsv(MAP_BASELINE),target=readCsv(MAP_TARGET),ledgerSchema=readCsv(LEDGER_SCHEMA),contracts=readCsv(CONTRACT),schemas=readCsv(SCHEMA),execSet=readCsv(EXEC_SET);errors.push(...exactColumns(criteria,CRITERIA_COLUMNS,'CRITERIA'),...compareRows(criteria.rows,criteriaRows(),CRITERIA_COLUMNS,'CRITERIA'),...exactColumns(eligible,ELIGIBLE_COLUMNS,'ELIGIBLE'),...exactColumns(baseline,MAP_COLUMNS,'MAP_BASELINE'),...exactColumns(target,MAP_TARGET_COLUMNS,'MAP_TARGET'),...exactColumns(ledgerSchema,LEDGER_SCHEMA_COLUMNS,'LEDGER_SCHEMA'),...compareRows(ledgerSchema.rows,ledgerSchemaRows(),LEDGER_SCHEMA_COLUMNS,'LEDGER_SCHEMA'),...exactColumns(contracts,CONTRACT_COLUMNS,'CONTRACT'),...compareRows(contracts.rows,contractRows(),CONTRACT_COLUMNS,'CONTRACT'),...exactColumns(schemas,SCHEMA_COLUMNS,'SCHEMA'),...compareRows(schemas.rows,schemaRows(),SCHEMA_COLUMNS,'SCHEMA'),...exactColumns(execSet,EXEC_SET_COLUMNS,'EXEC_SET'),...compareRows(execSet.rows,executionSetRows(),EXEC_SET_COLUMNS,'EXEC_SET'),...coreErrors({eligible:eligible.rows,target:target.rows}));if(!fs.readFileSync(abs(CASE_MAP)).equals(fs.readFileSync(abs(MAP_BASELINE))))errors.push('MAP_BASELINE_BYTES_DRIFT');if(expectNoExecution){if(GENERATED.some(file=>fs.existsSync(abs(file))))errors.push('EXECUTION_FILES_EXIST');if(manifestState().logicalRows.some(row=>row.run_id===EXEC_RUN))errors.push('EXECUTION_MANIFEST_ROWS');}return[...new Set(errors)];}
 
function baselineRows(){const source=auditEntry(SOURCE_AUDIT),release=auditEntry(RELEASE_AUDIT),manifest=fs.readFileSync(abs(MANIFEST)),mapBefore=identity(CASE_MAP);if(!source||!release)throw new Error('AUDIT_ENTRY_MISSING');const rows=[{baseline_id:'P0INT-BASE-001',identity_type:'SOURCE_EXECUTION_AUDIT_ENTRY',artifact_path:`${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:'P0INT-BASE-002',identity_type:'DESIGN_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_RELEASE_MARKERS'},{baseline_id:'P0INT-BASE-003',identity_type:'RAW_MANIFEST_BEFORE_EXECUTION',artifact_path:MANIFEST,rows:String(manifestState().logicalDataRows),bytes:String(manifest.length),sha256:hash(manifest),mtime:new Date(Math.trunc(fs.statSync(abs(MANIFEST)).mtimeMs)).toISOString(),required_state:'EXACT_APPEND_ONLY_PREFIX'},{baseline_id:'P0INT-BASE-004',identity_type:'FORMAL_MAP_BEFORE_EXECUTION',artifact_path:CASE_MAP,rows:String(mapBefore.rows),bytes:String(mapBefore.bytes),sha256:mapBefore.sha256,mtime:mapBefore.mtime,required_state:'EXACT45_RESTORABLE'}];for(const file of executionSetRows().slice(0,17).map(row=>row.artifact_path)){const id=identity(file);rows.push({baseline_id:`P0INT-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:`P0INT-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 baselineErrors(rows){const errors=[];if(rows.length!==70)return[`BASELINE_COUNT:${rows.length}:70`];for(const [row,entry,code] of [[rows[0],auditEntry(SOURCE_AUDIT),'SOURCE'],[rows[1],auditEntry(RELEASE_AUDIT),'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(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 mapRow=rows[3],mapId=identity(MAP_BASELINE);if(mapRow.rows!=='45'||mapRow.bytes!==String(mapId.bytes)||mapRow.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=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 requestText(){return`# Eligible6 formal evidence integration execution review request\n\ncase_id=${CASE_ID}\nsource_audit=${SOURCE_AUDIT}\nrelease_audit=${RELEASE_AUDIT}\nbatch_id=${EXEC_BATCH}\nrun_id=${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\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\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 validationRows(state){const errors=coreErrors(state),checks=[['CORE_ERRORS','0',String(errors.length)],['SOURCE_AUTHORITY_ERRORS','0',String(sourceAuthorityErrors().length)],['ACCEPTED_REGISTER','6',String(state.accepted.length)],['HELD_EXCLUDED','0',String(state.accepted.filter(row=>row.candidate_id==='P0DISCR1-CAND-005').length)],['MAP_BASELINE','45','45'],['MAP_TARGET','46',String(state.target.length)],['MAP_EXISTING_UNCHANGED','0',String(errors.filter(code=>code.startsWith('MAP_EXISTING_DRIFT')).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)],['EXACT_SET','25',String(executionSetRows().length)],['BASELINE','70','70'],['MANIFEST_DELTA','25','25'],['PROTECTED49','49','49']];const rows=checks.map((item,index)=>({check_id:`P0INT-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:'ELIGIBLE6_FORMAL_REFERENCE_INTEGRATION_FAIL_CLOSED_ORACLE'}));rows.push({check_id:'P0INT-EXEC-VAL-022',check_description:'SELF_REFERENCE_EXCLUDED',expected:'SELF_REFERENCE_EXCLUDED',actual:'SELF_REFERENCE_EXCLUDED',status:'INFO',evidence:'validation and manifest identities 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};});}
function rollbackTo(before){const cleanup=[];const restore=(file,buffer,stat)=>{try{fs.writeFileSync(abs(file),buffer);fs.utimesSync(abs(file),stat.atime,stat.mtime);}catch(primary){try{fs.writeFileSync(abs(file),buffer);fs.utimesSync(abs(file),stat.atime,stat.mtime);}catch(fallback){cleanup.push(`RESTORE:${file}:${primary.message}:${fallback.message}`);}}};restore(MANIFEST,before.manifest,before.manifestStat);restore(CASE_MAP,before.map,before.mapStat);for(const file of GENERATED)if(fs.existsSync(abs(file)))try{fs.rmSync(abs(file));}catch(primary){try{fs.unlinkSync(abs(file));}catch(fallback){cleanup.push(`REMOVE:${file}:${primary.message}:${fallback.message}`);}}const manifestOk=fs.readFileSync(abs(MANIFEST)).equals(before.manifest)&&Math.trunc(fs.statSync(abs(MANIFEST)).mtimeMs)===Math.trunc(before.manifestStat.mtimeMs),mapOk=fs.readFileSync(abs(CASE_MAP)).equals(before.map)&&Math.trunc(fs.statSync(abs(CASE_MAP)).mtimeMs)===Math.trunc(before.mapStat.mtimeMs),generatedAbsent=GENERATED.every(file=>!fs.existsSync(abs(file)));if(!manifestOk)cleanup.push('POSTCHECK_MANIFEST');if(!mapOk)cleanup.push('POSTCHECK_MAP');if(!generatedAbsent)cleanup.push('POSTCHECK_GENERATED');return cleanup;}
 
export function execute({token}={}){if(token!==EXEC_TOKEN)throw new Error('EXECUTION_TOKEN_MISMATCH');const pre=designInputErrors({requireRelease:true,expectNoExecution:true});if(pre.length)throw new Error(`PREWRITE:${pre.join('|')}`);const before={manifest:fs.readFileSync(abs(MANIFEST)),manifestStat:fs.statSync(abs(MANIFEST)),map:fs.readFileSync(abs(CASE_MAP)),mapStat:fs.statSync(abs(CASE_MAP))};try{write(EXEC_BASELINE,serializeCsv(baselineRows(),BASELINE_COLUMNS));const accepted=readCsv(ELIGIBLE_AUTHORITY).rows,target=readCsv(MAP_TARGET).rows,derived=deriveOutputs(accepted),ledger=ledgerRows(readCsv(MAP_BASELINE).rows,target),mapRows=mapRowsFromTarget(target),state={eligible:accepted,target,accepted,summary:derived.summary,applications:derived.applications,ledger,mapRows};write(ACCEPTED_REGISTER,serializeCsv(accepted,ELIGIBLE_COLUMNS));write(GAP_SUMMARY,serializeCsv(derived.summary,GAP_SUMMARY_COLUMNS));write(APPLICATION,serializeCsv(derived.applications,APPLICATION_COLUMNS));write(CHANGE_LEDGER,serializeCsv(ledger,LEDGER_COLUMNS));write(CASE_MAP,serializeMap(mapRows));write(EXEC_REQUEST,requestText());const validation=validationRows(state);write(EXEC_VALIDATION,serializeCsv(validation,VALIDATION_COLUMNS));if(validation.some(row=>row.status==='FAIL'))throw new Error('VALIDATION_FAIL');const rows=manifestRowsFor(executionSetRows().map(row=>row.artifact_path)),candidate=Buffer.concat([before.manifest,Buffer.from(serializeManifestDataRows(rows),'utf8')]),candidateState=validateAppendStableManifest(candidate,{anomalyRows:readCsv(ANOMALY_AUTHORITY).rows,frozenPrefix:{bytes:before.manifest.length,sha256:hash(before.manifest)},originalRunId:ORIGINAL_TRIAGE_RUN,originalRunExpectedRows:11,expectedRunRows:rows,expectedRunId:EXEC_RUN,expectedPhysicalDelta:25});if(candidateState.errors.length)throw new Error(`MANIFEST_CANDIDATE:${candidateState.errors.join('|')}`);fs.writeFileSync(abs(MANIFEST),candidate);const post=validateExecution();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,manifest_rows:25};}catch(error){const cleanup=rollbackTo(before);if(cleanup.length)throw new Error(`ROLLBACK_INCOMPLETE_HELD:${cleanup.join('|')}:${error.message}`);throw error;}}
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),accepted=readCsv(ACCEPTED_REGISTER),summary=readCsv(GAP_SUMMARY),applications=readCsv(APPLICATION),ledger=readCsv(CHANGE_LEDGER),validation=readCsv(EXEC_VALIDATION),target=readCsv(MAP_TARGET).rows,mapRows=readCsv(CASE_MAP),state={eligible:accepted.rows,target,accepted:accepted.rows,summary:summary.rows,applications:applications.rows,ledger:ledger.rows,mapRows:mapRows.rows};errors.push(...sourceAuthorityErrors(),...exactColumns(baseline,BASELINE_COLUMNS,'BASELINE'),...baselineErrors(baseline.rows),...exactColumns(accepted,ELIGIBLE_COLUMNS,'REGISTER'),...exactColumns(summary,GAP_SUMMARY_COLUMNS,'SUMMARY'),...exactColumns(applications,APPLICATION_COLUMNS,'APPLICATION'),...exactColumns(ledger,LEDGER_COLUMNS,'LEDGER'),...exactColumns(mapRows,MAP_COLUMNS,'FORMAL_MAP'),...exactColumns(validation,VALIDATION_COLUMNS,'VALIDATION'),...coreErrors(state));if(fs.readFileSync(abs(CASE_MAP),'utf8')!==serializeMap(mapRowsFromTarget(target)))errors.push('FORMAL_MAP_SERIALIZATION');if(normalize(fs.readFileSync(abs(EXEC_REQUEST)))!==requestText())errors.push('REQUEST_TEXT');if(validation.rows.length!==22||validation.rows.some(row=>row.status==='FAIL'))errors.push('VALIDATION_STATUS');const expected=manifestRowsFor(executionSetRows().map(row=>row.artifact_path)),prefix=baseline.rows[2],manifest=manifestState({expectedRows:expected,expectedRunId:EXEC_RUN,frozenPrefix:{bytes:Number(prefix.bytes),sha256:prefix.sha256},expectedPhysicalDelta:25});errors.push(...manifest.errors.map(code=>`MANIFEST:${code}`));return[...new Set(errors)];}
 
export function negativeRows(){const clean={eligible:eligibleRows(),target:mapTargetRows(readCsv(MAP_BASELINE).rows)},cases=[
['CLEAN',()=>structuredClone(clean),'ACCEPT','NONE'],['INCLUDE_CAND005',()=>{const s=structuredClone(clean);s.eligible[0].candidate_id='P0DISCR1-CAND-005';return s;},'REJECT','ELIGIBLE_FIELD'],['REMOVE_ELIGIBLE',()=>{const s=structuredClone(clean);s.eligible.pop();return s;},'REJECT','ELIGIBLE_COUNT'],['CLAIM_TAMPER',()=>{const s=structuredClone(clean);s.eligible[0].accepted_claim_text='tamper';return s;},'REJECT','ELIGIBLE_FIELD'],['LOCATOR_TAMPER',()=>{const s=structuredClone(clean);s.eligible[0].content_locator='bad';return s;},'REJECT','ELIGIBLE_FIELD'],['HASH_TAMPER',()=>{const s=structuredClone(clean);s.eligible[0].snippet_text_sha256='0'.repeat(64);return s;},'REJECT','ELIGIBLE_FIELD'],['GAP_CLOSE',()=>{const s=structuredClone(clean);s.eligible[0].gap_state_after='CLOSED';return s;},'REJECT','ELIGIBLE_FIELD'],['STRENGTH_UPGRADE',()=>{const s=structuredClone(clean);s.eligible[0].evidence_strength_effect='UPGRADE';return s;},'REJECT','ELIGIBLE_FIELD'],['MAP_EXISTING_DRIFT',()=>{const s=structuredClone(clean);s.target[0].evidence_status='tamper';return s;},'REJECT','MAP_TARGET_FIELD'],['MAP_EXTRA_ROW',()=>{const s=structuredClone(clean);s.target.push({...s.target[45],target_row_id:'EMAP-047',artifact:'extra'});return s;},'REJECT','MAP_TARGET_COUNT'],['MAP_NEW_WRONG_ARTIFACT',()=>{const s=structuredClone(clean);s.target[45].artifact='wrong';return s;},'REJECT','MAP_TARGET_FIELD'],['MAP_NEW_CLOSE',()=>{const s=structuredClone(clean);s.target[45].gap_state_after='CLOSED';return s;},'REJECT','MAP_TARGET_FIELD']
];const rows=cases.map((item,index)=>{const s=item[1](),errors=coreErrors({eligible:s.eligible,target:s.target}),actual=errors.length?'REJECT':'ACCEPT';return{test_id:`P0INT-NEG-${String(index+1).padStart(3,'0')}-${item[0]}`,mutation_applied:index?'YES':'NO_CLEAN_CONTROL',oracle:'coreErrors',expected:item[2],expected_code:item[3],actual,actual_codes:errors.join('|')||'NONE',result:actual===item[2]&&(item[3]==='NONE'||errors.some(error=>error.startsWith(item[3])))?'PASS':'FAIL'};});const good=['result=PASS','execution_release=EXPLICITLY_RELEASED',`released_batch_id=${EXEC_BATCH}`,`released_run_id=${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'].join('\n'),releaseCases=[['RELEASE_CLEAN',good,'ACCEPT','NONE'],['RELEASE_FAIL',`${good}\nresult=FAIL`,'REJECT','RELEASE_CONTRADICTION'],['RELEASE_DUPLICATE',`${good}\nresult=PASS`,'REJECT','RELEASE_MARKER_COUNT'],['RELEASE_WRONG_RUN',good.replace(`released_run_id=${EXEC_RUN}`,'released_run_id=WRONG'),'REJECT','RELEASE_MARKER_COUNT']];for(const item of releaseCases){const errors=releaseTextErrors(item[1]),actual=errors.length?'REJECT':'ACCEPT';rows.push({test_id:`P0INT-NEG-${String(rows.length+1).padStart(3,'0')}-${item[0]}`,mutation_applied:item[0]==='RELEASE_CLEAN'?'NO_CLEAN_CONTROL':'YES',oracle:'releaseTextErrors',expected:item[2],expected_code:item[3],actual,actual_codes:errors.join('|')||'NONE',result:actual===item[2]&&(item[3]==='NONE'||errors.some(error=>error.startsWith(item[3])))?'PASS':'FAIL'});}const predecessorCases=[['PREDECESSOR_APPEND_TAIL',['MANIFEST:PHYSICAL_RECORD_DELTA:43:18'],'ACCEPT','NONE'],['PREDECESSOR_OTHER_ERROR',['MANIFEST:RUN_ID_MISMATCH'],'REJECT','MANIFEST:RUN_ID_MISMATCH'],['PREDECESSOR_WRONG_DELTA',['MANIFEST:PHYSICAL_RECORD_DELTA:43:17'],'REJECT','MANIFEST:PHYSICAL_RECORD_DELTA:43:17']];for(const item of predecessorCases){const errors=predecessorAppendStableErrors(item[1]),actual=errors.length?'REJECT':'ACCEPT';rows.push({test_id:`P0INT-NEG-${String(rows.length+1).padStart(3,'0')}-${item[0]}`,mutation_applied:item[0]==='PREDECESSOR_APPEND_TAIL'?'NO_CLEAN_CONTROL':'YES',oracle:'predecessorAppendStableErrors',expected:item[2],expected_code:item[3],actual,actual_codes:errors.join('|')||'NONE',result:actual===item[2]&&(item[3]==='NONE'||errors.some(error=>error.startsWith(item[3])))?'PASS':'FAIL'});}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 eligible=eligibleRows(),target=mapTargetRows(currentMapRows()),derived=deriveOutputs(eligible),errors=fs.existsSync(abs(MAP_BASELINE))?coreErrors({eligible,target:mapTargetRows(readCsv(MAP_BASELINE).rows),accepted:eligible,summary:derived.summary,applications:derived.applications,ledger:ledgerRows(readCsv(MAP_BASELINE).rows,mapTargetRows(readCsv(MAP_BASELINE).rows)),mapRows:mapRowsFromTarget(mapTargetRows(readCsv(MAP_BASELINE).rows))}):[];console.log(JSON.stringify({status:errors.length?'FAIL':'PREVIEW_PASS',eligible:eligible.length,held:1,map_before:45,map_after:46,summary:7,applications:10,ledger:46,contracts:contractRows().length,schemas:schemaRows().length,exact_set:executionSetRows().length,errors},null,2));if(errors.length)process.exitCode=1;}else if(mode==='--self-test'){const rows=negativeRows();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=designInputErrors({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=designInputErrors({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(execute({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}`);}