deadbyte-mcp 0.13.0 → 0.15.0

package/scripts/verify-r43-parent.mjs

@@ -0,0 +1,126 @@
+import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
+import { lstat, readFile, readdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { canonicalJson } from '../src/canonical-json.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const UPDATE_DOMAIN=Buffer.from('DEADBYTE-R27-SLOT-UPDATE-V1\0','utf8');
+const HEX64=/^[0-9a-f]{64}$/;
+
+function inputPath(value){
+  if(value instanceof URL) return fileURLToPath(value);
+  return path.resolve(String(value));
+}
+function parseManifest(bytes,label){
+  const entries=new Map();
+  for(const [index,line] of bytes.toString('utf8').split(/\r?\n/).entries()){
+    if(!line)continue;
+    const match=/^([0-9a-f]{64})  ([^\0]+)$/.exec(line);
+    insist(match,`${label} line ${index+1} malformed`);
+    const rel=match[2].replaceAll('\\','/');
+    insist(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!entries.has(rel),`unsafe/duplicate ${label} path ${rel}`);
+    entries.set(rel,match[1]);
+  }
+  insist(entries.size>0,`${label} has no entries`);
+  return entries;
+}
+async function walk(rootDir,manifestName,rel=''){
+  const dir=rel?path.join(rootDir,...rel.split('/')):rootDir;
+  const out=[];
+  for(const name of (await readdir(dir)).sort((a,b)=>a.localeCompare(b,'en'))){
+    const child=rel?`${rel}/${name}`:name;
+    if(child===manifestName)continue;
+    const full=path.join(rootDir,...child.split('/'));
+    const st=await lstat(full);
+    insist(!st.isSymbolicLink(),`parent tree symlink forbidden: ${child}`);
+    if(st.isDirectory())out.push(...await walk(rootDir,manifestName,child));
+    else{insist(st.isFile(),`parent tree non-file forbidden: ${child}`);out.push(child);}
+  }
+  return out;
+}
+async function verifyTree(dir,manifestName,expectedManifest,expectedCount){
+  const base=path.resolve(dir);
+  const rootStat=await lstat(base);
+  insist(rootStat.isDirectory()&&!rootStat.isSymbolicLink(),`${manifestName} root must be a real directory`);
+  const bytes=await readFile(path.join(base,manifestName));
+  insist(sha256(bytes)===expectedManifest,`${manifestName} digest mismatch`);
+  const entries=parseManifest(bytes,manifestName);
+  insist(entries.size===expectedCount,`${manifestName} entry count mismatch`);
+  const actual=(await walk(base,manifestName)).sort((a,b)=>a.localeCompare(b,'en'));
+  const expected=[...entries.keys()].sort((a,b)=>a.localeCompare(b,'en'));
+  insist(actual.length===expected.length&&actual.every((rel,index)=>rel===expected[index]),`${manifestName} exact tree mismatch`);
+  for(const [rel,digest] of entries){
+    insist(sha256(await readFile(path.join(base,...rel.split('/'))))===digest,`${manifestName} file hash mismatch: ${rel}`);
+  }
+  return entries.size;
+}
+function publicKeyInfo(publicPem){
+  const key=createPublicKey(publicPem);
+  insist(key.asymmetricKeyType==='ed25519','R43 parent trust key must be Ed25519');
+  const der=Buffer.from(key.export({type:'spki',format:'der'}));
+  return {key,key_id:sha256(der)};
+}
+function verifyActivationEnvelope(env,keyInfo,record){
+  insist(env?.body&&env?.attestation,'R42 activation envelope malformed');
+  const bodyBytes=Buffer.from(canonicalJson(env.body),'utf8');
+  insist(sha256(bodyBytes)===env.body_sha256,'R42 activation body hash mismatch');
+  const {receipt_sha256:claimed,...unsigned}=env;
+  insist(claimed===record.parent_activation_receipt_sha256,'R42 activation signed receipt identity mismatch');
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===claimed,'R42 activation receipt hash mismatch');
+  insist(env.attestation.algorithm==='ed25519'&&env.attestation.domain==='DEADBYTE-R27-SLOT-UPDATE-V1','R42 activation attestation contract mismatch');
+  insist(env.attestation.key_id===record.parent_activation_signer_key_id&&env.attestation.key_id===keyInfo.key_id,'R42 activation signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([UPDATE_DOMAIN,bodyBytes]),keyInfo.key,Buffer.from(env.attestation.signature_base64,'base64')),'R42 activation signature invalid');
+  const body=env.body;
+  insist(body.schema==='deadbyte.r27-slot-update-receipt.v1'&&body.rollback_performed===false,'R42 activation receipt state invalid');
+  insist(body.release_version===record.parent_version&&body.candidate_manifest_sha256===record.parent_manifest_sha256,'R42 activation candidate mismatch');
+  const active=body.active_pointer;
+  insist(active?.release_id===record.parent_release_id&&active?.version===record.parent_version&&active?.manifest_sha256===record.parent_manifest_sha256,'R42 activation active release mismatch');
+  insist(active?.generation_manifest_sha256===record.parent_generation_manifest_sha256,'R42 activation generation mismatch');
+  insist(path.resolve(active.release_root)===path.resolve(record.parent_release_root),'R42 activation release root mismatch');
+  insist(path.resolve(active.generation_root)===path.resolve(record.parent_generation_root),'R42 activation generation root mismatch');
+  const prior=body.prior_pointer;
+  insist(prior?.release_id===record.parent_predecessor_release_id&&prior?.manifest_sha256===record.parent_predecessor_manifest_sha256,'R42 activation predecessor mismatch');
+  insist(body.authority?.final?.coding_armed===false&&body.authority?.final?.autonomous_armed===false&&body.authority?.final?.desktop_armed===false&&body.authority?.final?.host_armed===false,'R42 activation final authority was not disarmed');
+  return body;
+}
+
+export async function verifyR43Parent(file=path.join(root,'R43-PARENT.json')){
+  const record=JSON.parse(await readFile(inputPath(file),'utf8'));
+  insist(record.schema==='deadbyte.r43-parent.v1','R43 parent schema mismatch');
+  insist(record.parent_release_id==='v0.14.0-08cd8f3b98c90e0e'&&record.parent_version==='0.14.0','R43 parent release identity mismatch');
+  insist(record.parent_manifest_sha256==='08cd8f3b98c90e0e250cf506ff396515065ff5457909f850b75b0b6e8ecc2dd1','R43 parent manifest mismatch');
+  insist(record.parent_generation_manifest_sha256==='df8ca9894a3e2ca9a9f145cfa3e4e23fd71f42c1988266a1591fc16261ab18a5','R43 parent generation mismatch');
+  insist(record.parent_manifest_file_count===1820&&record.parent_generation_file_count===7,'R43 parent file count mismatch');
+  insist(record.parent_final_closure_present===false&&!Object.prototype.hasOwnProperty.call(record,'parent_final_closure_path'),'R43 parent must not invent unavailable R42 final closure');
+  insist(record.parent_proof==='immutable-slot+generation+signed-activation','R43 parent proof class mismatch');
+  for(const key of ['parent_activation_receipt_file_sha256','parent_activation_receipt_sha256','parent_activation_signer_key_id']) insist(HEX64.test(record[key]??''),`R43 parent ${key} malformed`);
+
+  const [releaseFiles,generationFiles]=await Promise.all([
+    verifyTree(record.parent_release_root,'MANIFEST.SHA256',record.parent_manifest_sha256,record.parent_manifest_file_count),
+    verifyTree(record.parent_generation_root,'GENERATION.SHA256',record.parent_generation_manifest_sha256,record.parent_generation_file_count)
+  ]);
+  const activationBytes=await readFile(path.resolve(record.parent_activation_receipt_path));
+  insist(sha256(activationBytes)===record.parent_activation_receipt_file_sha256,'R42 activation raw file hash mismatch');
+  const activation=JSON.parse(activationBytes.toString('utf8').replace(/^\uFEFF/,''));
+  const keyInfo=publicKeyInfo(await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  verifyActivationEnvelope(activation,keyInfo,record);
+
+  return {
+    status:'passed',parent_release_id:record.parent_release_id,parent_manifest_sha256:record.parent_manifest_sha256,
+    parent_generation_manifest_sha256:record.parent_generation_manifest_sha256,release_files:releaseFiles,generation_files:generationFiles,
+    parent_activation_receipt_file_sha256:record.parent_activation_receipt_file_sha256,
+    parent_activation_receipt_sha256:record.parent_activation_receipt_sha256,parent_activation_signer_key_id:keyInfo.key_id,
+    parent_final_closure_present:false
+  };
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  const file=process.argv[2]??path.join(root,'R43-PARENT.json');
+  verifyR43Parent(file).then(value=>console.log(JSON.stringify(value,null,2)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/verify-r44-parent.mjs

@@ -0,0 +1,142 @@
+import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
+import { lstat, readFile, readdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const CLOSURE_DOMAIN=Buffer.from('DEADBYTE-R43-FINAL-CLOSURE-V1\0','utf8');
+const HEX64=/^[0-9a-f]{64}$/;
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+const same=(a,b)=>canonicalJson(a)===canonicalJson(b);
+const samePath=(a,b)=>path.resolve(String(a)).toLowerCase()===path.resolve(String(b)).toLowerCase();
+function insist(ok,message){if(!ok) throw new Error(message);}
+
+function parseManifest(text){
+  const out=new Map();
+  for(const [i,line] of text.split(/\r?\n/).entries()){
+    if(!line) continue;
+    const m=/^([0-9a-f]{64})  ([^\0]+)$/.exec(line);
+    insist(m,`manifest line ${i+1} malformed`);
+    const rel=m[2];
+    insist(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!out.has(rel),`unsafe/duplicate manifest path ${rel}`);
+    out.set(rel,m[1]);
+  }
+  return out;
+}
+async function walk(root,rel=''){
+  const dir=path.join(root,...(rel?rel.split('/'):[]));
+  const names=(await readdir(dir)).sort((a,b)=>a.localeCompare(b,'en'));
+  const files=[];
+  for(const name of names){
+    const childRel=rel?`${rel}/${name}`:name;
+    const full=path.join(root,...childRel.split('/'));
+    const st=await lstat(full);
+    insist(!st.isSymbolicLink(),`symlink forbidden: ${childRel}`);
+    if(st.isDirectory()) files.push(...await walk(root,childRel));
+    else { insist(st.isFile(),`non-file forbidden: ${childRel}`); files.push(childRel); }
+  }
+  return files;
+}
+async function verifyTree(root,manifestName,expectedDigest,expectedCount){
+  const manifestBytes=await readFile(path.join(root,manifestName));
+  insist(sha256(manifestBytes)===expectedDigest,`${manifestName} digest mismatch`);
+  const entries=parseManifest(manifestBytes.toString('utf8'));
+  insist(entries.size===expectedCount,`${manifestName} file count mismatch`);
+  const actual=(await walk(root)).filter(rel=>rel!==manifestName).sort((a,b)=>a.localeCompare(b,'en'));
+  const expected=[...entries.keys()].sort((a,b)=>a.localeCompare(b,'en'));
+  insist(same(actual,expected),`${manifestName} exact tree mismatch`);
+  for(const [rel,digest] of entries){
+    insist(sha256(await readFile(path.join(root,...rel.split('/'))))===digest,`${manifestName} file hash mismatch: ${rel}`);
+  }
+  return entries.size;
+}
+
+export async function verifyR44Parent(parentFile,{stateRoot=path.join(os.homedir(),'.deadbyte-mcp')}={}){
+  const parentPath=path.resolve(parentFile);
+  const parent=JSON.parse(await readFile(parentPath,'utf8'));
+  insist(parent?.schema==='deadbyte.r44-parent.v1','R44 parent schema mismatch');
+  insist(parent.parent_release_id==='v0.14.1-0a5a833892593283','R44 parent release id mismatch');
+  insist(parent.parent_version==='0.14.1','R44 parent version mismatch');
+  insist(parent.parent_manifest_sha256==='0a5a8338925932830986421dda60ec5643f62f600404de4992fda2a5e79d09a9','R44 parent manifest mismatch');
+  insist(parent.parent_manifest_file_count===1834,'R44 parent file count mismatch');
+  insist(parent.parent_generation_manifest_sha256==='fcfcb5a47d55039b7bb5d42faa0739b57b13d8a420d4418ae09d96d2862967cb','R44 parent generation mismatch');
+  insist(parent.parent_generation_file_count===7,'R44 parent generation file count mismatch');
+  insist(parent.parent_final_closure_file_sha256==='f24100212b55d2016ea9c4ff47df5f026c8edc0b9b8643933ed8bf26fde3803f','R44 parent closure file hash mismatch');
+  insist(parent.parent_final_closure_sha256==='2f29e94dd726638c23b2e520a608dcf2a6919e43348855be3940599d557f920b','R44 parent closure hash mismatch');
+  insist(parent.parent_final_closure_signer_key_id==='c0727a7911e29a0f1edd3cd910e47f89f43edb484743988c89cd82bfd5e37936','R44 parent closure signer mismatch');
+  insist(parent.parent_proof==='immutable-slot+generation+signed-final-closure','R44 parent proof class mismatch');
+
+  const closureBytes=await readFile(path.resolve(parent.parent_final_closure_path));
+  insist(sha256(closureBytes)===parent.parent_final_closure_file_sha256,'R44 parent closure file bytes mismatch');
+  const envelope=JSON.parse(closureBytes.toString('utf8'));
+  insist(envelope?.body?.schema==='deadbyte.r43-final-closure.v1','R44 parent closure schema mismatch');
+  insist(envelope.body.version===parent.parent_version,'R44 parent closure version mismatch');
+  insist(envelope.body.release_label==='R43 AUTHORITY HARDENING PATCH','R44 parent closure label mismatch');
+
+  const publicKey=createPublicKey(await readFile(path.join(path.resolve(stateRoot),'trust','ed25519-public.pem')));
+  insist(publicKey.asymmetricKeyType==='ed25519','R44 parent trust key must be Ed25519');
+  const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+  insist(keyId===parent.parent_final_closure_signer_key_id,'R44 parent trust key id mismatch');
+  const bodyBytes=Buffer.from(canonicalJson(envelope.body),'utf8');
+  insist(sha256(bodyBytes)===envelope.body_sha256,'R44 parent closure body hash mismatch');
+  const {closure_sha256,...unsigned}=envelope;
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===closure_sha256,'R44 parent closure envelope hash mismatch');
+  insist(closure_sha256===parent.parent_final_closure_sha256,'R44 parent closure content address mismatch');
+  insist(envelope.attestation?.algorithm==='ed25519'&&envelope.attestation?.domain==='DEADBYTE-R43-FINAL-CLOSURE-V1','R44 parent closure attestation contract mismatch');
+  insist(envelope.attestation.key_id===keyId,'R44 parent closure attestation signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([CLOSURE_DOMAIN,bodyBytes]),publicKey,Buffer.from(envelope.attestation.signature_base64,'base64')),'R44 parent closure signature invalid');
+
+  const pointer=envelope.body.active_pointer;
+  insist(pointer?.release_id===parent.parent_release_id&&pointer?.version===parent.parent_version&&pointer?.manifest_sha256===parent.parent_manifest_sha256,'R44 parent closure release binding mismatch');
+  insist(pointer.generation_manifest_sha256===parent.parent_generation_manifest_sha256,'R44 parent closure generation binding mismatch');
+  insist(pointer.launcher_sha256===parent.parent_launcher_sha256,'R44 parent launcher binding mismatch');
+  insist(samePath(pointer.release_root,parent.parent_release_root),'R44 parent release root mismatch');
+  insist(samePath(pointer.generation_root,parent.parent_generation_root),'R44 parent generation root mismatch');
+  insist(envelope.body.immutable_slot?.protected===true,'R44 parent immutable slot proof missing');
+  insist(samePath(envelope.body.immutable_slot.release_root,parent.parent_release_root),'R44 parent immutable release root mismatch');
+  insist(!samePath(envelope.body.immutable_slot.development_root,parent.parent_release_root),'R44 parent development root aliases release slot');
+  insist(samePath(envelope.body.immutable_slot.development_root,parent.development_root),'R44 parent development root mismatch');
+  insist(envelope.body.authority?.all_disarmed===true,'R44 parent closure did not record all-disarmed state');
+  for(const name of ['process-grant.json','coding-grant.json','autonomous-grant.json','desktop-grant.json','host-grant.json']){
+    insist(envelope.body.authority.grants_absent?.[name]===true,`R44 parent closure grant absence missing: ${name}`);
+  }
+
+  const evidence=envelope.body.evidence;
+  insist(evidence&&evidence.parity&&evidence.activation&&evidence.rollback&&evidence.restore&&evidence.windows_gate,'R44 parent closure evidence set incomplete');
+  for(const [name,item] of Object.entries(evidence)){
+    insist(typeof item?.path==='string'&&HEX64.test(item?.sha256??''),`R44 parent ${name} evidence identity malformed`);
+    insist(sha256(await readFile(item.path))===item.sha256,`R44 parent ${name} evidence hash mismatch`);
+  }
+  const parity=JSON.parse(await readFile(evidence.parity.path,'utf8'));
+  insist(parity?.schema==='deadbyte.r43-parity.v1'&&parity.status==='passed','R44 parent parity status mismatch');
+  insist(parity.candidate?.release_id===parent.parent_release_id&&parity.candidate?.manifest_sha256===parent.parent_manifest_sha256,'R44 parent parity candidate mismatch');
+  insist(parity.successor?.release_id===parent.parent_release_id&&parity.successor?.manifest_sha256===parent.parent_manifest_sha256,'R44 parent parity successor mismatch');
+  insist(parity.successor_disarmed?.status==='passed','R44 parent successor-disarmed proof missing');
+
+  const releaseFiles=await verifyTree(parent.parent_release_root,'MANIFEST.SHA256',parent.parent_manifest_sha256,parent.parent_manifest_file_count);
+  const generationFiles=await verifyTree(parent.parent_generation_root,'GENERATION.SHA256',parent.parent_generation_manifest_sha256,parent.parent_generation_file_count);
+  return {
+    ok:true,
+    status:'passed',
+    proof_class:parent.parent_proof,
+    release_id:parent.parent_release_id,
+    manifest_sha256:parent.parent_manifest_sha256,
+    generation_manifest_sha256:parent.parent_generation_manifest_sha256,
+    release_files:releaseFiles,
+    generation_files:generationFiles,
+    closure_sha256:parent.parent_final_closure_sha256,
+    closure_file_sha256:parent.parent_final_closure_file_sha256,
+    signer_key_id:keyId,
+    recorded_all_disarmed:true
+  };
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  const file=process.argv[2]??path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..','R44-PARENT.json');
+  verifyR44Parent(file).then(result=>console.log(JSON.stringify(result,null,2)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/windows-gate-evidence-r42.mjs

@@ -0,0 +1,64 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import { readAndVerifyR42EvalEvidence } from '../src/agent-eval-runner-r42.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.14.0 / R42 WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok) throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.14.0',`Windows gate evidence requires V0.14.0, found ${pkg.version}`);
+
+  const suite=JSON.parse(await readFile(path.join(candidate,'harness','r42-agent-evals.json'),'utf8'));
+  const suiteSha256=sha256(Buffer.from(canonicalJson(suite),'utf8'));
+  const evalId=`r42-${manifestSha256.slice(0,16)}-${suiteSha256.slice(0,16)}`;
+  const evalPath=path.join(path.resolve(stateRoot),'evidence','release','r42-agent-evals','agent_eval',`${evalId}.json`);
+  const evalVerified=await readAndVerifyR42EvalEvidence(evalPath,{subjectManifestSha256:manifestSha256,suiteSha256});
+
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r42-windows-gate.v1',status:'passed',exit_code:0,version:'0.14.0',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256,
+    model_eval:{path:evalPath,evidence_sha256:evalVerified.evidence_sha256,payload_sha256:evalVerified.payload_sha256,
+      suite_sha256:suiteSha256,case_count:evalVerified.payload.case_count}
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r42-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256,model_eval:evidence.model_eval};
+  }catch(error){
+    if(error?.code!=='EEXIST') throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing R42 Windows gate evidence invalid');
+    insist(existing.version==='0.14.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing R42 Windows gate identity mismatch');
+    insist(existing.model_eval?.evidence_sha256===evidence.model_eval.evidence_sha256&&existing.model_eval?.suite_sha256===suiteSha256,'existing R42 Windows gate model-eval mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256,model_eval:existing.model_eval};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  writeWindowsGateEvidence()
+    .then(result=>console.log(JSON.stringify(result)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/windows-gate-evidence-r43.mjs

@@ -0,0 +1,55 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyR43Parent } from './verify-r43-parent.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.14.1 / R43 AUTHORITY HARDENING WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok)throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.14.1',`Windows gate evidence requires V0.14.1, found ${pkg.version}`);
+  const parent=await verifyR43Parent(path.join(candidate,'R43-PARENT.json'));
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r43-windows-gate.v1',status:'passed',exit_code:0,version:'0.14.1',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256,
+    parent:{release_id:parent.parent_release_id,manifest_sha256:parent.parent_manifest_sha256,
+      generation_manifest_sha256:parent.parent_generation_manifest_sha256,
+      activation_receipt_sha256:parent.parent_activation_receipt_sha256},
+    hardening:{authority_toctou:true,absolute_execution_deadline:true,pre_spawn_authority_recheck:true,
+      full_regression_required:true,model_path_changed:false}
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r43-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256,parent:evidence.parent};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing R43 Windows gate evidence invalid');
+    insist(existing.version==='0.14.1'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing R43 Windows gate identity mismatch');
+    insist(existing.parent?.release_id===parent.parent_release_id&&existing.parent?.activation_receipt_sha256===parent.parent_activation_receipt_sha256,'existing R43 parent evidence mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256,parent:existing.parent};
+  }
+}
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)writeWindowsGateEvidence().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/scripts/windows-gate-evidence-r44.mjs

@@ -0,0 +1,55 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyR44Parent } from './verify-r44-parent.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.15.0 / R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok)throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.15.0',`Windows gate evidence requires V0.15.0, found ${pkg.version}`);
+  const parent=await verifyR44Parent(path.join(candidate,'R44-PARENT.json'));
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r44-windows-gate.v1',status:'passed',exit_code:0,version:'0.15.0',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256,
+    parent:{release_id:parent.release_id,manifest_sha256:parent.manifest_sha256,
+      generation_manifest_sha256:parent.generation_manifest_sha256,
+      final_closure_sha256:parent.closure_sha256,final_closure_file_sha256:parent.closure_file_sha256,
+      signer_key_id:parent.signer_key_id},
+    features:{skill_integrity:true,agent_backend_persistence:true,codex_protocol_contract:true,
+      remote_device_identity:true,durable_job_supervisor:true,real_external_supervisor_smoke:true,
+      full_regression_required:true,codex_live_binary_required:false}
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r44-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256,parent:evidence.parent};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing R44 Windows gate evidence invalid');
+    insist(existing.version==='0.15.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing R44 Windows gate identity mismatch');
+    insist(existing.parent?.release_id===parent.release_id&&existing.parent?.final_closure_sha256===parent.closure_sha256,'existing R44 parent evidence mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256,parent:existing.parent};
+  }
+}
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)writeWindowsGateEvidence().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});