deadbyte-mcp 0.15.39 → 0.15.42

package/scripts/npm-release-r48.mjs

@@ -1,6 +1,9 @@
 import { spawnSync } from 'node:child_process';
-import { verifyPublishedTarballIdentity } from './npm-artifact-identity-r61.mjs';
-import { mkdtemp, readFile, rm, unlink } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { reconcileNpmPublication } from './npm-publication-r65.mjs';
+import { mkdtemp, readFile, rm, unlink, mkdir, rename } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { resolveStateRoot } from '../src/state-root.mjs';
 import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -10,7 +13,7 @@ const node = process.execPath;
 const npmCli = process.env.npm_execpath || path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
 
 function run(command, args, options = {}) {
-  const { cwd = root, timeout = 180000 } = options;
+  const { cwd = root, timeout = 180000, env=process.env } = options;
   const r = spawnSync(command, args, {
     cwd,
     encoding: 'utf8',
@@ -18,6 +21,7 @@ function run(command, args, options = {}) {
     stdio: ['ignore', 'pipe', 'pipe'],
     shell: false,
     windowsHide: true,
+    env,
   });
   if (r.error) throw r.error;
   if (r.status !== 0) {
@@ -94,30 +98,34 @@ async function main() {
   const existingText = (existing.stdout || '').trim();
   const isAlreadyPublished = existing.status === 0 && existingText && existingText !== 'null';
 
-  if (isAlreadyPublished) {
-    if (!isVerifyOnly) {
-      throw new Error(`deadbyte-mcp@${version} is already published on registry: ${existingText}`);
-    } else {
-      console.log(`Notice: deadbyte-mcp@${version} is already published on registry (${existingText}), proceeding with pre-publish verification only.`);
-    }
-  }
+  if (isAlreadyPublished) console.log(`Notice: deadbyte-mcp@${version} exists on registry (${existingText}); exact-byte reconciliation is required.`);
 
   console.log('[2/7] Pre-pack gates: verifying working tree manifest and doctor...');
   run(node, [path.join(root, 'scripts', 'release-manifest.mjs'), 'verify']);
-  run(node, [path.join(root, 'src', 'deadbyte-cli.mjs'), 'doctor']);
+  const doctorState=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-release-doctor-'));
+  try{run(node,[path.join(root,'src','deadbyte-cli.mjs'),'doctor'],{env:{...process.env,DEADBYTE_STATE_ROOT:doctorState}});}
+  finally{await rm(doctorState,{recursive:true,force:true});}
 
   console.log('[3/7] Packing artifact with npm pack...');
-  const packed = parseJson(runNpm(['pack', '--json'], { timeout: 180000 }));
-  const packRecord = Array.isArray(packed) ? packed[0] : packed?.[pkg.name];
+  const publicationDir=isVerifyOnly?null:path.join(resolveStateRoot(),'evidence','npm-publication',version);
+  const preservedTarball=publicationDir?path.join(publicationDir,`deadbyte-mcp-${version}.tgz`):null;
+  const resuming=Boolean(preservedTarball&&existsSync(path.join(publicationDir,'claim.json')));
+  if(publicationDir)await mkdir(publicationDir,{recursive:true});
+  if(resuming&&!existsSync(preservedTarball))throw new Error('immutable npm publication claim exists but exact local tarball is missing; manual artifact reconciliation required');
+  if(!resuming&&preservedTarball&&existsSync(preservedTarball))throw new Error('unclaimed preserved npm tarball exists; inspect artifact evidence before another pack');
+  const packed=resuming?null:parseJson(runNpm(['pack', '--json'], { timeout: 180000 }));
+  const packRecord=resuming?{filename:path.basename(preservedTarball)}:(Array.isArray(packed) ? packed[0] : packed?.[pkg.name]);
   const filename = packRecord?.filename;
   if (!filename) throw new Error('npm pack did not return a tarball filename');
-  const tarball = path.join(root, filename);
+  const tarball = resuming?preservedTarball:path.join(root, filename);
   let releaseSucceeded = false;
   let publishAttempted = false;
+  let releasePending = false;
 
   try {
     console.log('[4/7] Verifying packed artifact file surface against MANIFEST.SHA256 and packaging contract...');
     const manifestText = await readFile(path.join(root, 'MANIFEST.SHA256'), 'utf8');
+    const manifestSha256=createHash('sha256').update(manifestText).digest('hex');
     const manifestEntries = new Set();
     for (const line of manifestText.split(/\r?\n/)) {
       if (!line) continue;
@@ -168,7 +176,7 @@ async function main() {
       }
 
       run(node, [path.join(extractedPackage, 'src', 'deadbyte-cli.mjs'), 'doctor'], {
-        cwd: extractedPackage,
+        cwd: extractedPackage,env:{...process.env,DEADBYTE_STATE_ROOT:path.join(sandbox,'state')},
       });
 
       console.log('Artifact isolation gate PASS (clean doctor and version check on unpacked tarball in sandbox)');
@@ -177,36 +185,48 @@ async function main() {
     }
 
     if (isVerifyOnly) {
+      const packedBytes = await readFile(tarball);
+      const sha256 = createHash('sha256').update(packedBytes).digest('hex');
+      const sha512Integrity = `sha512-${createHash('sha512').update(packedBytes).digest('base64')}`;
+      if (packRecord.integrity !== sha512Integrity) throw new Error('npm pack integrity differs from packed tarball bytes');
+      console.log('VERIFIED_TARBALL ' + JSON.stringify({filename,bytes:packedBytes.length,sha256,integrity:sha512Integrity,shasum:packRecord.shasum}));
       console.log('[6/7] [VERIFY-ONLY] Skipping npm publish.');
       console.log('[7/7] [VERIFY-ONLY] Skipping external registry smoke test.');
       console.log('\nVERIFY-ONLY PIPELINE PASS: All pre-pack, artifact surface, and isolated sandbox gates passed successfully.');
       return;
     }
 
-    const localBytes = await readFile(tarball);
+    if(!resuming)await rename(tarball,preservedTarball);
+    const publishTarball=preservedTarball;
+    const localBytes = await readFile(publishTarball);
+    const localIntegrity=`sha512-${createHash('sha512').update(localBytes).digest('base64')}`;
+    if(packRecord.integrity&&packRecord.integrity!==localIntegrity)throw new Error('npm packed artifact integrity changed before publication');
 
     console.log('[6/7] Publishing artifact to npm registry...');
     publishAttempted = true;
-    let publishOut;
-    try {
-      publishOut = runNpmInteractive(['publish', tarball, '--access', 'public', '--auth-type=web'], { timeout: 300000 });
-    } catch (publishError) {
-      const detail = String(publishError?.message || publishError);
-      if (/EOTP|one-time password|two-factor|2FA|security.?key|authentication/i.test(detail)) {
-        console.error('Publish requires interactive npm authentication (Security Key/WebAuthn).');
-        console.error('Tarball preserved for retry: ' + tarball);
-      }
-      throw publishError;
+    const reconciliation=await reconcileNpmPublication({recordPath:publicationDir,version,manifestSha256,localBytes,
+      publish:async()=>runNpmInteractive(['publish',publishTarball,'--access','public','--auth-type=web'],{timeout:300000}),
+      lookup:async()=>{
+        try{
+          const viewed=parseJson(runNpm(['view',`deadbyte-mcp@${version}`,'version','dist.integrity','dist.shasum','dist.tarball','--json'],{timeout:120000}));
+          return Array.isArray(viewed)?viewed[0]:viewed;
+        }catch(error){if(/E404|404 Not Found/.test(String(error?.message)))return null;throw error;}
+      },
+      tags:async()=>parseJson(runNpm(['view','deadbyte-mcp','dist-tags','--json'],{timeout:120000})),
+      fetchTarball:async published=>{
+        const response=await fetch(published?.dist?.tarball,{signal:AbortSignal.timeout(120000)});
+        if(!response.ok)throw Object.assign(new Error(`registry tarball fetch failed status=${response.status}`),{status:response.status});
+        return Buffer.from(await response.arrayBuffer());
+      }});
+    if(reconciliation.state!=='REGISTRY_IDENTITY_VERIFIED'){
+      console.log('RELEASE_PENDING '+JSON.stringify({state:reconciliation.state,version,tarball:publishTarball,record_path:publicationDir,reason:reconciliation.reason??null}));
+      releasePending=true;
+      process.exitCode=2;return;
     }
-    const viewed = parseJson(runNpm(['view', `deadbyte-mcp@${version}`, 'version', 'dist.integrity', 'dist.shasum', 'dist.tarball', '--json'], { timeout: 120000 }));
-    const published = Array.isArray(viewed) ? viewed[0] : viewed;
-    const dist = published?.dist ?? published;
-    if(typeof dist?.tarball !== 'string')throw new Error('published registry tarball URL missing');
-    const registryResponse = await fetch(dist.tarball,{signal:AbortSignal.timeout(120000)});
-    if(!registryResponse.ok) throw new Error(`registry tarball fetch failed status=${registryResponse.status}`);
-    const registryBytes = Buffer.from(await registryResponse.arrayBuffer());
-    const tags = parseJson(runNpm(['view', 'deadbyte-mcp', 'dist-tags', '--json'], { timeout: 120000 }));
-    const identity=verifyPublishedTarballIdentity({version,localBytes,registryBytes,published,tags});
+    const identity=reconciliation.identity;
+    const published={version,dist:{integrity:identity.npm_integrity,shasum:identity.shasum}};
+    const tags={latest:version};
+    const publishOut='registry identity verified by durable reconciliation';
 
     console.log('[7/7] Post-publish external registry smoke test (executed outside repo in temp)...');
     const tempDir = os.tmpdir();
@@ -221,6 +241,7 @@ async function main() {
     const externalDoctor = runNpm(['exec', '--yes', `--package=deadbyte-mcp@${version}`, '--', 'deadbyte-mcp', 'doctor'], {
       cwd: tempDir,
       timeout: 300000,
+      env:{...process.env,DEADBYTE_STATE_ROOT:path.join(publicationDir,'external-doctor-state')},
     });
 
     if(!publishOnly){
@@ -247,10 +268,14 @@ async function main() {
     }, null, 2));
 
   } finally {
-    if ((releaseSucceeded && !publishOnly) || !publishAttempted) {
+    if (isVerifyOnly || (!publishAttempted&&!publicationDir)) {
       await unlink(tarball).catch(() => {});
+    } else if(releasePending){
+      console.log('Publication processing or reconciliation pending; exact tarball preserved: '+preservedTarball);
+    } else if(releaseSucceeded){
+      console.log('Verified release tarball retained for audit: '+preservedTarball);
     } else {
-      console.error('Release artifact preserved after failure: ' + tarball);
+      console.error('Release artifact preserved for reconciliation: ' + preservedTarball);
     }
   }
 }

package/scripts/r64-predecessor-reproducer.mjs

@@ -0,0 +1,32 @@
+import {mkdtemp,mkdir,writeFile,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+const sourceRoot=process.argv[2];
+if(!sourceRoot||!path.isAbsolute(sourceRoot))throw new Error('absolute predecessor root required');
+const load=name=>import(pathToFileURL(path.join(sourceRoot,name)).href);
+const [{loadCodingPolicy},{createMachineFsRuntime},{generateTrustKeypair},{machineFsGatewayInputSchema},{registerMachineFsTools}]=await Promise.all([
+  load('src/coding-plane.mjs'),load('src/machine-fs.mjs'),load('src/trust.mjs'),
+  load('src/compact-gateway-mcp-tools.mjs'),load('src/machine-fs-mcp-tools.mjs')
+]);
+const root=await mkdtemp(path.join(tmpdir(),'deadbyte-r64-red-'));
+try{
+  const project=path.join(root,'project');await mkdir(project);
+  await writeFile(path.join(project,'large.bin'),Buffer.alloc(4*1024*1024+64,0x52));
+  const policyPath=path.join(root,'policy.json');
+  await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(root,'grant.json'),evidence_dir:path.join(root,'evidence'),roots:{project:{path:project,read:true,write:false,exec:false,deny_paths:[]}},commands:{},max_read_bytes:4*1024*1024,max_write_bytes:65536}));
+  const policy=await loadCodingPolicy(policyPath);
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(root,'private.pem'),publicKeyPath:path.join(root,'public.pem')});
+  const runtime=createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const first=await runtime.read({rootId:'project',relativePath:'large.bin',offset:2,maxBytes:4*1024*1024});
+  const args={root_id:'project',path:'large.bin',offset:first.next_offset,max_bytes:64,hash_file:false,timeout_ms:30000};
+  const server={registerTool(name,definition){if(name==='machine_fs_read')this.read=definition;}};
+  registerMachineFsTools(server,{runtime:{}});
+  let runtimeError=null;
+  try{await runtime.read({rootId:'project',relativePath:'large.bin',offset:first.next_offset,maxBytes:64});}
+  catch(error){runtimeError=String(error?.message||error);}
+  const result={source_root:sourceRoot,page_two_offset:first.next_offset,full_schema_accepts:server.read.inputSchema.safeParse(args).success,compact_schema_accepts:machineFsGatewayInputSchema.safeParse({op:'read',...args}).success,runtime_error:runtimeError};
+  console.log(JSON.stringify(result));
+  if(result.full_schema_accepts||result.compact_schema_accepts||!runtimeError)process.exitCode=1;
+}finally{await rm(root,{recursive:true,force:true});}

package/scripts/r64-read-benchmark.mjs

@@ -0,0 +1,84 @@
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,rm,writeFile} from 'node:fs/promises';
+import {performance} from 'node:perf_hooks';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+const [beforeRoot,afterRoot,scratchRoot,outputPath]=process.argv.slice(2);
+if([beforeRoot,afterRoot,scratchRoot,outputPath].some(value=>!value||!path.isAbsolute(value)))throw new Error('four absolute paths required: R63 R64 scratch output');
+const rounds=7,operations=400,concurrency=4;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const percentile=(values,p)=>[...values].sort((a,b)=>a-b)[Math.ceil(values.length*p)-1];
+await mkdir(scratchRoot,{recursive:true});
+const scratch=await mkdtemp(path.join(scratchRoot,'read-bench-'));
+try{
+  const project=path.join(scratch,'project');
+  await mkdir(project);
+  const file=path.join(project,'fixture.bin');
+  const content=Buffer.alloc(4*1024*1024+131072,0x52);
+  await writeFile(file,content);
+  const policyPath=path.join(scratch,'policy.json');
+  await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:path.join(scratch,'grant.json'),evidence_dir:path.join(scratch,'evidence'),
+    roots:{project:{path:project,read:true,write:false,exec:false,deny_paths:[]}},
+    commands:{},max_read_bytes:4*1024*1024,max_write_bytes:65536}));
+  const rows=[];
+  for(let round=0;round<rounds;round++){
+    for(const [label,root] of (round%2?[['after',afterRoot],['before',beforeRoot]]:[['before',beforeRoot],['after',afterRoot]])){
+      const url=name=>pathToFileURL(path.join(root,name)).href;
+      const [{loadCodingPolicy},{createMachineFsRuntime},{generateTrustKeypair},{createBridgeGovernor}]=await Promise.all([
+        import(url('src/coding-plane.mjs')),import(url('src/machine-fs.mjs')),
+        import(url('src/trust.mjs')),import(url('bridge/src/r40-governor.mjs'))
+      ]);
+      const keys=await generateTrustKeypair({privateKeyPath:path.join(scratch,`private-${label}-${round}.pem`),publicKeyPath:path.join(scratch,`public-${label}-${round}.pem`)});
+      const policy=await loadCodingPolicy(policyPath);
+      const runtime=createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+      const governor=createBridgeGovernor();
+      const latencies=[],control=[],errors=[];
+      let next=0,peakRss=process.memoryUsage().rss;
+      const started=performance.now();
+      async function bulkWorker(){
+        for(;;){
+          const index=next++;
+          if(index>=operations)return;
+          const mark=performance.now();
+          const ticket=await governor.acquire('machine_fs',{op:'read'});
+          try{
+            const result=await runtime.read({rootId:'project',relativePath:'fixture.bin',offset:(index%32)*65536,maxBytes:65536});
+            if(result.status!=='ok'||Buffer.from(result.data_base64,'base64').length!==65536)throw new Error('read oracle failed');
+          }catch(error){errors.push(String(error));}
+          finally{ticket.release();latencies.push(performance.now()-mark);peakRss=Math.max(peakRss,process.memoryUsage().rss);}
+        }
+      }
+      async function controlWorker(){
+        for(let index=0;index<operations;index++){
+          const mark=performance.now();
+          const ticket=await governor.acquire(index%2?'machine_status':'machine_ping');
+          try{if(index%2)await readFile(policyPath);else sha(Buffer.from(`ping-${index}`));}
+          finally{ticket.release();control.push(performance.now()-mark);}
+        }
+      }
+      await Promise.all([...Array.from({length:concurrency},()=>bulkWorker()),controlWorker()]);
+      const elapsed=performance.now()-started;
+      await governor.close();
+      const boundaryStart=performance.now();
+      let boundary={status:'unknown'};
+      try{
+        const first=await runtime.read({rootId:'project',relativePath:'fixture.bin',offset:65536,maxBytes:4*1024*1024});
+        const second=await runtime.read({rootId:'project',relativePath:'fixture.bin',offset:first.next_offset,maxBytes:65536});
+        if(first.next_offset<=4*1024*1024||second.eof!==true||Buffer.from(second.data_base64,'base64').length!==65536)throw new Error('cross-boundary oracle failed');
+        boundary={status:'pass',page_two_offset:first.next_offset,elapsed_ms:performance.now()-boundaryStart};
+      }catch(error){boundary={status:'rejected',reason:String(error?.message||error),elapsed_ms:performance.now()-boundaryStart};}
+      if(label==='before'&&boundary.status!=='rejected')errors.push('R63 unexpectedly accepted page two');
+      if(label==='after'&&boundary.status!=='pass')errors.push('R64 cross-boundary paging failed');
+      rows.push({round,label,source_sha256:sha(await readFile(path.join(root,'src/machine-fs.mjs'))),
+        ops:latencies.length,ops_per_second:operations*1000/elapsed,p50_ms:percentile(latencies,.5),p95_ms:percentile(latencies,.95),
+        control_p95_ms:percentile(control,.95),peak_rss_bytes:peakRss,boundary,errors});
+    }
+  }
+  const report={schema:'deadbyte.r64.read-benchmark.v1',node:process.version,rounds,operations_per_round:operations,concurrency,
+    source_roots:{before:beforeRoot,after:afterRoot},rows,
+    limitations:['same-host sequential alternating runs; OS scheduling noise remains','comparable throughput rows use inherited sub-4-MiB reads; boundary timings are separate because R63 cannot execute page two','control probe uses governor and local read/hash, not public MCP machine_ping or machine_status']};
+  await writeFile(outputPath,JSON.stringify(report,null,2)+'\n',{flag:'wx'});
+  console.log(JSON.stringify({output_path:outputPath,rows:rows.length,errors:rows.reduce((sum,row)=>sum+row.errors.length,0)}));
+}finally{await rm(scratch,{recursive:true,force:true});}

