deadbyte-mcp 0.9.0 → 0.10.0

package/scripts/release-parity.mjs

@@ -1,21 +1,28 @@
 import { createHash } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+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');
+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');
 
-function assert(condition, message) { if (!condition) throw new Error(message); }
-function parseFrozenManifest(text) {
+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;
@@ -27,164 +34,167 @@ function parseFrozenManifest(text) {
   }
   return entries;
 }
-export async function restoreFrozenStage({developmentRoot,releaseRoot,expectedManifestSha256}) {
+// 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);
+    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}`);
+    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 {}
-  }
+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 } = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd:root, 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 });
+}
+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 text = (await readFile(path.join(stateRoot, 'bridge', 'mcp-url.txt'), 'utf8')).trim();
-  const url = new URL(text);
-  if (url.protocol !== 'https:') throw new Error('public MCP URL must be HTTPS');
-  return text;
+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 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);
+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) {
-  const scheduled = parseJsonOutput((await run(process.execPath, [deferred, mode, value], { 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 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 publicDisarmed(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, 'public disarmed gate');
-  assert(result.status === 'passed' && result.tool_count === 73, 'public disarmed gate failed exact catalog');
-  assert(result.coding_armed === false && result.autonomous_armed === false, 'public authority remained armed');
+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;
-}export function validateParityEvidence(value) {
-  assert(value?.schema === 'deadbyte.r35-parity.v1', 'parity schema mismatch');
-  assert(value.status === 'passed', 'parity status is not passed');
-  assert(value.rdc_operation_count === 0 && value.execution_provider === 'deadbyte_mcp', 'parity used non-DEADBYTE execution');
-  assert(value.public_full?.status === 'passed' && value.public_full?.tools?.length === 73, 'public full gate missing exact 73');
-  assert(value.machine_control?.status === 'passed' && value.machine_control?.tool_count === 73, 'machine control parity missing');
-  assert(value.autonomous?.status === 'passed' && value.autonomous?.tool_count === 73, 'autonomous parity missing');
-  assert(value.rollback?.state === 'completed' && value.restore?.state === 'completed', 'rollback/restore not completed');
-  assert(value.predecessor_disarmed?.tool_count === 73 && value.successor_disarmed?.tool_count === 73, 'disarmed public gate missing');
-  for (const key of ['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification']) {
-    assert(value.requirements?.[key] === true, `parity requirement not proven: ${key}`);
-  }
+}
+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 pointer = JSON.parse(await readFile(path.join(stateRoot, 'active-release.json'), 'utf8'));
-  const candidateManifest = sha256(await readFile(path.join(root, 'MANIFEST.SHA256')));
-  assert(pointer.manifest_sha256 === candidateManifest, 'active release is not the canonical candidate');
-  const url = await publicUrl();
-  const publicFullScript = path.join(root, 'src', 'remote-mcp-smoke-client.mjs');
-  const machineScript = path.join(root, 'src', 'remote-mcp-r34-parity-client.mjs');
-  const autonomousScript = path.join(root, 'src', 'remote-mcp-autonomous-smoke-client.mjs');  let publicFull,machineControl,autonomous,publicGatesPassed=false;
-  try {
-    publicFull = parseJsonOutput((await run(process.execPath, [publicFullScript, url, 'full'], { timeoutMs:180000 })).stdout, 'public full gate');
-    machineControl = parseJsonOutput((await run(process.execPath, [machineScript, url], { timeoutMs:600000 })).stdout, 'R34 machine parity');
-    autonomous = parseJsonOutput((await run(process.execPath, [autonomousScript, url], { timeoutMs:900000 })).stdout, 'R34 autonomous parity');
-    assert(publicFull.status === 'passed' && publicFull.tools?.length === 73, 'public full gate did not expose exact 73');
-    assert(machineControl.status === 'passed' && machineControl.tool_count === 73, 'machine-control parity failed');
-    assert(autonomous.status === 'passed' && autonomous.tool_count === 73, 'autonomous parity failed');
-    publicGatesPassed=true;
-  } finally {
-    let restoreError=null;
-    try {
-      await restoreFrozenStage({developmentRoot:root,releaseRoot:pointer.release_root,expectedManifestSha256:candidateManifest});
-    } catch(error) { restoreError=error; }
-    if(!publicGatesPassed||restoreError) await disarmAll().catch(()=>{});
-    if(restoreError) throw restoreError;
-  }
+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 publicDisarmed(url);
-  const rollbackPair = await scheduleDeferred('rollback', path.resolve(activationReceiptPath));
-  const predecessorDisarmed = await publicDisarmed(url);
-  const restorePair = await scheduleDeferred('activate', candidateManifest);
-  const successorDisarmed = await publicDisarmed(url);
-  const finalPointer = JSON.parse(await readFile(path.join(stateRoot, 'active-release.json'), 'utf8'));
-  assert(finalPointer.manifest_sha256 === candidateManifest, 'restore did not return canonical candidate');
+  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.r35-parity.v1', status:'passed', completed_at_utc:new Date().toISOString(),
-    release_id:finalPointer.release_id, manifest_sha256:candidateManifest,
-    execution_provider:'deadbyte_mcp', rdc_operation_count:0,
-    public_full:publicFull, machine_control:machineControl, autonomous,
-    before_rollback_disarmed:beforeRollback,
-    rollback:{...rollbackPair.completed, scheduled_operation_id:rollbackPair.scheduled.operation_id},
-    predecessor_disarmed:predecessorDisarmed,
-    restore:{...restorePair.completed, scheduled_operation_id:restorePair.scheduled.operation_id},
-    successor_disarmed:successorDisarmed,    requirements:{
-      tree_read:machineControl.bounded_read_verified === true && machineControl.tree_entries >= 0,
-      precondition_mutation:machineControl.stale_precondition_denied === true && machineControl.machine_fs_receipts_verified >= 3,
-      search:machineControl.search_result_count >= 1,
-      owned_process:typeof machineControl.process_session_id === 'string' && machineControl.process_output_bytes > 0,
-      observation:machineControl.observation_receipts_verified >= 3,
-      coding_loop:machineControl.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:machineControl.machine_fs_receipts_verified >= 3 && autonomous.signed_release_verified === true
+  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, `r35-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) };
+  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; });
-}
+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/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.9.0 / R35 WINDOWS BATCH GATE: PASS';
+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({
@@ -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.9.0',`Windows gate evidence requires V0.9.0, found ${pkg.version}`);
+  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.r35-windows-gate.v1',status:'passed',exit_code:0,version:'0.9.0',
+    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,`r35-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  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();}
@@ -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.9.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    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};
   }
 }

package/src/autonomous-context-engine.mjs

@@ -213,7 +213,7 @@ function historicalEvidence({ contexts, observations, loopState }) {
   };
 }
 
-export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null }) {
+export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null, capabilities = null }) {
   if (!policy?.limits || !Number.isInteger(policy.limits.max_context_bytes)) throw new Error('loop context policy byte limit missing');
   const relevanceEpoch=Number.isInteger(loopState?.mutation_epoch)&&loopState.mutation_epoch>=0?loopState.mutation_epoch:0;
   const retainedContexts=normalizeEvidence(contexts,{kind:'context',relevanceEpoch});
@@ -249,6 +249,7 @@ export function buildLoopContext({ goal, policy, loopState = {}, tree = [], cont
     },
     historical_evidence:historicalEvidence({contexts:retainedContexts,observations:retainedObservations,loopState}),
     project_memory:memory,
+    capabilities:capabilities===null?null:structuredClone(capabilities),
     profiles
   };
   return compactLoopContext(state,policy.limits.max_context_bytes);

package/src/autonomous-mcp-tools.mjs

@@ -18,7 +18,11 @@ const replaceOperation = z.strictObject({ kind:z.literal('replace'), path:relPat
   expected_sha256:hex64, old_string:z.string().min(1).max(262144), new_string:z.string().max(524288),
   expected_replacements:z.number().int().min(1).max(64).default(1) });
 const deleteOperation = z.strictObject({ kind:z.literal('delete'), path:relPath, expected_sha256:hex64 });
-const nativeOperation = z.union([writeOperation,replaceOperation,deleteOperation]);
+const mkdirOperation = z.strictObject({ kind:z.literal('mkdir'), path:relPath });
+const moveOperation = z.strictObject({ kind:z.literal('move'), source_path:relPath, destination_path:relPath,
+  expected_source_identity:hex64, expected_destination_identity:z.union([z.literal('absent'),hex64]).default('absent') });
+const rmdirOperation = z.strictObject({ kind:z.literal('rmdir'), path:relPath, expected_source_identity:hex64 });
+const nativeOperation = z.union([writeOperation,replaceOperation,deleteOperation,mkdirOperation,moveOperation,rmdirOperation]);
 const plannerResponse = z.strictObject({ request_id:hex64, raw_text:z.string().min(2).max(8*1024*1024),
   model:z.string().min(1).max(128).default('client-model') });
 function result(schema,value,isError=false) { return autonomousStructuredResult(schema,value,isError); }

package/src/autonomous-output-contracts.mjs

@@ -58,21 +58,21 @@ export const autonomousSessionStatusOutputSchema = statusContract({
 
 export const nativeDiffPreviewOutputSchema = statusContract({
   statuses:['ready','failed'], success:['ready'], required:['diff_id','root_id','operation_count','payload_bytes','paths','operations'],
-  shape:{ diff_id:hex64.optional(), root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
-    payload_bytes:z.number().int().min(0).optional(), paths:z.array(z.string()).max(32).optional(),
+  shape:{ schema:z.enum(['deadbyte.native-diff.v1','deadbyte.native-diff.v2']).optional(), diff_id:hex64.optional(), root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
+    payload_bytes:z.number().int().min(0).optional(), paths:z.array(z.string()).max(64).optional(),
     operations:z.array(jsonObject).max(32).optional() }
 });
 export const nativeDiffApplyOutputSchema = statusContract({
   statuses:['committed','existing','failed'], success:['committed','existing'],
   required:['diff_id','receipt_sha256','operation_count'],
   shape:{ diff_id:hex64.optional(), receipt_sha256:hex64.optional(), operation_count:z.number().int().min(1).max(32).optional(),
-    current_state_matches:z.boolean().optional(), coding_receipts:z.array(jsonObject).max(32).optional() }
+    current_state_matches:z.boolean().optional(), coding_receipts:z.array(jsonObject).max(32).optional(), operation_receipts:z.array(jsonObject).max(32).optional() }
 });
 export const nativeDiffVerifyOutputSchema = z.strictObject({
   status:z.literal('failed').optional(), error:z.string().optional(), ok:z.boolean().optional(), reason:z.string().optional(),
   diff_id:hex64.optional(), receipt_sha256:hex64.optional(), signature_valid:z.literal(true).optional(),
   root_id:z.string().min(1).max(64).optional(), operation_count:z.number().int().min(1).max(32).optional(),
-  coding_receipts_verified:z.number().int().min(0).max(32).optional(), final_states:z.array(jsonObject).max(32).optional(),
+  coding_receipts_verified:z.number().int().min(0).max(32).optional(), operation_receipts_verified:z.number().int().min(0).max(32).optional(), final_states:z.array(jsonObject).max(32).optional(),
   current_state_matches:z.boolean().optional(), journal_head_sha256:hex64.optional()
 }).superRefine((value,ctx) => {
   if (value.status === 'failed') { requireFields(value,ctx,['error']); return; }

package/src/autonomous-planner-contracts.mjs

@@ -89,10 +89,45 @@ const r34PatchOperationSchema = z.discriminatedUnion('kind',[
     expected_replacements:z.number().int().min(1).max(64).default(1)}),
   z.strictObject({kind:z.literal('delete'),path:relPath,expected_sha256:z.string().regex(HEX64)})
 ]);
+const plannerCursor=z.string().max(4096).nullable().default(null);
+const plannerFiles=z.array(z.strictObject({path:relPath,encoding:z.enum(['utf8','base64']).default('utf8')})).min(1).max(32);
+const plannerSemanticPosition={path:relPath,line:z.number().int().min(0),column:z.number().int().min(0)};
+const r36TypedActionSchemas=[
+  z.strictObject({kind:z.literal('search'),path:relPath.default('.'),target:z.enum(['content','path']).default('content'),mode:z.enum(['literal','regex']).default('literal'),pattern:z.string().min(1).max(256),case_sensitive:z.boolean().default(false),max_results:z.number().int().min(1).max(1000).default(200),max_file_bytes:z.number().int().min(1).max(4194304).default(262144),max_scan_bytes:z.number().int().min(1).max(67108864).default(4194304),page_size:z.number().int().min(1).max(500).default(100),cursor:plannerCursor}),
+  z.strictObject({kind:z.literal('stat'),path:relPath.default('.'),hash:z.boolean().default(false)}),
+  z.strictObject({kind:z.literal('multi_read'),files:plannerFiles,max_total_bytes:z.number().int().min(1).max(2097152).default(1048576)}),
+  z.strictObject({kind:z.literal('semantic_outline'),path:relPath,max_symbols:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({kind:z.literal('semantic_definition'),...plannerSemanticPosition,max_results:z.number().int().min(1).max(200).default(50)}),
+  z.strictObject({kind:z.literal('semantic_references'),...plannerSemanticPosition,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({kind:z.literal('semantic_diagnostics'),path:relPath,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({kind:z.literal('semantic_implementations'),...plannerSemanticPosition,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({kind:z.literal('semantic_rename_preview'),...plannerSemanticPosition,new_name:z.string().regex(/^[A-Za-z_$][A-Za-z0-9_$]{0,127}$/)}),
+  z.strictObject({kind:z.literal('native_diff_apply'),diff_id:z.string().regex(HEX64),expected_operation_count:z.number().int().min(1).max(32)}),
+  z.strictObject({kind:z.literal('native_diff_verify'),diff_id:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('process_start'),profile_id:z.string().regex(ID),cwd:relPath.default('.'),args:z.array(z.string().max(2048)).max(64).default([])}),
+  z.strictObject({kind:z.literal('process_read'),session_id:z.string().regex(HEX64),offset:z.number().int().min(0).default(0),max_bytes:z.number().int().min(1).max(262144).default(65536)}),
+  z.strictObject({kind:z.literal('process_status'),session_id:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('process_list')}),
+  z.strictObject({kind:z.literal('process_action'),session_id:z.string().regex(HEX64),action_id:z.string().regex(ID)}),
+  z.strictObject({kind:z.literal('process_terminate'),session_id:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('machine_fs_stat'),path:relPath.default('.'),hash:z.boolean().default(false)}),
+  z.strictObject({kind:z.literal('machine_fs_list'),path:relPath.default('.'),cursor:plannerCursor,limit:z.number().int().min(1).max(1000).default(100),hash_files:z.boolean().default(false)}),
+  z.strictObject({kind:z.literal('machine_fs_read'),path:relPath,offset:z.number().int().min(0).default(0),max_bytes:z.number().int().min(1).max(4194304).default(65536),hash_file:z.boolean().default(false)}),
+  z.strictObject({kind:z.literal('machine_fs_mkdir'),path:relPath}),
+  z.strictObject({kind:z.literal('machine_fs_move'),source_path:relPath,destination_path:relPath,expected_source_identity:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('machine_fs_delete'),path:relPath,expected_source_identity:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('observation_search_start'),path:relPath.default('.'),pattern:z.string().min(1).max(256),case_sensitive:z.boolean().default(false),max_results:z.number().int().min(1).max(1000).default(200),max_files:z.number().int().min(1).max(10000).default(2000),max_bytes:z.number().int().min(1).max(67108864).default(4194304),max_file_bytes:z.number().int().min(1).max(4194304).default(262144)}),
+  z.strictObject({kind:z.literal('observation_search_status'),search_id:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('observation_search_page'),search_id:z.string().regex(HEX64),cursor:plannerCursor,limit:z.number().int().min(1).max(500).default(100)}),
+  z.strictObject({kind:z.literal('observation_search_cancel'),search_id:z.string().regex(HEX64)}),
+  z.strictObject({kind:z.literal('observation_process_list'),include_external:z.boolean().default(false),cursor:plannerCursor,limit:z.number().int().min(1).max(256).default(100)}),
+  z.strictObject({kind:z.literal('observation_system_status')})
+];
 const r34ActionSchema = z.discriminatedUnion('kind',[
   z.strictObject({kind:z.literal('patch'),operations:z.array(r34PatchOperationSchema).min(1).max(32)}),
   z.strictObject({kind:z.literal('run_profile'),profile_id:z.string().regex(ID)}),
-  z.strictObject({kind:z.literal('delegate'),operation:z.record(z.string(),z.json())})
+  z.strictObject({kind:z.literal('delegate'),operation:z.record(z.string(),z.json())}),
+  ...r36TypedActionSchemas
 ]);
 const r34ReadSchema = z.strictObject({
   path:relPath,

package/src/autonomous-planner.mjs

@@ -119,6 +119,27 @@ function normalizeDelegatedOperation(raw) {
   }
   throw new Error('planner delegated operation kind invalid');
 }
+
+function legacyDelegatedToTyped(operation) {
+  if (operation.kind === 'machine_stat') return { kind:'machine_fs_stat', path:operation.path, hash:operation.hash };
+  if (operation.kind === 'machine_list') return { kind:'machine_fs_list', path:operation.path, cursor:operation.cursor, limit:operation.limit, hash_files:operation.hash_files };
+  if (operation.kind === 'machine_read') return { kind:'machine_fs_read', path:operation.path, offset:operation.offset, max_bytes:operation.max_bytes, hash_file:operation.hash };
+  return operation;
+}
+function validateR36TypedAction(action) {
+  const pathFields=[];
+  if (typeof action.path === 'string' && action.path !== '.') pathFields.push(action.path);
+  if (typeof action.cwd === 'string' && action.cwd !== '.') pathFields.push(action.cwd);
+  if (typeof action.source_path === 'string') pathFields.push(action.source_path);
+  if (typeof action.destination_path === 'string') pathFields.push(action.destination_path);
+  for (const item of action.files ?? []) if (typeof item?.path === 'string') pathFields.push(item.path);
+  for (const candidate of pathFields) validatePortableRelativePath(candidate);
+  return action;
+}
+function normalizeR36TypedAction(action) {
+  if (action.kind === 'delegate') return validateR36TypedAction(legacyDelegatedToTyped(normalizeDelegatedOperation(action.operation)));
+  return validateR36TypedAction(action);
+}
 function normalizePlan(raw) {
   strictKeys(raw, ['title','reason','steps'], 'planner plan');
   const title = text(raw.title, 'planner plan title', 160, 1);
@@ -226,9 +247,9 @@ export function parseR34PlannerDecision(rawText, policy) {
       return decision;
     }
     if (decision.action.kind === 'delegate') {
-      return { ...decision, action:{ kind:'delegate', operation:normalizeDelegatedOperation(decision.action.operation) } };
+      return { ...decision, action:normalizeR36TypedAction(decision.action) };
     }
-    throw new Error('R34 planner authority or unsupported action');
+    return { ...decision, action:normalizeR36TypedAction(decision.action) };
   }
   if (decision.kind === 'step_complete') return decision;
   if (decision.kind === 'replan') {
@@ -312,7 +333,8 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     contexts:view.contexts ?? [],
     observations:view.observations ?? [],
     decisions:view.recent_decisions ?? [],
-    projectMemory:view.project_memory ?? null
+    projectMemory:view.project_memory ?? null,
+    capabilities:view.capabilities ?? null
   });
   const stateJson = canonicalJson(state);
   return [