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 rt from './detail_strengthening_p0_qualified4_evidence_acceptance_verification_runtime_20260801.mjs';
import {parseAuthorityCsv,serializeCsv,serializeManifestDataRows,validateAppendStableManifest} from './artifact_manifest_append_stable_parser_repair001_20260730.mjs';
 
const BUILDER='dev/ana-dev/detail_strengthening_p0_qualified4_evidence_acceptance_verification_design_20260801.mjs';
const DESIGN_BASELINE=`${rt.BASE}/evidence/detail_strengthening_p0_qualified4_evidence_acceptance_design_baseline_20260801.csv`;
const NEGATIVE_RESULTS=`${rt.BASE}/evidence/detail_strengthening_p0_qualified4_evidence_acceptance_negative_results_20260801.csv`;
const DESIGN_SET=`${rt.BASE}/manifest/detail_strengthening_p0_qualified4_evidence_acceptance_design_artifact_set_20260801.csv`;
const DESIGN_VALIDATION=`${rt.BASE}/manifest/detail_strengthening_p0_qualified4_evidence_acceptance_design_validation_20260801.csv`;
const REVIEW_REQUEST=`${rt.BASE}/manifest/review_request_detail_strengthening_p0_qualified4_evidence_acceptance_design_20260801.md`;
const DESIGN_SET_COLUMNS=['artifact_id','batch_id','run_id','generation_order','artifact_path','artifact_role','identity_policy'];
const NEGATIVE_COLUMNS=['test_id','mutation_applied','oracle','expected','expected_code','actual','actual_codes','result'];
const BASELINE_COLUMNS=rt.BASELINE_COLUMNS;
const VALIDATION_COLUMNS=rt.VALIDATION_COLUMNS;
const abs=file=>path.join(rt.ROOT,...file.split('/'));
const normalize=value=>Buffer.isBuffer(value)?value.toString('utf8').replace(/^\uFEFF/,'').replace(/\r\n/g,'\n').replace(/\r/g,'\n'):String(value).replace(/^\uFEFF/,'').replace(/\r\n/g,'\n').replace(/\r/g,'\n');
const hash=value=>crypto.createHash('sha256').update(value).digest('hex');
const readCsv=file=>{const parsed=parseAuthorityCsv(normalize(fs.readFileSync(abs(file))));if(parsed.errors.length)throw new Error(`${file}:${parsed.errors.join('|')}`);return parsed;};
const write=(file,bytes)=>{fs.mkdirSync(path.dirname(abs(file)),{recursive:true});fs.writeFileSync(abs(file),bytes);};
const identity=file=>{const buffer=fs.readFileSync(abs(file)),stat=fs.statSync(abs(file));return{sha256:hash(buffer),bytes:String(buffer.length),mtime:new Date(Math.trunc(stat.mtimeMs)).toISOString()};};
 
function entryAuthority(id,file,authorityId,markers){
  const entry=rt.entryById(file,id);if(!entry)throw new Error(`ENTRY_MISSING_OR_DUPLICATE:${id}`);
  return[{authority_id:authorityId,audit_or_design_id:id,artifact_path:file,start_line:String(entry.startLine),end_line:String(entry.endLine),normalized_lines:String(entry.lines),normalized_bytes:String(entry.bytes),normalized_sha256:entry.sha256,required_marker_1:markers[0],required_marker_2:markers[1],required_marker_3:markers[2]}];
}
 
function baselineRows(manifestBefore){
  const files=[rt.QUALIFICATION_INPUT,rt.CANDIDATES,rt.PROVENANCE,rt.RAW_ARCHIVE,rt.GAP_INPUT,rt.APPLICATION_INPUT,rt.PROTECTED_INVENTORY,rt.FAULT_RESULTS,rt.AUDIT_REPORT,rt.DESIGN_DOC];
  const rows=files.map((file,index)=>{const id=identity(file);return{baseline_id:`P0Q4ACC-DES-BASE-${String(index+1).padStart(3,'0')}`,artifact_role:'DESIGN_INPUT',artifact_path:file,sha256:id.sha256,bytes:id.bytes,mtime:id.mtime,required_state:'EXACT_AT_DESIGN_BUILD'};});
  const stat=fs.statSync(abs(rt.MANIFEST));rows.push({baseline_id:'P0Q4ACC-DES-BASE-MANIFEST',artifact_role:'MANIFEST_PREFIX',artifact_path:rt.MANIFEST,sha256:hash(manifestBefore),bytes:String(manifestBefore.length),mtime:new Date(Math.trunc(stat.mtimeMs)).toISOString(),required_state:'IMMUTABLE_PREFIX_BEFORE_DESIGN_APPEND'});return rows;
}
 