package/scripts/r65-canonical-full.mjs

@@ -0,0 +1,45 @@
+import {createHash} from 'node:crypto';
+import {mkdirSync,readdirSync,writeFileSync} from 'node:fs';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+
+const runId=process.argv[2]??'manual';
+if(!/^[A-Za-z0-9._-]{1,96}$/.test(runId))throw new Error('invalid run id');
+const testDir=path.join(process.cwd(),'test');
+const tests=readdirSync(testDir,{withFileTypes:true})
+  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs'))
+  .map(entry=>path.join('test',entry.name))
+  .sort((a,b)=>a.localeCompare(b,'en'));
+const startedAt=new Date().toISOString();
+const run=spawnSync(process.execPath,['--test','--test-concurrency=4',...tests],{
+  cwd:process.cwd(),
+  encoding:'utf8',
+  maxBuffer:128*1024*1024,
+  windowsHide:true,
+  shell:false
+});
+const stdout=run.stdout||'',stderr=run.stderr||'';
+const evidenceDir=path.resolve(process.cwd(),'..','..','testing','0.15.42-r65','full-runs',runId);
+mkdirSync(evidenceDir,{recursive:true});
+writeFileSync(path.join(evidenceDir,'stdout.log'),stdout,'utf8');
+writeFileSync(path.join(evidenceDir,'stderr.log'),stderr,'utf8');
+const grab=(name)=>{const m=stdout.match(new RegExp('(?:ℹ|#)\\s*'+name+'\\s+(\\d+)','i'));return m?Number(m[1]):null;};
+const result={
+  schema:'deadbyte.r65-full-run.v1',
+  run_id:runId,
+  started_at_utc:startedAt,
+  finished_at_utc:new Date().toISOString(),
+  command:[process.execPath,'--test','--test-concurrency=4',...tests],
+  test_files:tests.length,
+  exit_code:run.status??null,
+  signal:run.signal??null,
+  error:run.error?String(run.error.stack||run.error):null,
+  tests:grab('tests'),pass:grab('pass'),fail:grab('fail'),skipped:grab('skipped'),
+  stdout_sha256:createHash('sha256').update(stdout).digest('hex'),
+  stderr_sha256:createHash('sha256').update(stderr).digest('hex')
+};
+writeFileSync(path.join(evidenceDir,'result.json'),JSON.stringify(result,null,2)+'\n','utf8');
+process.stdout.write(stdout);
+process.stderr.write(stderr);
+if(run.error)process.stderr.write(String(run.error.stack||run.error)+'\n');
+process.exit(run.status??1);

