deadbyte-mcp 0.10.0 → 0.11.0

package/scripts/release-parity-r36.mjs

@@ -0,0 +1,200 @@
+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 { probeR36FullSurface } from '../src/r36-full-surface-probe.mjs';
+import { runR36CompactParity } from '../src/remote-mcp-r36-parity-client.mjs';
+import { probeR36CompactDisarmed } from '../src/r36-compact-disarmed-probe.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.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 R35_PREDECESSOR_RELEASE_ID='v0.9.0-b95e1ec1d9a7e26a';
+export const R35_PREDECESSOR_MANIFEST='b95e1ec1d9a7e26a96ef492306c1be4df18c883ff03ab3b6015f677d7429ec8d';
+
+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 ['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 publicR35Disarmed(url){
+  const script=path.join(root,'src','remote-mcp-r24-disarmed-smoke-client.mjs');
+  const result=parseJsonOutput((await run(process.execPath,[script,url],{timeoutMs:90000})).stdout,'R35 predecessor disarmed gate');
+  assert(result.status==='passed'&&result.tool_count===73,'R35 predecessor public catalog mismatch');
+  assert(result.coding_armed===false&&result.autonomous_armed===false,'R35 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,'R36 generation missing coding core root');
+  const core=path.resolve(raw);const release=path.resolve(pointerValue.release_root);
+  assert(core.toLowerCase()!==release.toLowerCase(),'R36 coding core must not point at immutable active release slot');
+  return core;
+}
+
+export function validateParityEvidence(value){
+  assert(value?.schema==='deadbyte.r36-parity.v1','R36 parity schema mismatch');
+  assert(value.status==='passed','R36 parity status is not passed');
+  assert(value.rdc_operation_count===0&&value.execution_provider==='deadbyte_mcp','R36 parity used non-DEADBYTE execution');
+  assert(value.candidate?.version==='0.10.0'&&/^[0-9a-f]{64}$/.test(value.candidate?.manifest_sha256??''),'R36 candidate identity missing');
+  assert(value.local_full?.status==='passed'&&value.local_full?.tool_count===76&&value.local_full?.strict_output_schemas===true,'R36 local full 76-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===5,'R36 public compact closure missing');
+  assert(value.autonomous?.status==='passed'&&value.autonomous?.signed_release_verified===true,'R36 autonomous live 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,'R36 pre-rollback disarm proof missing');
+  assert(value.rollback?.state==='completed'&&value.restore?.state==='completed','R36 rollback/restore not completed');
+  assert(value.stage_restore?.status==='restored'&&value.stage_restore?.manifest_sha256===value.candidate.manifest_sha256,'R36 stage restore proof missing');
+  assert(value.predecessor?.release_id===R35_PREDECESSOR_RELEASE_ID&&value.predecessor?.manifest_sha256===R35_PREDECESSOR_MANIFEST&&value.predecessor?.version==='0.9.0','R35 exact predecessor identity mismatch');
+  assert(value.predecessor_disarmed?.status==='passed'&&value.predecessor_disarmed?.tool_count===73,'R35 predecessor public proof missing');
+  assert(value.successor?.version==='0.10.0'&&value.successor?.manifest_sha256===value.candidate.manifest_sha256,'R36 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,'R36 successor disarmed proof missing');
+  assert(value.immutable_slot?.protected===true&&value.immutable_slot?.development_root!==value.immutable_slot?.release_root,'R36 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']) assert(value.requirements?.[key]===true,`R36 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.10.0','R36 parity requires active 0.10.0 candidate');
+  assert(active.manifest_sha256===candidateManifest,'active release is not canonical R36 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),'R36 active bridge root missing');
+  assert(typeof successorBridgeConfiguredSha==='string'&&/^[0-9a-f]{64}$/.test(successorBridgeConfiguredSha),'R36 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,'R36 active bridge bytes do not match generation pin');
+  const successorBridge={root:successorBridgeRoot,sha256:successorBridgeActualSha};
+  const developmentRoot=await mutableCore(active);
+  const localFull=await probeR36FullSurface({packageRoot:active.release_root,generationRoot:active.generation_root,stateRoot});
+  const url=await publicUrl();
+  let publicCompact,autonomous;
+  try{
+    publicCompact=await runR36CompactParity(url);
+    autonomous=parseJsonOutput((await run(process.execPath,[path.join(root,'src','remote-mcp-autonomous-smoke-client.mjs'),url],{timeoutMs:900000})).stdout,'R36 autonomous compact parity');
+    assert(autonomous.status==='passed'&&autonomous.signed_release_verified===true,'R36 autonomous compact parity failed');
+  }catch(error){await disarmAll().catch(()=>{});throw error;}
+
+  await disarmAll();
+  const beforeRollback=await probeR36CompactDisarmed(url);
+  const rollbackPair=await scheduleDeferred('rollback',path.resolve(activationReceiptPath));
+  const predecessor=await pointer();
+  assert(predecessor.release_id===R35_PREDECESSOR_RELEASE_ID&&predecessor.manifest_sha256===R35_PREDECESSOR_MANIFEST&&predecessor.version==='0.9.0','rollback did not reach exact sealed R35 predecessor');
+  const predecessorDisarmed=await publicR35Disarmed(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.10.0'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R36 candidate');
+  const successorDisarmed=await probeR36CompactDisarmed(url);
+  await disarmAll();
+
+  const evidence={
+    schema:'deadbyte.r36-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,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===76&&localFull.strict_output_schemas===true
+    }
+  };
+  validateParityEvidence(evidence);
+  const evidenceDir=path.join(stateRoot,'evidence','release');await mkdir(evidenceDir,{recursive:true});
+  const evidencePath=path.join(evidenceDir,`r36-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.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.ps1

@@ -3,7 +3,7 @@ Set-StrictMode -Version 2.0
 $root = Split-Path -Parent $PSScriptRoot
 Push-Location $root
 try {
-    & node.exe --test test\r36-finalization.test.mjs test\r36-release-identity.test.mjs test\deferred-slot-operation.test.mjs
+    & node.exe --test test\r37-finalization.test.mjs test\release-version.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 "release parity tests failed with exit code $LASTEXITCODE" }
-    Write-Output 'R36 RELEASE PARITY TEST PASS'
+    Write-Output 'R37 RELEASE PARITY TEST PASS'
 } finally { Pop-Location }

package/scripts/release-parity.mjs

@@ -18,8 +18,8 @@ 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 R35_PREDECESSOR_RELEASE_ID='v0.9.0-b95e1ec1d9a7e26a';
-export const R35_PREDECESSOR_MANIFEST='b95e1ec1d9a7e26a96ef492306c1be4df18c883ff03ab3b6015f677d7429ec8d';
+export const R36_PREDECESSOR_RELEASE_ID='v0.10.0-8d1e5f09745e7647';
+export const R36_PREDECESSOR_MANIFEST='8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8';
 
 function assert(condition,message){if(!condition) throw new Error(message);}
 function parseFrozenManifest(text){
@@ -91,54 +91,54 @@ async function scheduleDeferred(mode,value,{bridgeRoot=null,bridgeScriptSha256=n
   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 publicR35Disarmed(url){
-  const script=path.join(root,'src','remote-mcp-r24-disarmed-smoke-client.mjs');
-  const result=parseJsonOutput((await run(process.execPath,[script,url],{timeoutMs:90000})).stdout,'R35 predecessor disarmed gate');
-  assert(result.status==='passed'&&result.tool_count===73,'R35 predecessor public catalog mismatch');
-  assert(result.coding_armed===false&&result.autonomous_armed===false,'R35 predecessor authority remained armed');
+async function publicR36Disarmed(url){
+  const result=await probeR36CompactDisarmed(url);
+  assert(result.status==='passed'&&result.tool_count<=42&&result.capability_closure===true,'R36 predecessor public compact catalog mismatch');
+  assert(result.release_id===R36_PREDECESSOR_RELEASE_ID&&result.release_manifest_sha256===R36_PREDECESSOR_MANIFEST,'R36 predecessor machine binding mismatch');
+  assert(result.coding_armed===false&&result.autonomous_armed===false,'R36 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,'R36 generation missing coding core root');
+  assert(typeof raw==='string'&&raw,'R37 generation missing coding core root');
   const core=path.resolve(raw);const release=path.resolve(pointerValue.release_root);
-  assert(core.toLowerCase()!==release.toLowerCase(),'R36 coding core must not point at immutable active release slot');
+  assert(core.toLowerCase()!==release.toLowerCase(),'R37 coding core must not point at immutable active release slot');
   return core;
 }
 
 export function validateParityEvidence(value){
-  assert(value?.schema==='deadbyte.r36-parity.v1','R36 parity schema mismatch');
-  assert(value.status==='passed','R36 parity status is not passed');
-  assert(value.rdc_operation_count===0&&value.execution_provider==='deadbyte_mcp','R36 parity used non-DEADBYTE execution');
-  assert(value.candidate?.version==='0.10.0'&&/^[0-9a-f]{64}$/.test(value.candidate?.manifest_sha256??''),'R36 candidate identity missing');
-  assert(value.local_full?.status==='passed'&&value.local_full?.tool_count===76&&value.local_full?.strict_output_schemas===true,'R36 local full 76-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===5,'R36 public compact closure missing');
-  assert(value.autonomous?.status==='passed'&&value.autonomous?.signed_release_verified===true,'R36 autonomous live 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,'R36 pre-rollback disarm proof missing');
-  assert(value.rollback?.state==='completed'&&value.restore?.state==='completed','R36 rollback/restore not completed');
-  assert(value.stage_restore?.status==='restored'&&value.stage_restore?.manifest_sha256===value.candidate.manifest_sha256,'R36 stage restore proof missing');
-  assert(value.predecessor?.release_id===R35_PREDECESSOR_RELEASE_ID&&value.predecessor?.manifest_sha256===R35_PREDECESSOR_MANIFEST&&value.predecessor?.version==='0.9.0','R35 exact predecessor identity mismatch');
-  assert(value.predecessor_disarmed?.status==='passed'&&value.predecessor_disarmed?.tool_count===73,'R35 predecessor public proof missing');
-  assert(value.successor?.version==='0.10.0'&&value.successor?.manifest_sha256===value.candidate.manifest_sha256,'R36 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,'R36 successor disarmed proof missing');
-  assert(value.immutable_slot?.protected===true&&value.immutable_slot?.development_root!==value.immutable_slot?.release_root,'R36 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']) assert(value.requirements?.[key]===true,`R36 parity requirement not proven: ${key}`);
+  assert(value?.schema==='deadbyte.r37-parity.v1','R37 parity schema mismatch');
+  assert(value.status==='passed','R37 parity status is not passed');
+  assert(value.rdc_operation_count===0&&value.execution_provider==='deadbyte_mcp','R37 parity used non-DEADBYTE execution');
+  assert(value.candidate?.version==='0.11.0'&&/^[0-9a-f]{64}$/.test(value.candidate?.manifest_sha256??''),'R37 candidate identity missing');
+  assert(value.local_full?.status==='passed'&&value.local_full?.tool_count===76&&value.local_full?.strict_output_schemas===true,'R37 local full 76-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===5,'R37 public compact closure missing');
+  assert(value.autonomous?.status==='passed'&&value.autonomous?.signed_release_verified===true,'R37 autonomous live 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,'R37 pre-rollback disarm proof missing');
+  assert(value.rollback?.state==='completed'&&value.restore?.state==='completed','R37 rollback/restore not completed');
+  assert(value.stage_restore?.status==='restored'&&value.stage_restore?.manifest_sha256===value.candidate.manifest_sha256,'R37 stage restore proof missing');
+  assert(value.predecessor?.release_id===R36_PREDECESSOR_RELEASE_ID&&value.predecessor?.manifest_sha256===R36_PREDECESSOR_MANIFEST&&value.predecessor?.version==='0.10.0','R36 exact predecessor identity mismatch');
+  assert(value.predecessor_disarmed?.status==='passed'&&value.predecessor_disarmed?.tool_count<=42&&value.predecessor_disarmed?.capability_closure===true,'R36 predecessor public proof missing');
+  assert(value.successor?.version==='0.11.0'&&value.successor?.manifest_sha256===value.candidate.manifest_sha256,'R37 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,'R37 successor disarmed proof missing');
+  assert(value.immutable_slot?.protected===true&&value.immutable_slot?.development_root!==value.immutable_slot?.release_root,'R37 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']) assert(value.requirements?.[key]===true,`R37 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.10.0','R36 parity requires active 0.10.0 candidate');
-  assert(active.manifest_sha256===candidateManifest,'active release is not canonical R36 candidate');
+  assert(active.version==='0.11.0','R37 parity requires active 0.11.0 candidate');
+  assert(active.manifest_sha256===candidateManifest,'active release is not canonical R37 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),'R36 active bridge root missing');
-  assert(typeof successorBridgeConfiguredSha==='string'&&/^[0-9a-f]{64}$/.test(successorBridgeConfiguredSha),'R36 active bridge SHA missing');
+  assert(typeof successorBridgeRootRaw==='string'&&path.isAbsolute(successorBridgeRootRaw),'R37 active bridge root missing');
+  assert(typeof successorBridgeConfiguredSha==='string'&&/^[0-9a-f]{64}$/.test(successorBridgeConfiguredSha),'R37 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,'R36 active bridge bytes do not match generation pin');
+  assert(successorBridgeActualSha===successorBridgeConfiguredSha,'R37 active bridge bytes do not match generation pin');
   const successorBridge={root:successorBridgeRoot,sha256:successorBridgeActualSha};
   const developmentRoot=await mutableCore(active);
   const localFull=await probeR36FullSurface({packageRoot:active.release_root,generationRoot:active.generation_root,stateRoot});
@@ -146,25 +146,25 @@ export async function runReleaseParity(activationReceiptPath){
   let publicCompact,autonomous;
   try{
     publicCompact=await runR36CompactParity(url);
-    autonomous=parseJsonOutput((await run(process.execPath,[path.join(root,'src','remote-mcp-autonomous-smoke-client.mjs'),url],{timeoutMs:900000})).stdout,'R36 autonomous compact parity');
-    assert(autonomous.status==='passed'&&autonomous.signed_release_verified===true,'R36 autonomous compact parity failed');
+    autonomous=parseJsonOutput((await run(process.execPath,[path.join(root,'src','remote-mcp-autonomous-smoke-client.mjs'),url],{timeoutMs:900000})).stdout,'R37 autonomous compact parity');
+    assert(autonomous.status==='passed'&&autonomous.signed_release_verified===true,'R37 autonomous compact parity failed');
   }catch(error){await disarmAll().catch(()=>{});throw error;}
 
   await disarmAll();
   const beforeRollback=await probeR36CompactDisarmed(url);
   const rollbackPair=await scheduleDeferred('rollback',path.resolve(activationReceiptPath));
   const predecessor=await pointer();
-  assert(predecessor.release_id===R35_PREDECESSOR_RELEASE_ID&&predecessor.manifest_sha256===R35_PREDECESSOR_MANIFEST&&predecessor.version==='0.9.0','rollback did not reach exact sealed R35 predecessor');
-  const predecessorDisarmed=await publicR35Disarmed(url);
+  assert(predecessor.release_id===R36_PREDECESSOR_RELEASE_ID&&predecessor.manifest_sha256===R36_PREDECESSOR_MANIFEST&&predecessor.version==='0.10.0','rollback did not reach exact sealed R36 predecessor');
+  const predecessorDisarmed=await publicR36Disarmed(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.10.0'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R36 candidate');
+  assert(successor.version==='0.11.0'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R37 candidate');
   const successorDisarmed=await probeR36CompactDisarmed(url);
   await disarmAll();
 
   const evidence={
-    schema:'deadbyte.r36-parity.v1',status:'passed',completed_at_utc:new Date().toISOString(),execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    schema:'deadbyte.r37-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,before_rollback_disarmed:beforeRollback,
@@ -189,7 +189,7 @@ export async function runReleaseParity(activationReceiptPath){
   };
   validateParityEvidence(evidence);
   const evidenceDir=path.join(stateRoot,'evidence','release');await mkdir(evidenceDir,{recursive:true});
-  const evidencePath=path.join(evidenceDir,`r36-parity-${candidateManifest.slice(0,16)}.json`);
+  const evidencePath=path.join(evidenceDir,`r37-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)};
 }

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

@@ -0,0 +1,52 @@
+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.10.0 / R36 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.10.0',`Windows gate evidence requires V0.10.0, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r36-windows-gate.v1',status:'passed',exit_code:0,version:'0.10.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,`r36-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.10.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;});
+}

package/scripts/windows-gate-evidence.mjs

@@ -7,7 +7,7 @@ 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.10.0 / R36 WINDOWS BATCH GATE: PASS';
+const marker='DEADBYTE V0.11.0 / R37 WINDOWS BATCH GATE: PASS';
 function insist(ok,message){if(!ok) throw new Error(message);}
 
 export async function writeWindowsGateEvidence({
@@ -19,17 +19,17 @@ export async function writeWindowsGateEvidence({
   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.10.0',`Windows gate evidence requires V0.10.0, found ${pkg.version}`);
+  insist(pkg.version==='0.11.0',`Windows gate evidence requires V0.11.0, found ${pkg.version}`);
   const completed=clock();
   insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
   const evidence={
-    schema:'deadbyte.r36-windows-gate.v1',status:'passed',exit_code:0,version:'0.10.0',
+    schema:'deadbyte.r37-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.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,`r36-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  const file=path.join(dir,`r37-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();}
@@ -39,7 +39,7 @@ export async function writeWindowsGateEvidence({
     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.10.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    insist(existing.version==='0.11.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};
   }
 }

package/src/agent-memory-plane.mjs

@@ -0,0 +1,98 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const AGENT_MEMORY_SCHEMA='deadbyte.agent-memory.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+const uniq=values=>[...new Set(values.filter(v=>typeof v==='string'&&v.length>0))];
+
+function tokens(text){return uniq(String(text??'').toLowerCase().split(/[^a-z0-9_.\/-]+/).filter(x=>x.length>1));}
+function compactEvent(event){
+  const p=event?.payload&&typeof event.payload==='object'?event.payload:{};
+  const safe={seq:event?.seq??null,type:event?.type??'unknown',event_sha256:HEX64.test(event?.event_sha256??'')?event.event_sha256:null};
+  for(const key of ['reason','profile_id','mutation_epoch','receipt_sha256','diff_receipt_sha256','action_key']){
+    if(p[key]!==undefined) safe[key]=p[key];
+  }
+  if(Array.isArray(p.paths)) safe.paths=p.paths.filter(x=>typeof x==='string').slice(0,32);
+  return safe;
+}
+
+export function deriveAgentMemory(events,{maxArchival=96}={}){
+  if(!Array.isArray(events)) throw new Error('memory events must be array');
+  const acceptance=[],proven=[],rejected=[],blockers=new Set(),files=new Map(),profiles=new Map();
+  const archival=[];
+  for(const event of events){
+    const p=event?.payload&&typeof event.payload==='object'?event.payload:{};
+    if(event?.type==='goal_created'&&typeof p.acceptance==='string'&&p.acceptance) acceptance.push(p.acceptance);
+    if(event?.type==='profile_completed'&&typeof p.profile_id==='string'){
+      profiles.set(p.profile_id,{id:`profile:${p.profile_id}`,kind:'profile',label:p.profile_id,passed:p.passed===true,
+        receipt_sha256:HEX64.test(p.receipt_sha256??'')?p.receipt_sha256:null});
+      if(p.passed===true){proven.push(`${p.profile_id}:passed`);blockers.delete(`profile:${p.profile_id}`);}
+      else blockers.add(`profile:${p.profile_id}`);
+    }
+    if(event?.type==='native_diff_committed'){
+      for(const file of p.paths??[]) if(typeof file==='string'&&file) files.set(file,{id:`file:${file}`,kind:'file',label:file});
+    }
+    if(event?.type==='planner_rejected'&&typeof p.reason==='string') rejected.push(p.reason);
+    if(event?.type==='waiting_entered'&&typeof p.reason==='string') blockers.add(`wait:${p.reason}`);
+    if(event?.type==='waiting_resumed'&&typeof p.previous_reason==='string') blockers.delete(`wait:${p.previous_reason}`);
+    if(['planner_rejected','profile_completed','native_diff_committed','waiting_entered','waiting_resumed','release_completed'].includes(event?.type)){
+      archival.push(compactEvent(event));
+    }
+  }
+  const core={acceptance_constraints:uniq(acceptance),proven_invariants:uniq(proven),
+    rejected_approaches:uniq(rejected),unresolved_blockers:[...blockers].sort()};
+  const nodes=[
+    {id:'goal:current',kind:'goal',label:core.acceptance_constraints.join(' | ')||'current goal'},
+    ...[...files.values()].sort((a,b)=>a.id.localeCompare(b.id,'en')),
+    ...[...profiles.values()].sort((a,b)=>a.id.localeCompare(b.id,'en')),
+    ...core.unresolved_blockers.map(id=>({id:`blocker:${id}`,kind:'blocker',label:id}))
+  ];
+  const edges=[];
+  for(const node of nodes){
+    if(node.id==='goal:current') continue;
+    edges.push({source:'goal:current',target:node.id,kind:node.kind==='file'?'touches':node.kind==='profile'?'verified_by':'blocked_by'});
+  }
+  const body={schema:AGENT_MEMORY_SCHEMA,core,archival:archival.slice(-maxArchival),graph:{nodes,edges}};
+  return Object.freeze({...body,memory_sha256:sha(body)});
+}
+
+function score(value,needles){
+  const text=JSON.stringify(value).toLowerCase();
+  return needles.reduce((n,t)=>n+(text.includes(t)?1:0),0);
+}
+function ranked(values,needles,limit){
+  return values.map(value=>({value,score:score(value,needles)})).filter(x=>x.score>0)
+    .sort((a,b)=>b.score-a.score||JSON.stringify(a.value).localeCompare(JSON.stringify(b.value),'en'))
+    .slice(0,limit).map(x=>x.value);
+}
+export function queryAgentMemory(memory,{query,mode='local',limit=12}={}){
+  if(!memory||memory.schema!==AGENT_MEMORY_SCHEMA) throw new Error('memory snapshot invalid');
+  if(!['local','global','drift'].includes(mode)) throw new Error('memory query mode invalid');
+  if(!Number.isInteger(limit)||limit<1||limit>128) throw new Error('memory query limit invalid');
+  const needles=tokens(query);
+  let results=[];
+  if(mode==='global'){
+    results=[
+      {kind:'core',...memory.core},
+      {kind:'graph_summary',node_count:memory.graph.nodes.length,edge_count:memory.graph.edges.length,
+        node_kinds:Object.fromEntries([...new Set(memory.graph.nodes.map(n=>n.kind))].sort().map(k=>[k,memory.graph.nodes.filter(n=>n.kind===k).length]))}
+    ];
+    if(needles.length) results=ranked([...results,...memory.archival],needles,limit);
+    else results=results.slice(0,limit);
+  }else{
+    const local=ranked([...memory.graph.nodes,...memory.archival],needles,limit);
+    results=[...local];
+    if(mode==='drift'){
+      const ids=new Set(local.filter(x=>x?.id).map(x=>x.id));
+      const neighborIds=new Set();
+      for(const edge of memory.graph.edges){
+        if(ids.has(edge.source)) neighborIds.add(edge.target);
+        if(ids.has(edge.target)) neighborIds.add(edge.source);
+      }
+      for(const node of memory.graph.nodes) if(neighborIds.has(node.id)&&!results.some(x=>x?.id===node.id)) results.push(node);
+      results=results.slice(0,limit);
+    }
+  }
+  return Object.freeze({schema:'deadbyte.agent-memory-query.v1',mode,query:String(query??''),memory_sha256:memory.memory_sha256,results});
+}

package/src/autonomous-output-contracts.mjs

@@ -98,9 +98,12 @@ export const autonomousGoalRunOutputSchema = z.strictObject({
   if (value.status === 'input_required') requireFields(value,ctx,['planner_request']);
 });
 export const autonomousGoalStatusOutputSchema = statusContract({
-  statuses:['ok','failed'], success:['ok'], required:['goal_id','goal_sha256','title','root_id','journal_verified',...Object.keys(derivedShape)],
+  statuses:['ok','failed'], success:['ok'], required:['goal_id','goal_sha256','title','root_id','journal_verified',
+    'run_busy','run_owner_pid','run_lock_created_at_utc',...Object.keys(derivedShape)],
   shape:{ goal_id:goalId.optional(), goal_sha256:hex64.optional(), title:z.string().optional(), root_id:z.string().optional(),
-    journal_verified:z.literal(true).optional(), loop:publicLoopSchema.optional(), ...runShape }
+    journal_verified:z.literal(true).optional(), run_busy:z.boolean().optional(),
+    run_owner_pid:z.number().int().min(1).nullable().optional(),
+    run_lock_created_at_utc:z.string().nullable().optional(), loop:publicLoopSchema.optional(), ...runShape }
 });
 export const autonomousGoalEventsOutputSchema = statusContract({
   statuses:['ok','failed'], success:['ok'], required:['goal_id','journal_verified','journal_head_sha256','events'],