function designSetRows(){
  const paths=[BUILDER,rt.SCRIPT,rt.SOURCE_ENTRY_AUTHORITY,rt.FORMAL_ENTRY_AUTHORITY,rt.CRITERIA,rt.DECISION_AUTHORITY,rt.CONTRACT,rt.SCHEMA,rt.EXEC_SET,DESIGN_BASELINE,NEGATIVE_RESULTS,DESIGN_SET,REVIEW_REQUEST,DESIGN_VALIDATION];
  const roles=['DESIGN_BUILDER','EXECUTION_RUNTIME','SOURCE_AUDIT_ENTRY_AUTHORITY','FORMAL_DESIGN_ENTRY_AUTHORITY','ACCEPTANCE_CRITERIA','DECISION_AUTHORITY','RUNTIME_CONTRACT','OUTPUT_SCHEMA','EXECUTION_EXACT_SET','DESIGN_BASELINE','NEGATIVE_RESULTS','DESIGN_ARTIFACT_SET','DESIGN_REVIEW_REQUEST','DESIGN_VALIDATION_LAST'];
  return paths.map((artifactPath,index)=>({artifact_id:`P0Q4ACC-DES-SET-${String(index+1).padStart(3,'0')}`,batch_id:rt.DESIGN_BATCH,run_id:rt.DESIGN_RUN,generation_order:String(index+1),artifact_path:artifactPath,artifact_role:roles[index],identity_policy:'EXACT_SHA256_BYTES_FILESYSTEM_MTIME_MS'}));
}
 
function requestText(){return `# Qualified4 证据接受/核验详细设计独立审核请求\n\n- case_id: ${rt.CASE_ID}\n- action_id: NEXT-ROBOT-047-DESIGN-001\n- design_id: ${rt.DESIGN_ID}\n- design_batch_id: ${rt.DESIGN_BATCH}\n- design_run_id: ${rt.DESIGN_RUN}\n- proposed_batch_id: ${rt.EXEC_BATCH}\n- proposed_run_id: ${rt.EXEC_RUN}\n- source_audit: ${rt.SOURCE_AUDIT}\n- release_audit_expected: ${rt.RELEASE_AUDIT}\n- scope: FROZEN_LOCAL_INPUTS_ONLY_NO_NETWORK\n- qualified_universe: 4\n- proposal_distribution: eligible4/held0/rejected0\n- execution_exact_set: 21\n- transaction: audited runProductionTransactionR2 + immutable fault10 authority\n- outputs: proposal ledger4/gap summary7/application10/request/validation\n- integration_effect: PROPOSAL_ONLY_NO_FORMAL_EVIDENCE_WRITE\n- map_effect: READ_ONLY_MAP46_NO_MUTATION\n- gap_state: OPEN_RETAINED_GAP\n- formal_pool_effect: NO_AUTOMATIC_FORMAL_POOL_CHANGE\n- evidence_strength_effect: NO_UPGRADE\n- execution_outputs: 0\n- proposed_execution_manifest_rows: 0\n\n请仅审核设计可执行性、四条逐项主张边界、exact-set/manifest和fail-closed门；不得执行拟议run。\n`;
}
 