package/scripts/r65-focused.mjs

@@ -0,0 +1,37 @@
+import {spawnSync} from 'node:child_process';
+
+const tests=[
+  'test/r65-activation-lock.test.mjs',
+  'test/r65-activation-lock-recovery.test.mjs',
+  'test/r65-activation-orchestration.test.mjs',
+  'test/r65-activation-preflight.test.mjs',
+  'test/r65-authority-continuity-decision.test.mjs',
+  'test/r65-authority-durable-policy-binding.test.mjs',
+  'test/r65-authority-epoch-cli.test.mjs',
+  'test/r65-authority-epoch-races.test.mjs',
+  'test/r65-authority-epoch-recovery.test.mjs',
+  'test/r65-authority-epoch-store.test.mjs',
+  'test/r65-authority-grant-capture.test.mjs',
+  'test/r65-authority-observation-epoch.test.mjs',
+  'test/r65-authority-policy-envelope.test.mjs',
+  'test/r65-authority-runtime-epoch.test.mjs',
+  'test/r65-authority-runtime-policy-binding.test.mjs',
+  'test/r65-authority-restored-safe.test.mjs',
+  'test/r65-controller-authority-epoch.test.mjs',
+  'test/r65-controller-authority-epoch-live.test.mjs',
+  'test/r65-deploy-preflight.test.mjs',
+  'test/r65-epoch-native-activation-integration.test.mjs',
+  'test/r65-epoch-native-continuity-engine.test.mjs',
+  'test/r65-epoch-native-cross-plane.test.mjs',
+  'test/r65-legacy-authority-migration.test.mjs',
+  'test/r65-legacy-auto-restore-rejection.test.mjs',
+  'test/r65-parent-source-verifier.test.mjs',
+  'test/r65-release-contract.test.mjs',
+  'test/r65-transaction-precondition.test.mjs'
+];
+const run=spawnSync(process.execPath,['--test','--test-concurrency=2',...tests],{
+  cwd:process.cwd(),encoding:'utf8',maxBuffer:64*1024*1024,windowsHide:true
+});
+process.stdout.write(run.stdout||'');
+process.stderr.write(run.stderr||'');
+process.exit(run.status??1);

