deadbyte-mcp 0.12.0 → 0.14.0

package/scripts/release-parity-r42.mjs

@@ -0,0 +1,235 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
+import { loadPowerShellDataFile } from '../src/runtime-update.mjs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { probeR40FullSurface } from '../src/r40-full-surface-probe.mjs';
+import { runR40CompactParity } from '../src/remote-mcp-r40-parity-client.mjs';
+import { probeR40CompactDisarmed } from '../src/r40-compact-disarmed-probe.mjs';
+import { probeR36CompactDisarmed } from '../src/r36-compact-disarmed-probe.mjs';
+import { runR40DesktopGuardedSmoke } from '../src/remote-mcp-desktop-r40-smoke-client.mjs';
+import { verifyR41Memory } from './verify-memory-r41.mjs';
+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 stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const deferred=path.join(root,'scripts','deferred-slot-operation-r42.mjs');
+const ps='C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+const launcher=path.join(stateRoot,'bin','DEADBYTE-MCP.ps1');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+export const R42_PREDECESSOR_RELEASE_ID='v0.13.0-3255be10de4daf08';
+export const R42_PREDECESSOR_MANIFEST='3255be10de4daf0837d67d1ab1913b785b8b8215bc7405823c2ff46968c4b98f';
+
+function assert(condition,message){if(!condition) throw new Error(message);}
+function parseFrozenManifest(text){
+  const entries=[];const seen=new Set();
+  for(const [index,line] of text.split(/\r?\n/).entries()){
+    if(!line) continue;
+    const match=/^([0-9a-f]{64})  ([^\0]+)$/.exec(line);
+    assert(match,`frozen manifest line ${index+1} malformed`);
+    const rel=match[2];
+    assert(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!seen.has(rel),`unsafe/duplicate frozen manifest path: ${rel}`);
+    seen.add(rel);entries.push({sha256:match[1],path:rel});
+  }
+  return entries;
+}
+// Restore the mutable development stage from the immutable active release after live parity work may drift it.
+export async function restoreFrozenStage({developmentRoot,releaseRoot,expectedManifestSha256}){
+  const dev=path.resolve(developmentRoot);const release=path.resolve(releaseRoot);
+  const manifestBytes=await readFile(path.join(release,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  assert(manifestSha256===expectedManifestSha256,`immutable release manifest drift: ${manifestSha256}`);
+  const entries=parseFrozenManifest(manifestBytes.toString('utf8'));
+  for(const entry of entries){
+    const source=path.join(release,...entry.path.split('/'));const bytes=await readFile(source);
+    assert(sha256(bytes)===entry.sha256,`immutable release file drift: ${entry.path}`);
+    const destination=path.join(dev,...entry.path.split('/'));await mkdir(path.dirname(destination),{recursive:true});
+    await writeFile(destination,bytes);assert(sha256(await readFile(destination))===entry.sha256,`development restore verification failed: ${entry.path}`);
+  }
+  await writeFile(path.join(dev,'MANIFEST.SHA256'),manifestBytes);
+  assert(sha256(await readFile(path.join(dev,'MANIFEST.SHA256')))===expectedManifestSha256,'development manifest restore verification failed');
+  return {status:'restored',file_count:entries.length,manifest_sha256:manifestSha256};
+}
+function parseJsonOutput(text,label){
+  const trimmed=String(text).trim();const starts=[...trimmed.matchAll(/\{/g)].map(match=>match.index);
+  for(const start of starts){try{return JSON.parse(trimmed.slice(start));}catch{}}
+  throw new Error(`${label} did not emit JSON`);
+}
+function run(command,args,{timeoutMs=900000,env=process.env,cwd=root}={}){
+  return new Promise((resolve,reject)=>{
+    const child=spawn(command,args,{cwd,shell:false,windowsHide:true,env,stdio:['ignore','pipe','pipe']});
+    const out=[],err=[];const timer=setTimeout(()=>{child.kill();reject(new Error(`command timeout: ${path.basename(command)}`));},timeoutMs);
+    child.stdout.on('data',chunk=>out.push(Buffer.from(chunk)));child.stderr.on('data',chunk=>err.push(Buffer.from(chunk)));
+    child.on('error',error=>{clearTimeout(timer);reject(error);});child.on('exit',code=>{
+      clearTimeout(timer);const stdout=Buffer.concat(out).toString('utf8');const stderr=Buffer.concat(err).toString('utf8');
+      if(code!==0) reject(new Error(`command failed exit=${code}: ${stderr||stdout}`));else resolve({stdout,stderr,exitCode:code});
+    });
+  });
+}
+async function publicUrl(){
+  const value=(await readFile(path.join(stateRoot,'bridge','mcp-url.txt'),'utf8')).trim();const url=new URL(value);
+  if(url.protocol!=='https:') throw new Error('public MCP URL must be HTTPS');return value;
+}
+async function pointer(){return JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));}
+async function disarmAll(){
+  for(const command of ['disarmdesktop','disarmautonomous','disarmcoding','disarmprocess','disarmhost']){
+    await run(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,command],{timeoutMs:60000});
+  }
+}
+async function waitDeferred(statePath,timeoutMs=180000){
+  const deadline=Date.now()+timeoutMs;
+  while(Date.now()<deadline){const state=JSON.parse(await readFile(statePath,'utf8'));if(state.state==='completed') return state;if(state.state==='failed') throw new Error(`deferred ${state.mode} failed: ${state.error}`);await sleep(500);}
+  throw new Error(`deferred operation timeout: ${statePath}`);
+}
+async function scheduleDeferred(mode,value,{bridgeRoot=null,bridgeScriptSha256=null}={}){
+  if((bridgeRoot===null)!==(bridgeScriptSha256===null)) throw new Error('deferred bridge override requires exact root + SHA pair');
+  const args=[deferred,mode,value];
+  if(bridgeRoot!==null) args.push('--bridge-root',bridgeRoot,'--bridge-script-sha256',bridgeScriptSha256);
+  const scheduled=parseJsonOutput((await run(process.execPath,args,{timeoutMs:30000})).stdout,`deferred ${mode}`);
+  assert(scheduled.status==='scheduled',`deferred ${mode} was not scheduled`);
+  assert(scheduled.execution_provider==='deadbyte_mcp'&&scheduled.rdc_operation_count===0,'deferred operation provider mismatch');
+  return {scheduled,completed:await waitDeferred(scheduled.state_path)};
+}
+async function verifyR42ModelEval(candidateManifest){
+  const suite=JSON.parse(await readFile(path.join(root,'harness','r42-agent-evals.json'),'utf8'));
+  const suiteSha256=sha256(Buffer.from(canonicalJson(suite),'utf8'));
+  const evidenceId=`r42-${candidateManifest.slice(0,16)}-${suiteSha256.slice(0,16)}`;
+  const file=path.join(stateRoot,'evidence','release','r42-agent-evals','agent_eval',`${evidenceId}.json`);
+  const verified=await readAndVerifyR42EvalEvidence(file,{subjectManifestSha256:candidateManifest,suiteSha256});
+  return {status:'passed',path:file,evidence_sha256:verified.evidence_sha256,payload_sha256:verified.payload_sha256,
+    suite_sha256:suiteSha256,case_count:verified.payload.case_count};
+}
+
+async function publicR40PredecessorDisarmed(url){
+  const result=await probeR36CompactDisarmed(url);
+  assert(result.status==='passed'&&result.tool_count<=42&&result.capability_closure===true,'R40 predecessor public compact catalog mismatch');
+  assert(result.release_id===R42_PREDECESSOR_RELEASE_ID&&result.release_manifest_sha256===R42_PREDECESSOR_MANIFEST,'R40 predecessor machine binding mismatch');
+  assert(result.coding_armed===false&&result.autonomous_armed===false,'R40 predecessor authority remained armed');
+  return result;
+}
+async function mutableCore(pointerValue){
+  const policy=JSON.parse(await readFile(path.join(pointerValue.generation_root,'coding-policy.json'),'utf8'));
+  const raw=policy?.roots?.core?.path??policy?.roots?.core?.real_path;
+  assert(typeof raw==='string'&&raw,'R40 generation missing coding core root');
+  const core=path.resolve(raw);const release=path.resolve(pointerValue.release_root);
+  assert(core.toLowerCase()!==release.toLowerCase(),'R40 coding core must not point at immutable active release slot');
+  return core;
+}
+
+export function validateParityEvidence(value){
+  assert(value?.schema==='deadbyte.r42-parity.v1','R40 parity schema mismatch');
+  assert(value.status==='passed','R40 parity status is not passed');
+  assert(value.rdc_operation_count===0&&value.execution_provider==='deadbyte_mcp','R40 parity used non-DEADBYTE execution');
+  assert(value.candidate?.version==='0.14.0'&&/^[0-9a-f]{64}$/.test(value.candidate?.manifest_sha256??''),'R40 candidate identity missing');
+  assert(value.local_full?.status==='passed'&&value.local_full?.tool_count===80&&value.local_full?.strict_output_schemas===true,'R40 local full 80-tool proof missing');
+  assert(value.public_compact?.status==='passed'&&value.public_compact?.tool_count===42&&value.public_compact?.capability_closure===true&&value.public_compact?.gateway_count===6&&value.public_compact?.desktop_armed===false&&value.public_compact?.desktop_observation_receipt_verified===true&&value.public_compact?.desktop_grounding_receipt_verified===true,'R40 public compact/Desktop closure missing');
+  assert(value.desktop_guarded?.status==='passed'&&value.desktop_guarded?.native_injected===true&&value.desktop_guarded?.replay_performed===false&&
+    Number.isInteger(value.desktop_guarded?.predispatch_retry_count)&&value.desktop_guarded.predispatch_retry_count>=0&&value.desktop_guarded.predispatch_retry_count<=2&&
+    value.desktop_guarded?.observation_receipts_verified===value.desktop_guarded.predispatch_retry_count+1&&value.desktop_guarded?.action_receipts_verified===3,
+    'R40 guarded Desktop proof missing');
+  assert(value.autonomous?.status==='passed'&&value.autonomous?.signed_release_verified===true,'R40 autonomous live proof missing');
+  assert(value.deterministic_memory?.status==='passed'&&value.deterministic_memory?.goal_count>=1&&value.deterministic_memory?.snapshot_count>=1&&value.deterministic_memory?.index_count>=1,'R41 deterministic memory proof missing');
+  assert(value.model_eval?.status==='passed'&&value.model_eval?.case_count>=1&&/^[0-9a-f]{64}$/.test(value.model_eval?.evidence_sha256??''),'R42 model-backed eval proof missing');
+  assert(value.before_rollback_disarmed?.status==='passed'&&value.before_rollback_disarmed?.capability_closure===true&&value.before_rollback_disarmed?.coding_armed===false&&value.before_rollback_disarmed?.autonomous_armed===false&&value.before_rollback_disarmed?.desktop_armed===false,'R40 pre-rollback disarm proof missing');
+  assert(value.rollback?.state==='completed'&&value.restore?.state==='completed','R40 rollback/restore not completed');
+  assert(value.stage_restore?.status==='restored'&&value.stage_restore?.manifest_sha256===value.candidate.manifest_sha256,'R40 stage restore proof missing');
+  assert(value.predecessor?.release_id===R42_PREDECESSOR_RELEASE_ID&&value.predecessor?.manifest_sha256===R42_PREDECESSOR_MANIFEST&&value.predecessor?.version==='0.13.0','R40 exact predecessor identity mismatch');
+  assert(value.predecessor_disarmed?.status==='passed'&&value.predecessor_disarmed?.tool_count<=42&&value.predecessor_disarmed?.capability_closure===true,'R40 predecessor public proof missing');
+  assert(value.successor?.version==='0.14.0'&&value.successor?.manifest_sha256===value.candidate.manifest_sha256,'R40 exact successor restore identity mismatch');
+  assert(value.successor_disarmed?.status==='passed'&&value.successor_disarmed?.capability_closure===true&&value.successor_disarmed?.coding_armed===false&&value.successor_disarmed?.autonomous_armed===false&&value.successor_disarmed?.desktop_armed===false,'R40 successor disarmed proof missing');
+  assert(value.immutable_slot?.protected===true&&value.immutable_slot?.development_root!==value.immutable_slot?.release_root,'R40 immutable-slot separation missing');
+  for(const key of ['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface','desktop_readonly','desktop_guarded_input','deterministic_memory','model_eval']) assert(value.requirements?.[key]===true,`R41 parity requirement not proven: ${key}`);
+  return true;
+}
+
+export async function runReleaseParity(activationReceiptPath){
+  const active=await pointer();const candidateManifest=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+  assert(active.version==='0.14.0','R41 parity requires active 0.14.0 candidate');
+  assert(active.manifest_sha256===candidateManifest,'active release is not canonical R40 candidate');
+  const activeConfig=await loadPowerShellDataFile(active.config_path);
+  const successorBridgeRootRaw=activeConfig?.Bridge?.WorkingDirectory;
+  const successorBridgeConfiguredSha=activeConfig?.Bridge?.ScriptSha256;
+  assert(typeof successorBridgeRootRaw==='string'&&path.isAbsolute(successorBridgeRootRaw),'R40 active bridge root missing');
+  assert(typeof successorBridgeConfiguredSha==='string'&&/^[0-9a-f]{64}$/.test(successorBridgeConfiguredSha),'R40 active bridge SHA missing');
+  const successorBridgeRoot=await realpath(path.resolve(successorBridgeRootRaw));
+  const successorBridgeActualSha=sha256(await readFile(path.join(successorBridgeRoot,'src','bridge.mjs')));
+  assert(successorBridgeActualSha===successorBridgeConfiguredSha,'R40 active bridge bytes do not match generation pin');
+  const successorBridge={root:successorBridgeRoot,sha256:successorBridgeActualSha};
+  const developmentRoot=await mutableCore(active);
+  const localFull=await probeR40FullSurface({packageRoot:active.release_root,generationRoot:active.generation_root,stateRoot});
+  const url=await publicUrl();
+  let publicCompact,autonomous,desktopGuarded;
+  try{
+    publicCompact=await runR40CompactParity(url);
+    autonomous=parseJsonOutput((await run(process.execPath,[path.join(root,'src','remote-mcp-autonomous-smoke-client.mjs'),url],{timeoutMs:900000})).stdout,'R40 autonomous compact parity');
+    assert(autonomous.status==='passed'&&autonomous.signed_release_verified===true,'R40 autonomous compact parity failed');
+    await run(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,'armdesktop'],{timeoutMs:60000});
+    try{desktopGuarded=await runR40DesktopGuardedSmoke(url);}
+    finally{await run(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,'disarmdesktop'],{timeoutMs:60000}).catch(()=>{});}
+    assert(desktopGuarded.status==='passed'&&desktopGuarded.native_injected===true&&desktopGuarded.action_receipts_verified===3,'R40 guarded Desktop public smoke failed');
+  }catch(error){await disarmAll().catch(()=>{});throw error;}
+  const deterministicMemory=await verifyR41Memory({memoryRoot:path.join(stateRoot,'evidence','autonomous','memory-r41',candidateManifest),
+    journalRoot:path.join(stateRoot,'evidence','autonomous','goals'),sourceReleaseManifest:candidateManifest,
+    publicKeyPath:path.join(stateRoot,'trust','ed25519-public.pem')});
+  assert(deterministicMemory.goal_count>=1&&deterministicMemory.snapshot_count>=1&&deterministicMemory.index_count>=1,'R41 live deterministic memory evidence missing');
+  const modelEval=await verifyR42ModelEval(candidateManifest);
+  assert(modelEval.status==='passed'&&modelEval.case_count>=1,'R42 model-backed eval evidence missing');
+
+  await disarmAll();
+  const beforeRollback=await probeR40CompactDisarmed(url);
+  const rollbackPair=await scheduleDeferred('rollback',path.resolve(activationReceiptPath));
+  const predecessor=await pointer();
+  assert(predecessor.release_id===R42_PREDECESSOR_RELEASE_ID&&predecessor.manifest_sha256===R42_PREDECESSOR_MANIFEST&&predecessor.version==='0.13.0','rollback did not reach exact sealed R40 predecessor');
+  const predecessorDisarmed=await publicR40PredecessorDisarmed(url);
+  const stageRestore=await restoreFrozenStage({developmentRoot,releaseRoot:active.release_root,expectedManifestSha256:candidateManifest});
+  const restorePair=await scheduleDeferred('activate',candidateManifest,{bridgeRoot:successorBridge.root,bridgeScriptSha256:successorBridge.sha256});
+  const successor=await pointer();
+  assert(successor.version==='0.14.0'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R40 candidate');
+  const successorDisarmed=await probeR40CompactDisarmed(url);
+  await disarmAll();
+
+  const evidence={
+    schema:'deadbyte.r42-parity.v1',status:'passed',completed_at_utc:new Date().toISOString(),execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:active.release_id,version:active.version,manifest_sha256:candidateManifest},
+    immutable_slot:{protected:true,release_root:path.resolve(active.release_root),development_root:developmentRoot},
+    local_full:localFull,public_compact:publicCompact,autonomous,deterministic_memory:deterministicMemory,model_eval:modelEval,desktop_guarded:desktopGuarded,before_rollback_disarmed:beforeRollback,
+    rollback:{...rollbackPair.completed,scheduled_operation_id:rollbackPair.scheduled.operation_id},
+    predecessor:{release_id:predecessor.release_id,version:predecessor.version,manifest_sha256:predecessor.manifest_sha256},predecessor_disarmed:predecessorDisarmed,
+    stage_restore:stageRestore,
+    restore:{...restorePair.completed,scheduled_operation_id:restorePair.scheduled.operation_id},
+    successor:{release_id:successor.release_id,version:successor.version,manifest_sha256:successor.manifest_sha256},successor_disarmed:successorDisarmed,
+    requirements:{
+      tree_read:publicCompact.tree_entries>=0&&publicCompact.coding_stat_verified===true,
+      precondition_mutation:publicCompact.machine_fs_receipts_verified>=3,
+      search:publicCompact.coding_search_result_count>=1&&publicCompact.observation_search_result_count>=1,
+      owned_process:typeof publicCompact.process_session_id==='string'&&publicCompact.process_output_bytes>0,
+      observation:publicCompact.observation_receipts_verified>=2,
+      coding_loop:publicCompact.coding_receipts_verified===2,
+      autonomy:autonomous.signed_release_verified===true&&autonomous.observed_failure_before_replan===true,
+      interrupted_recovery:rollbackPair.completed.state==='completed'&&restorePair.completed.state==='completed',
+      evidence_verification:publicCompact.machine_fs_receipts_verified>=3&&autonomous.signed_release_verified===true,
+      compact_closure:publicCompact.capability_closure===true&&successorDisarmed.capability_closure===true,
+      full_surface:localFull.tool_count===80&&localFull.strict_output_schemas===true,
+      desktop_readonly:publicCompact.desktop_armed===false&&publicCompact.desktop_observation_receipt_verified===true&&publicCompact.desktop_grounding_receipt_verified===true,
+      desktop_guarded_input:desktopGuarded.native_injected===true&&desktopGuarded.replay_performed===false&&desktopGuarded.action_receipts_verified===3,
+      deterministic_memory:deterministicMemory.status==='passed'&&deterministicMemory.goal_count>=1&&deterministicMemory.snapshot_count>=1,
+      model_eval:modelEval.status==='passed'&&modelEval.case_count>=1
+    }
+  };
+  validateParityEvidence(evidence);
+  const evidenceDir=path.join(stateRoot,'evidence','release');await mkdir(evidenceDir,{recursive:true});
+  const evidencePath=path.join(evidenceDir,`r42-parity-${candidateManifest.slice(0,16)}.json`);
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');await writeFile(evidencePath,bytes);
+  return {evidence,evidence_path:evidencePath,evidence_sha256:sha256(bytes)};
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  const receipt=process.argv[2];if(!receipt) throw new Error('usage: node scripts/release-parity-r42.mjs <activation-receipt.json>');
+  runReleaseParity(receipt).then(result=>console.log(JSON.stringify({status:'passed',...result},null,2))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/release-parity-tests-r41.ps1

@@ -0,0 +1,9 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+$root = Split-Path -Parent $PSScriptRoot
+Push-Location $root
+try {
+    & node.exe --test test\memory-snapshot-r41.test.mjs test\memory-projections-r41.test.mjs test\memory-retrieval-r41.test.mjs test\memory-history-r41.test.mjs test\memory-autonomous-integration-r41.test.mjs test\r41-finalization.test.mjs test\controller.test.mjs test\controller-desktop-r40.test.mjs test\r40-finalization.test.mjs test\release-version.test.mjs test\desktop-contract-r40.test.mjs test\desktop-policy-r40.test.mjs test\desktop-observer-r40.test.mjs test\desktop-input-r40.test.mjs test\desktop-uia-r40.test.mjs test\desktop-runtime-r40.test.mjs test\desktop-memory-r40.test.mjs test\desktop-mcp-tools-r40.test.mjs test\desktop-adversarial-r40.test.mjs test\autonomous-desktop-r40.test.mjs test\release-generation.test.mjs test\runtime-self-update.test.mjs test\r37-0110-history.test.mjs test\r37-agent-fabric.test.mjs test\remote-live-log-r37.test.mjs test\remote-session-cli.test.mjs test\r36-finalization.test.mjs test\r36-release-identity.test.mjs test\deferred-slot-operation.test.mjs
+    if ($LASTEXITCODE -ne 0) { throw "R41 release parity tests failed with exit code $LASTEXITCODE" }
+    Write-Output 'R41 RELEASE PARITY TEST PASS'
+} finally { Pop-Location }

package/scripts/release-parity-tests-r42.ps1

@@ -0,0 +1,6 @@
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version 2.0
+& node.exe --test test\provider-responses-r42.test.mjs test\task-contract-r42.test.mjs test\human-clarification-r42.test.mjs test\agent-governance-r42.test.mjs test\evidence-publisher-r42.test.mjs test\agent-eval-r42.test.mjs test\agent-eval-runner-r42.test.mjs test\r42-finalization.test.mjs
+if($LASTEXITCODE -ne 0){exit $LASTEXITCODE}
+& node.exe --test test\memory-snapshot-r41.test.mjs test\memory-projections-r41.test.mjs test\memory-retrieval-r41.test.mjs test\memory-history-r41.test.mjs test\memory-autonomous-integration-r41.test.mjs
+exit $LASTEXITCODE

package/scripts/verify-memory-r41.mjs

@@ -0,0 +1,88 @@
+import { createHash } from 'node:crypto';
+import { readFile,readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import { loadPublicVerifyKey } from '../src/trust.mjs';
+import { buildMemoryArchive,buildMemoryCorpus,buildRetrievalIndex,verifyMemoryGoal,verifyMemoryJournal,
+  verifyMemorySnapshot,verifyRetrievalIndex } from '../src/memory-r41.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const readJson=async file=>JSON.parse((await readFile(file,'utf8')).replace(/^\uFEFF/,''));
+async function jsonFiles(dir){return (await readdir(dir)).filter(name=>name.endsWith('.json')).sort();}
+function parseArgs(argv){
+  const out={};for(let index=0;index<argv.length;index+=2){const key=argv[index];insist(key?.startsWith('--')&&argv[index+1],`invalid argument ${key??''}`);out[key.slice(2)]=argv[index+1];}
+  for(const key of ['memory-root','journal-root','manifest','public-key'])insist(out[key],`missing --${key}`);return out;
+}
+async function loadCanonicalGoal(journalRoot,goalId,publicKey,keyId,manifest){
+  const root=path.join(journalRoot,goalId);const goal=verifyMemoryGoal(await readJson(path.join(root,'goal.json')),{publicKey,keyId,expectedGoalId:goalId});
+  const names=await jsonFiles(path.join(root,'events'));
+  insist(names.every((name,index)=>name===`${String(index+1).padStart(6,'0')}.json`),`event gap for ${goalId}`);
+  const events=[];for(const name of names)events.push(await readJson(path.join(root,'events',name)));
+  verifyMemoryJournal(events,{goalId,publicKey,keyId});
+  insist(events[0]?.type==='goal_created'&&events[0]?.payload?.source_release_manifest===manifest,`goal ${goalId} is not bound to release manifest`);
+  return {goal,events,corpus:buildMemoryCorpus({goal,events,publicKey,keyId,sourceReleaseManifest:manifest})};
+}
+
+export async function verifyR41Memory({memoryRoot,journalRoot,sourceReleaseManifest,publicKeyPath}={}){
+  insist(path.isAbsolute(memoryRoot)&&path.isAbsolute(journalRoot),'memory verifier roots must be absolute');insist(HEX64.test(sourceReleaseManifest??''),'memory verifier manifest invalid');
+  const {publicKey,keyId}=await loadPublicVerifyKey(publicKeyPath);const canonical=new Map();let snapshots=0,indexes=0,archives=0,archiveIndexes=0;
+  let journalGoalIds=[];try{journalGoalIds=(await readdir(journalRoot,{withFileTypes:true})).filter(entry=>entry.isDirectory()&&HEX64.test(entry.name)).map(entry=>entry.name).sort();}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+  for(const goalId of journalGoalIds){
+    const firstPath=path.join(journalRoot,goalId,'events','000001.json');let first;
+    try{first=await readJson(firstPath);}catch(error){if(error?.code==='ENOENT')continue;throw error;}
+    verifyMemoryJournal([first],{goalId,publicKey,keyId});
+    if(first.type!=='goal_created'||first.payload?.source_release_manifest!==sourceReleaseManifest)continue;
+    const loaded=await loadCanonicalGoal(journalRoot,goalId,publicKey,keyId,sourceReleaseManifest);canonical.set(goalId,loaded);
+  }
+  let goalIds=[];try{goalIds=(await readdir(path.join(memoryRoot,'goals'),{withFileTypes:true})).filter(entry=>entry.isDirectory()&&HEX64.test(entry.name)).map(entry=>entry.name).sort();}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+  for(const goalId of goalIds){
+    const loaded=canonical.get(goalId);insist(loaded,`memory projection goal ${goalId} has no canonical release-bound journal`);
+    const base=path.join(memoryRoot,'goals',goalId);const corporaByMemoryHash=new Map();
+    for(const name of await jsonFiles(path.join(base,'snapshots'))){
+      const value=await readJson(path.join(base,'snapshots',name));
+      const proof=verifyMemorySnapshot(value,{goal:loaded.goal,events:loaded.events,publicKey,keyId,sourceReleaseManifest});
+      insist(proof.ok,`snapshot invalid ${goalId}/${name}: ${proof.reason}`);
+      const prefixEvents=loaded.events.slice(0,proof.last_event_seq);
+      const prefixCorpus=buildMemoryCorpus({goal:loaded.goal,events:prefixEvents,publicKey,keyId,sourceReleaseManifest});
+      const prior=corporaByMemoryHash.get(prefixCorpus.memory_sha256);
+      insist(!prior||canonicalJson(prior)===canonicalJson(prefixCorpus),`snapshot corpus collision ${goalId}/${name}`);
+      corporaByMemoryHash.set(prefixCorpus.memory_sha256,prefixCorpus);snapshots+=1;
+    }
+    for(const name of await jsonFiles(path.join(base,'indexes'))){
+      const value=await readJson(path.join(base,'indexes',name));
+      const sourceCorpus=corporaByMemoryHash.get(value.source_memory_sha256);
+      insist(sourceCorpus,`index source memory hash has no verified snapshot prefix ${goalId}/${name}`);
+      const proof=verifyRetrievalIndex(value,{corpus:sourceCorpus,sourceReleaseManifest});
+      insist(proof.ok,`index invalid ${goalId}/${name}: ${proof.reason}`);indexes+=1;
+    }
+  }
+  const archiveByHash=new Map();
+  try{for(const name of await jsonFiles(path.join(memoryRoot,'archives'))){const value=await readJson(path.join(memoryRoot,'archives',name));
+    const corpora=value.corpus_refs.map(ref=>{
+      const loaded=canonical.get(ref.goal_id);insist(loaded,`archive references noncanonical goal ${ref.goal_id}`);
+      const headIndex=loaded.events.findIndex(event=>event.event_sha256===ref.journal_head_sha256);
+      insist(headIndex>=0,`archive references unknown journal head ${ref.goal_id}`);
+      const corpus=buildMemoryCorpus({goal:loaded.goal,events:loaded.events.slice(0,headIndex+1),publicKey,keyId,sourceReleaseManifest});
+      insist(corpus.memory_sha256===ref.memory_sha256,`archive references noncanonical goal prefix ${ref.goal_id}`);
+      return corpus;
+    });
+    const expected=buildMemoryArchive(corpora,{sourceReleaseManifest});insist(canonicalJson(expected)===canonicalJson(value),'archive projection mismatch');insist(name===`${value.memory_sha256}.json`,'archive filename mismatch');archiveByHash.set(value.memory_sha256,value);archives+=1;}}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+  try{for(const name of await jsonFiles(path.join(memoryRoot,'archive-indexes'))){const value=await readJson(path.join(memoryRoot,'archive-indexes',name));const archive=archiveByHash.get(value.source_memory_sha256);insist(archive,'archive index source missing');
+    const proof=verifyRetrievalIndex(value,{corpus:archive,sourceReleaseManifest});insist(proof.ok,`archive index invalid ${name}: ${proof.reason}`);insist(canonicalJson(buildRetrievalIndex(archive,{sourceReleaseManifest}))===canonicalJson(value),'archive index rebuild mismatch');archiveIndexes+=1;}}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+  return {schema:'deadbyte.r41-memory-verification.v1',status:'passed',source_release_manifest:sourceReleaseManifest,
+    goal_count:goalIds.length,snapshot_count:snapshots,index_count:indexes,archive_count:archives,archive_index_count:archiveIndexes,
+    verification_sha256:sha(Buffer.from(canonicalJson({goalIds,snapshots,indexes,archives,archiveIndexes,sourceReleaseManifest}),'utf8'))};
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  const args=parseArgs(process.argv.slice(2));verifyR41Memory({memoryRoot:path.resolve(args['memory-root']),journalRoot:path.resolve(args['journal-root']),
+    sourceReleaseManifest:args.manifest,publicKeyPath:path.resolve(args['public-key'])}).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/verify-r41-parent.mjs

@@ -0,0 +1,61 @@
+import { createHash } from 'node:crypto';
+import { lstat,readFile,readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+
+function parseManifest(bytes){
+  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,`parent manifest line ${index+1} malformed`);
+    const rel=match[2];insist(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!entries.has(rel),`unsafe/duplicate parent manifest path ${rel}`);
+    entries.set(rel,match[1]);
+  }
+  return entries;
+}
+async function walk(dir,rel=''){
+  const out=[];
+  for(const name of (await readdir(path.join(dir,...(rel?rel.split('/'):[])))).sort((a,b)=>a.localeCompare(b,'en'))){
+    const child=rel?`${rel}/${name}`:name;const full=path.join(dir,...child.split('/'));const st=await lstat(full);
+    insist(!st.isSymbolicLink(),`parent tree symlink forbidden: ${child}`);
+    if(st.isDirectory())out.push(...await walk(dir,child));else{insist(st.isFile(),`parent tree non-file forbidden: ${child}`);out.push(child);}
+  }
+  return out;
+}
+async function verifyTree(dir,expectedManifest,{exact}){
+  const bytes=await readFile(path.join(dir,'MANIFEST.SHA256'));insist(sha(bytes)===expectedManifest,`parent manifest digest mismatch: ${dir}`);
+  const entries=parseManifest(bytes);
+  if(exact){
+    const actual=(await walk(dir)).filter(rel=>rel!=='MANIFEST.SHA256');
+    insist(actual.length===entries.size&&actual.every(rel=>entries.has(rel)),`parent exact tree mismatch: ${dir}`);
+  }
+  for(const [rel,digest] of entries)insist(sha(await readFile(path.join(dir,...rel.split('/'))))===digest,`parent file hash mismatch: ${dir} :: ${rel}`);
+  return entries.size;
+}
+
+export async function verifyR41Parent(file=path.join(root,'R41-PARENT.json')){
+  const record=JSON.parse(await readFile(path.resolve(file),'utf8'));
+  insist(record.schema==='deadbyte.r41-parent.v1','R41 parent schema mismatch');
+  insist(record.parent_version==='0.12.0'&&record.parent_release_id==='v0.12.0-70906ae0a7e4f062','R41 parent identity mismatch');
+  const [sourceFiles,releaseFiles]=await Promise.all([
+    verifyTree(path.resolve(record.parent_source_root),record.parent_manifest_sha256,{exact:false}),
+    verifyTree(path.resolve(record.parent_release_root),record.parent_manifest_sha256,{exact:true})
+  ]);
+  insist(sourceFiles===record.parent_manifest_file_count&&releaseFiles===record.parent_manifest_file_count,'R41 parent file count mismatch');
+  const evidenceBytes=await readFile(path.resolve(record.parent_public_evidence_path));
+  insist(sha(evidenceBytes)===record.parent_public_evidence_sha256,'R40 public evidence hash mismatch');
+  const evidence=JSON.parse(evidenceBytes.toString('utf8').replace(/^\uFEFF/,''));
+  insist(evidence.schema==='deadbyte.r40-public-final-verify.v1'&&evidence.status==='passed','R40 public evidence status invalid');
+  insist(evidence.release_id===record.parent_release_id&&evidence.manifest_sha256===record.parent_manifest_sha256,'R40 public evidence identity mismatch');
+  return {status:'passed',parent_release_id:record.parent_release_id,parent_manifest_sha256:record.parent_manifest_sha256,
+    source_files:sourceFiles,release_files:releaseFiles,parent_public_evidence_sha256:record.parent_public_evidence_sha256};
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  verifyR41Parent(process.argv[2]).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-r42-parent.mjs

@@ -0,0 +1,101 @@
+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';
+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 sha1=bytes=>createHash('sha1').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const CLOSURE_DOMAIN=Buffer.from('DEADBYTE-R41-FINAL-CLOSURE-V1\0','utf8');
+
+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];
+    insist(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!entries.has(rel),`unsafe/duplicate ${label} path ${rel}`);
+    entries.set(rel,match[1]);
+  }
+  return entries;
+}
+async function walk(dir,rel=''){
+  const out=[];
+  for(const name of (await readdir(path.join(dir,...(rel?rel.split('/'):[])))).sort((a,b)=>a.localeCompare(b,'en'))){
+    const child=rel?`${rel}/${name}`:name;
+    const full=path.join(dir,...child.split('/'));
+    const st=await lstat(full);
+    insist(!st.isSymbolicLink(),`parent tree symlink forbidden: ${child}`);
+    if(st.isDirectory())out.push(...await walk(dir,child));
+    else{insist(st.isFile(),`parent tree non-file forbidden: ${child}`);out.push(child);}
+  }
+  return out;
+}
+async function verifyTree(dir,manifestName,expectedManifest,{exact}){
+  const bytes=await readFile(path.join(dir,manifestName));
+  insist(sha256(bytes)===expectedManifest,`${manifestName} digest mismatch: ${dir}`);
+  const entries=parseManifest(bytes,manifestName);
+  if(exact){
+    const actual=(await walk(dir)).filter(rel=>rel!==manifestName);
+    insist(actual.length===entries.size&&actual.every(rel=>entries.has(rel)),`${manifestName} exact tree mismatch: ${dir}`);
+  }
+  for(const [rel,digest] of entries){
+    insist(sha256(await readFile(path.join(dir,...rel.split('/'))))===digest,`${manifestName} file hash mismatch: ${dir} :: ${rel}`);
+  }
+  return entries.size;
+}
+function verifySignedClosure(envelope,record,publicPem){
+  insist(envelope?.body?.schema==='deadbyte.r41-final-closure.v1','R41 parent closure schema mismatch');
+  insist(envelope.body.version==='0.13.0','R41 parent closure version mismatch');
+  const pointer=envelope.body.active_pointer;
+  insist(pointer?.release_id===record.parent_release_id&&pointer?.manifest_sha256===record.parent_manifest_sha256,'R41 parent closure release identity mismatch');
+  insist(pointer?.generation_manifest_sha256===record.parent_generation_manifest_sha256,'R41 parent closure generation identity mismatch');
+  const bodyBytes=Buffer.from(canonicalJson(envelope.body),'utf8');
+  insist(sha256(bodyBytes)===envelope.body_sha256,'R41 parent closure body hash mismatch');
+  const {closure_sha256,...unsigned}=envelope;
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===closure_sha256,'R41 parent closure envelope hash mismatch');
+  const key=createPublicKey(publicPem);insist(key.asymmetricKeyType==='ed25519','R41 parent closure key must be Ed25519');
+  const der=Buffer.from(key.export({type:'spki',format:'der'}));
+  const keyId=sha256(der);
+  insist(envelope.attestation?.algorithm==='ed25519'&&envelope.attestation?.domain==='DEADBYTE-R41-FINAL-CLOSURE-V1','R41 parent closure attestation contract mismatch');
+  insist(envelope.attestation.key_id===keyId,'R41 parent closure signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([CLOSURE_DOMAIN,bodyBytes]),key,Buffer.from(envelope.attestation.signature_base64,'base64')),'R41 parent closure signature invalid');
+  return pointer;
+}
+
+export async function verifyR42Parent(file=path.join(root,'R42-PARENT.json')){
+  const record=JSON.parse(await readFile(path.resolve(file),'utf8'));
+  insist(record.schema==='deadbyte.r42-parent.v1','R42 parent schema mismatch');
+  insist(record.parent_version==='0.13.0'&&record.parent_release_id==='v0.13.0-3255be10de4daf08','R42 parent identity mismatch');
+  insist(record.parent_manifest_sha256==='3255be10de4daf0837d67d1ab1913b785b8b8215bc7405823c2ff46968c4b98f','R42 parent manifest mismatch');
+  insist(record.parent_generation_manifest_sha256==='143d2d98b675b4ed68cce2bfb1cda76ec22633035b49746e445140fee58b25cd','R42 parent generation mismatch');
+  const [sourceFiles,releaseFiles]=await Promise.all([
+    verifyTree(path.resolve(record.parent_source_root),'MANIFEST.SHA256',record.parent_manifest_sha256,{exact:false}),
+    verifyTree(path.resolve(record.parent_release_root),'MANIFEST.SHA256',record.parent_manifest_sha256,{exact:true})
+  ]);
+  insist(sourceFiles===record.parent_manifest_file_count&&releaseFiles===record.parent_manifest_file_count,'R42 parent file count mismatch');
+
+  const closureBytes=await readFile(path.resolve(record.parent_final_closure_path));
+  insist(sha256(closureBytes)===record.parent_final_closure_sha256,'R41 parent final closure raw hash mismatch');
+  const closure=JSON.parse(closureBytes.toString('utf8').replace(/^\uFEFF/,''));
+  const pointer=verifySignedClosure(closure,record,await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  const generationFiles=await verifyTree(path.resolve(pointer.generation_root),'GENERATION.SHA256',record.parent_generation_manifest_sha256,{exact:true});
+
+  const tarball=await readFile(path.resolve(record.parent_public_tarball_path));
+  insist(sha256(tarball)===record.parent_public_tarball_sha256,'R41 parent public tarball SHA-256 mismatch');
+  insist(sha1(tarball)===record.parent_public_tarball_sha1,'R41 parent public tarball SHA-1 mismatch');
+
+  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,source_files:sourceFiles,release_files:releaseFiles,
+    generation_files:generationFiles,parent_final_closure_sha256:record.parent_final_closure_sha256,
+    parent_public_tarball_sha256:record.parent_public_tarball_sha256,parent_public_tarball_sha1:record.parent_public_tarball_sha1};
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  verifyR42Parent(process.argv[2]).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/windows-gate-evidence-r41.mjs

@@ -0,0 +1,53 @@
+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';
+
+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.13.0 / R41 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.13.0',`Windows gate evidence requires V0.13.0, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r41-windows-gate.v1',status:'passed',exit_code:0,version:'0.13.0',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256
+  };
+  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,`r41-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};
+  }catch(error){
+    if(error?.code!=='EEXIST') throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8'));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing Windows gate evidence invalid');
+    insist(existing.version==='0.13.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256};
+  }
+}
+
+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;});
+}
+