function validationRows(manifestBefore){
  const decisions=rt.decisionRows(),derived=rt.deriveOutputs(decisions),core=rt.coreErrors({criteria:rt.criteriaRows(),decisions,summary:derived.summary,applications:derived.applications}),designInputs=rt.designInputErrors({requireRelease:false,expectNoExecution:true}),negative=rt.negativeRows();
  const checks=[['CORE_ERRORS','0',String(core.length)],['DESIGN_INPUT_ERRORS','0',String(designInputs.length)],['SOURCE_AUDIT_ERRORS','0',String(rt.sourceAuditErrors().length)],['QUALIFIED_INPUTS','4',String(decisions.length)],['CRITERIA','4',String(rt.criteriaRows().length)],['ELIGIBLE_PROPOSALS','4',String(decisions.filter(row=>row.proposal_outcome==='ACCEPTANCE_PROPOSAL_ELIGIBLE_PENDING_INDEPENDENT_REVIEW').length)],['SUMMARY','7',String(derived.summary.length)],['APPLICATION','10',String(derived.applications.length)],['CONTRACTS','34',String(rt.contractRows().length)],['SCHEMAS','7',String(rt.schemaRows().length)],['EXECUTION_EXACT_SET','21',String(rt.executionSetRows().length)],['DESIGN_EXACT_SET','14',String(designSetRows().length)],['NEGATIVE_PASS',String(negative.length),String(negative.filter(row=>row.result==='PASS').length)],['FAULT_PASS','10',String(readCsv(rt.FAULT_RESULTS).rows.filter(row=>row.result==='PASS').length)],['PROTECTED_ERRORS','0',String(rt.protectedErrors().length)],['EXECUTION_OUTPUTS','0',String(rt.GENERATED.filter(file=>fs.existsSync(abs(file))).length)],['EXECUTION_MANIFEST_ROWS','0',String(readCsv(rt.MANIFEST).rows.filter(row=>row.run_id===rt.EXEC_RUN).length)],['MANIFEST_PREFIX_BYTES',String(manifestBefore.length),String(manifestBefore.length)]];
  const rows=checks.map((item,index)=>({check_id:`P0Q4ACC-DES-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:'QUALIFIED4_EVIDENCE_ACCEPTANCE_DESIGN_FAIL_CLOSED'}));
  rows.push({check_id:'P0Q4ACC-DES-VAL-019',check_description:'SELF_REFERENCE_EXCLUDED',expected:'SELF_REFERENCE_EXCLUDED',actual:'SELF_REFERENCE_EXCLUDED',status:'INFO',evidence:'design validation and manifest identity postchecked'});return rows;
}
 
function manifestRows(paths){return paths.map(file=>{const id=identity(file);return{case_id:rt.CASE_ID,run_id:rt.DESIGN_RUN,batch_id:rt.DESIGN_BATCH,artifact_path:file,sha256:id.sha256,bytes:id.bytes,mtime:id.mtime};});}
 
function buildDesign(){
  if(readCsv(rt.MANIFEST).rows.some(row=>row.run_id===rt.DESIGN_RUN))throw new Error('DESIGN_RUN_ALREADY_REGISTERED');
  for(const file of [...rt.GENERATED])if(fs.existsSync(abs(file)))throw new Error(`EXECUTION_OUTPUT_ALREADY_EXISTS:${file}`);
  const manifestBefore=fs.readFileSync(abs(rt.MANIFEST));
  const source=entryAuthority(rt.SOURCE_AUDIT,rt.AUDIT_REPORT,'P0Q4ACC-SOURCE-ENTRY-001',['result=PASS','next_allowed_action=PREPARE_QUALIFIED4_EVIDENCE_ACCEPTANCE_VERIFICATION_DETAILED_DESIGN_ONLY','evidence_acceptance_release=NOT_RELEASED']);
  const formal=entryAuthority(rt.DESIGN_ID,rt.DESIGN_DOC,'P0Q4ACC-FORMAL-ENTRY-001',['FROZEN_LOCAL_INPUTS_ONLY_NO_NETWORK','PROPOSAL_ONLY_NO_FORMAL_EVIDENCE_WRITE','OPEN_RETAINED_GAP']);
  write(rt.SOURCE_ENTRY_AUTHORITY,serializeCsv(source,rt.ENTRY_COLUMNS));
  write(rt.FORMAL_ENTRY_AUTHORITY,serializeCsv(formal,rt.ENTRY_COLUMNS));
  write(rt.CRITERIA,serializeCsv(rt.criteriaRows(),rt.CRITERIA_COLUMNS));
  write(rt.DECISION_AUTHORITY,serializeCsv(rt.decisionRows(),rt.DECISION_COLUMNS));
  write(rt.CONTRACT,serializeCsv(rt.contractRows(),rt.CONTRACT_COLUMNS));
  write(rt.SCHEMA,serializeCsv(rt.schemaRows(),rt.SCHEMA_COLUMNS));
  write(rt.EXEC_SET,serializeCsv(rt.executionSetRows(),rt.EXEC_SET_COLUMNS));
  write(DESIGN_BASELINE,serializeCsv(baselineRows(manifestBefore),BASELINE_COLUMNS));
  write(NEGATIVE_RESULTS,serializeCsv(rt.negativeRows(),NEGATIVE_COLUMNS));
  write(DESIGN_SET,serializeCsv(designSetRows(),DESIGN_SET_COLUMNS));
  write(REVIEW_REQUEST,requestText());
  const validation=validationRows(manifestBefore);write(DESIGN_VALIDATION,serializeCsv(validation,VALIDATION_COLUMNS));if(validation.some(row=>row.status==='FAIL'))throw new Error(`DESIGN_VALIDATION_FAIL:${validation.filter(row=>row.status==='FAIL').map(row=>row.check_id).join('|')}`);
  const paths=designSetRows().map(row=>row.artifact_path),rows=manifestRows(paths),candidate=Buffer.concat([manifestBefore,Buffer.from(serializeManifestDataRows(rows),'utf8')]);
  const checked=validateAppendStableManifest(candidate,{anomalyRows:readCsv(rt.ANOMALY_AUTHORITY).rows,frozenPrefix:{bytes:manifestBefore.length,sha256:hash(manifestBefore)},originalRunId:rt.ORIGINAL_TRIAGE_RUN,originalRunExpectedRows:11,expectedRunRows:rows,expectedRunId:rt.DESIGN_RUN,expectedPhysicalDelta:14});if(checked.errors.length)throw new Error(`MANIFEST_CANDIDATE:${checked.errors.join('|')}`);
  fs.writeFileSync(abs(rt.MANIFEST),candidate);
  const post=validatePackageManifest();if(post.length)throw new Error(`POSTWRITE:${post.join('|')}`);
  return{status:'DESIGN_BUILT_PENDING_INDEPENDENT_REVIEW',qualified:4,eligible:4,summary:7,applications:10,contracts:34,schemas:7,execution_exact_set:21,negative_tests:rt.negativeRows().length,design_manifest_rows:14};
}
 
function validatePackage(){
  const errors=[...rt.designInputErrors({requireRelease:false,expectNoExecution:true})];
  for(const file of [DESIGN_BASELINE,NEGATIVE_RESULTS,DESIGN_SET,REVIEW_REQUEST,DESIGN_VALIDATION])if(!fs.existsSync(abs(file)))errors.push(`DESIGN_ARTIFACT_MISSING:${file}`);if(errors.length)return errors;
  const negative=readCsv(NEGATIVE_RESULTS),set=readCsv(DESIGN_SET),validation=readCsv(DESIGN_VALIDATION);if(negative.rows.some(row=>row.result!=='PASS'))errors.push('NEGATIVE_FAIL');if(JSON.stringify(set.rows)!==JSON.stringify(designSetRows()))errors.push('DESIGN_SET');if(validation.rows.some(row=>row.status==='FAIL'))errors.push('DESIGN_VALIDATION_FAIL');if(normalize(fs.readFileSync(abs(REVIEW_REQUEST)))!==requestText())errors.push('REVIEW_REQUEST');return errors;
}
 
function validatePackageManifest(){
  const errors=validatePackage();if(errors.length)return errors;
  const baseline=readCsv(DESIGN_BASELINE).rows.find(row=>row.artifact_role==='MANIFEST_PREFIX');if(!baseline)return['DESIGN_MANIFEST_PREFIX_BASELINE'];
  const rows=manifestRows(designSetRows().map(row=>row.artifact_path)),checked=validateAppendStableManifest(fs.readFileSync(abs(rt.MANIFEST)),{anomalyRows:readCsv(rt.ANOMALY_AUTHORITY).rows,frozenPrefix:{bytes:Number(baseline.bytes),sha256:baseline.sha256},originalRunId:rt.ORIGINAL_TRIAGE_RUN,originalRunExpectedRows:11,expectedRunRows:rows,expectedRunId:rt.DESIGN_RUN,expectedPhysicalDelta:14});return checked.errors.map(code=>`MANIFEST:${code}`);
}
 
if(process.argv[1]&&import.meta.url===pathToFileURL(process.argv[1]).href){
  const mode=process.argv[2]??'--validate-design';
  if(mode==='--build-design')console.log(JSON.stringify(buildDesign(),null,2));
  else if(mode==='--validate-design'){const errors=validatePackage();console.log(JSON.stringify({status:errors.length?'FAIL':'PASS_DESIGN_PACKAGE',errors},null,2));if(errors.length)process.exitCode=1;}
  else if(mode==='--validate-package-manifest'){const errors=validatePackageManifest();console.log(JSON.stringify({status:errors.length?'FAIL':'PASS_APPEND_STABLE_DESIGN_PACKAGE',errors},null,2));if(errors.length)process.exitCode=1;}
  else if(mode==='--self-test'){const rows=rt.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 throw new Error(`UNKNOWN_MODE:${mode}`);
}