package/scripts/verify-r65-parent-source.mjs

@@ -0,0 +1,75 @@
+import {createHash} from 'node:crypto';
+import {lstat,readFile,realpath} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+function parseArgs(argv){
+  const out={root:null,expectedManifestSha256:null};
+  for(let i=0;i<argv.length;i++){
+    const arg=argv[i];
+    if(arg==='--root')out.root=argv[++i]??null;
+    else if(arg==='--expected-manifest-sha256')out.expectedManifestSha256=argv[++i]??null;
+    else throw new Error('unknown argument '+arg);
+  }
+  if(typeof out.root!=='string'||out.root.length<1)throw new Error('--root required');
+  if(!HEX64.test(String(out.expectedManifestSha256)))throw new Error('--expected-manifest-sha256 must be lowercase hex');
+  return out;
+}
+
+function parseManifest(text){
+  const entries=[];
+  const seen=new Set();
+  for(const raw of text.split(/\r?\n/)){
+    if(raw==='')continue;
+    const match=/^([0-9a-f]{64})  (.+)$/.exec(raw);
+    if(!match)throw new Error('manifest line invalid');
+    const rel=match[2];
+    if(rel.includes('\\')||path.posix.isAbsolute(rel)||rel==='.'||rel.split('/').includes('..')||path.posix.normalize(rel)!==rel)
+      throw new Error('manifest path invalid: '+rel);
+    if(seen.has(rel))throw new Error('manifest duplicate path: '+rel);
+    seen.add(rel);
+    entries.push({sha256:match[1],rel});
+  }
+  if(entries.length<1)throw new Error('manifest has no entries');
+  return entries;
+}
+
+export async function verifyDeclaredParentSource({root,expectedManifestSha256}){
+  const absolute=path.resolve(root);
+  const rootReal=await realpath(absolute);
+  const manifestPath=path.join(absolute,'MANIFEST.SHA256');
+  const manifestBytes=await readFile(manifestPath);
+  const actualManifestSha=sha(manifestBytes);
+  if(actualManifestSha!==expectedManifestSha256)
+    throw new Error(`manifest SHA-256 mismatch expected=${expectedManifestSha256} actual=${actualManifestSha}`);
+  const entries=parseManifest(manifestBytes.toString('utf8'));
+  for(const entry of entries){
+    const target=path.resolve(absolute,...entry.rel.split('/'));
+    const info=await lstat(target).catch(error=>{
+      if(error?.code==='ENOENT')throw new Error('listed file missing: '+entry.rel);
+      throw error;
+    });
+    if(!info.isFile()||info.isSymbolicLink())throw new Error('listed path is not a regular file: '+entry.rel);
+    const targetReal=await realpath(target);
+    const prefix=rootReal.endsWith(path.sep)?rootReal:rootReal+path.sep;
+    if(targetReal!==rootReal&&!targetReal.startsWith(prefix))throw new Error('listed path escapes root: '+entry.rel);
+    const actual=sha(await readFile(target));
+    if(actual!==entry.sha256)throw new Error(`hash mismatch ${entry.rel} expected=${entry.sha256} actual=${actual}`);
+  }
+  return Object.freeze({files:entries.length,manifest_sha256:actualManifestSha,root:rootReal});
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===path.resolve(fileURLToPath(import.meta.url));
+if(invoked){
+  try{
+    const opts=parseArgs(process.argv.slice(2));
+    const result=await verifyDeclaredParentSource(opts);
+    console.log(`R65_PARENT_SOURCE_VERIFY_OK files=${result.files} manifest_sha256=${result.manifest_sha256}`);
+  }catch(error){
+    console.error('R65_PARENT_SOURCE_VERIFY_FAIL '+String(error?.stack??error));
+    process.exitCode=1;
+  }
+}