deadbyte-mcp 0.11.0 → 0.11.1

package/scripts/release-parity-r37-0110.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 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){
+  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 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,'R37 generation missing coding core root');
+  const core=path.resolve(raw);const release=path.resolve(pointerValue.release_root);
+  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.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.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),'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,'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});
+  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,'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===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.11.0'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R37 candidate');
+  const successorDisarmed=await probeR36CompactDisarmed(url);
+  await disarmAll();
+
+  const evidence={
+    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,
+    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,`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)};
+}
+
+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\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
+    & node.exe --test test\r37-finalization.test.mjs test\release-version.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 "release parity tests failed with exit code $LASTEXITCODE" }
     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 R36_PREDECESSOR_RELEASE_ID='v0.10.0-8d1e5f09745e7647';
-export const R36_PREDECESSOR_MANIFEST='8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8';
+export const R37_PREDECESSOR_RELEASE_ID='v0.11.0-08c2a0008b1f84c9';
+export const R37_PREDECESSOR_MANIFEST='08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8';
 
 function assert(condition,message){if(!condition) throw new Error(message);}
 function parseFrozenManifest(text){
@@ -91,11 +91,11 @@ 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 publicR36Disarmed(url){
+async function publicR37Disarmed(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');
+  assert(result.status==='passed'&&result.tool_count<=42&&result.capability_closure===true,'R37 predecessor public compact catalog mismatch');
+  assert(result.release_id===R37_PREDECESSOR_RELEASE_ID&&result.release_manifest_sha256===R37_PREDECESSOR_MANIFEST,'R37 predecessor machine binding mismatch');
+  assert(result.coding_armed===false&&result.autonomous_armed===false,'R37 predecessor authority remained armed');
   return result;
 }
 async function mutableCore(pointerValue){
@@ -111,16 +111,16 @@ export function validateParityEvidence(value){
   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.candidate?.version==='0.11.1'&&/^[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.predecessor?.release_id===R37_PREDECESSOR_RELEASE_ID&&value.predecessor?.manifest_sha256===R37_PREDECESSOR_MANIFEST&&value.predecessor?.version==='0.11.0','R37 exact predecessor identity mismatch');
+  assert(value.predecessor_disarmed?.status==='passed'&&value.predecessor_disarmed?.tool_count<=42&&value.predecessor_disarmed?.capability_closure===true,'R37 predecessor public proof missing');
+  assert(value.successor?.version==='0.11.1'&&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}`);
@@ -129,7 +129,7 @@ export function validateParityEvidence(value){
 
 export async function runReleaseParity(activationReceiptPath){
   const active=await pointer();const candidateManifest=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-  assert(active.version==='0.11.0','R37 parity requires active 0.11.0 candidate');
+  assert(active.version==='0.11.1','R37 parity requires active 0.11.1 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;
@@ -154,12 +154,12 @@ export async function runReleaseParity(activationReceiptPath){
   const beforeRollback=await probeR36CompactDisarmed(url);
   const rollbackPair=await scheduleDeferred('rollback',path.resolve(activationReceiptPath));
   const predecessor=await pointer();
-  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);
+  assert(predecessor.release_id===R37_PREDECESSOR_RELEASE_ID&&predecessor.manifest_sha256===R37_PREDECESSOR_MANIFEST&&predecessor.version==='0.11.0','rollback did not reach exact sealed R37 predecessor');
+  const predecessorDisarmed=await publicR37Disarmed(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.11.0'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R37 candidate');
+  assert(successor.version==='0.11.1'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R37 candidate');
   const successorDisarmed=await probeR36CompactDisarmed(url);
   await disarmAll();
 

package/scripts/windows-gate-evidence-r37-0110.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.11.0 / R37 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.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.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,`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();}
+    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.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};
+  }
+}
+
+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.11.0 / R37 WINDOWS BATCH GATE: PASS';
+const marker='DEADBYTE V0.11.1 / R37 WINDOWS BATCH GATE: PASS';
 function insist(ok,message){if(!ok) throw new Error(message);}
 
 export async function writeWindowsGateEvidence({
@@ -19,11 +19,11 @@ 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.11.0',`Windows gate evidence requires V0.11.0, found ${pkg.version}`);
+  insist(pkg.version==='0.11.1',`Windows gate evidence requires V0.11.1, found ${pkg.version}`);
   const completed=clock();
   insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
   const evidence={
-    schema:'deadbyte.r37-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.0',
+    schema:'deadbyte.r37-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.1',
     marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256
   };
   const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
@@ -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.11.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    insist(existing.version==='0.11.1'&&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/deadbyte-cli.mjs

@@ -9,14 +9,17 @@ import { fileURLToPath } from 'node:url';
 import { defaultPublicKeyPath } from './trust.mjs';
 import { verifyAuditChain } from './audit-verify.mjs';
 import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-result-journal.mjs';
-import { createLiveTimelineTracker, formatCompactAuditEvent, formatRemoteLifecycle, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
+import { DEADBYTE_VERSION } from './version.mjs';
+import { createLiveTimelineTracker, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
   'armprocess','disarmprocess','processstatus','armhost','disarmhost','hoststatus','hosttest',
   'armcoding','disarmcoding','codingstatus','codingtest','armautonomous','disarmautonomous','autonomousstatus','autonomoustest'
 ]);
-const SESSION_START=['start','armprocess','armcoding','armautonomous'];
+const SESSION_ARM=['armprocess','armcoding','armautonomous'];
+const REMOTE_STATUS_TIMEOUT_MS=30000;
+const REMOTE_START_TIMEOUT_MS=150000;
 const SESSION_STATUS=[
   ['processstatus',/^Process plane\s*:\s*ARMED\b/m],
   ['codingstatus',/^Coding plane\s*:\s*ARMED\b/m],
@@ -52,11 +55,16 @@ async function remoteContext(){
   const powershell=await requireRegular(path.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe'),'Windows PowerShell');
   return {root,launcher,powershell};
 }
-function invokeController(ctx,command,{capture=false,allowFailure=false,echoCaptured=true}={}){
-  const result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],{
+function invokeController(ctx,command,{capture=false,allowFailure=false,echoCaptured=true,timeoutMs=null}={}){
+  const options={
     stdio:capture?['ignore','pipe','pipe']:'inherit',encoding:capture?'utf8':undefined,windowsHide:false,shell:false
-  });
-  if(result.error) throw result.error;
+  };
+  if(Number.isInteger(timeoutMs)&&timeoutMs>0) options.timeout=timeoutMs;
+  const result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],options);
+  if(result.error){
+    if(result.error?.code==='ETIMEDOUT') throw new Error(`remote controller '${command}' timed out after ${timeoutMs}ms`);
+    throw result.error;
+  }
   const status=Number.isInteger(result.status)?result.status:1;
   const stdout=capture?String(result.stdout||''):'';
   const stderr=capture?String(result.stderr||''):'';
@@ -64,6 +72,14 @@ function invokeController(ctx,command,{capture=false,allowFailure=false,echoCapt
   if(status!==0&&!allowFailure) throw new Error(`remote controller '${command}' failed exit=${status}`);
   return {status,stdout,stderr};
 }
+function controllerRuntimeReady(text){
+  const value=String(text||'');
+  return /^DEADBYTE MCP\s*=\s*ONLINE\s*$/m.test(value)&&
+    /^Bridge PID\s*:\s*\d+\s+\[verified\]\s*$/m.test(value)&&
+    /^Cloud PID\s*:\s*\d+\s+\[verified\]\s*$/m.test(value)&&
+    /^Local ready\s*:\s*True\s*$/m.test(value)&&
+    /^Loop supervisor:\s*RUNNING\s+\[verified\]\s*$/m.test(value);
+}
 async function listLogFiles(root){
   const files=[];
   const audit=path.join(root,'audit');
@@ -88,13 +104,17 @@ function formatLogLine(file,line,{activityTracker=null}={}){
   return formatRuntimeDiagnosticLine(file,line);
 }
 function remoteResultJournalPath(root,sessionId){return path.join(root,'runtime','remote-results',`${sessionId}.json`);}
-function auditTerminalResult(file,line){
+function auditTimelineRecord(file,line){
   if(!/^segment-\d{8}\.jsonl$/.test(path.basename(file))||!line) return null;
   let event;try{event=JSON.parse(line);}catch{return null;}
-  if(event?.event_type!=='tool.result'||typeof event.request_id!=='string'||!event.request_id||typeof event.tool!=='string'||!event.tool) return null;
+  if(typeof event?.request_id!=='string'||!event.request_id||typeof event.tool!=='string'||!event.tool) return null;
   const observed=Number.isFinite(Date.parse(event.created_at_utc))?new Date(Date.parse(event.created_at_utc)).toISOString():new Date().toISOString();
-  return {request_id:event.request_id,tool:event.tool,status:event.outcome?.is_error===true?'error':'ok',observed_at_utc:observed,
-    payload_sha256:createHash('sha256').update(Buffer.from(line,'utf8')).digest('hex')};
+  const payload_sha256=createHash('sha256').update(Buffer.from(line,'utf8')).digest('hex');
+  if(event.event_type==='tool.request') return {event_type:'tool.call',request_id:event.request_id,tool:event.tool,
+    observed_at_utc:observed,arguments:event.args??{},payload_sha256};
+  if(event.event_type==='tool.result') return {event_type:'tool.result',request_id:event.request_id,tool:event.tool,
+    status:event.outcome?.is_error===true?'error':'ok',observed_at_utc:observed,payload_sha256};
+  return null;
 }
 async function replayRemoteResults(root,cursor){
   const parsed=parseRemoteResultCursor(cursor);
@@ -105,6 +125,12 @@ async function replayRemoteResults(root,cursor){
   for(;;){
     const page=await journal.replayAfter(next,{limit:200});
     for(const event of page.events){
+      if(event.event_type==='tool.call'){
+        const line=formatRemoteToolCall({event_type:'tool.request',tool:event.tool,request_id:event.request_id,
+          observed_at_utc:event.observed_at_utc,args:event.arguments});
+        process.stdout.write(`${line} | REPLAY cursor r1:${event.session_id}:${event.seq}\n`);
+        continue;
+      }
       const marker=event.status==='error'?'[ERR]':'[OK]';
       process.stdout.write(`[REPLAY] ${marker} ${event.tool} [cursor r1:${event.session_id}:${event.seq}]\n`);
     }
@@ -139,9 +165,11 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
       const next=await readAppend(file,prior);
       activeOffsets.set(file,next.offset);
       for(const line of next.text.split(/\r?\n/)){
-        const terminal=auditTerminalResult(file,line);
+        const timeline=auditTimelineRecord(file,line);
         let recorded=null;
-        if(terminal&&journal) recorded=await journal.recordTerminal(terminal);
+        if(timeline&&journal) recorded=timeline.event_type==='tool.call'
+          ? await journal.recordCall(timeline)
+          : await journal.recordTerminal(timeline);
         if(recorded?.duplicate) continue;
         const formatted=formatLogLine(file,line,{activityTracker});
         if(!formatted) continue;
@@ -257,18 +285,21 @@ async function runRemoteSession({resumeCursor=null}={}){
     const logOffsets=await snapshotRemoteLogOffsets(ctx.root);
     logTask=tailRemoteLogs(ctx.root,aborter.signal,{journal:resultJournal,offsets:logOffsets,activityTracker});
     process.stdout.write('[BOOT] Starting local + remote runtime...\n');
-    const started=[];
-    for(const command of SESSION_START){
-      if(command==='start') process.stdout.write('[BOOT] Starting bridge/runtime...\n');
-      else process.stdout.write(`🔐 [AUTH] Arming ${command.slice(3)}...\n`);
-      const controllerResult=invokeController(ctx,command,{capture:true,echoCaptured:false});
-      started.push(controllerResult);
-      if(command==='start'){
-        process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);
-        process.stdout.write(`${formatRemoteLifecycle('cloud_connected')}\n`);
-      }
+    const preflight=invokeController(ctx,'status',{capture:true,allowFailure:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+    let startText=preflight.stdout||'';
+    if(preflight.status===0&&controllerRuntimeReady(preflight.stdout)){
+      process.stdout.write('[BOOT] Runtime already ONLINE; reusing verified bridge/cloud/supervisor.\n');
+    }else{
+      process.stdout.write('[BOOT] Starting bridge/runtime...\n');
+      const started=invokeController(ctx,'start',{capture:true,echoCaptured:false,timeoutMs:REMOTE_START_TIMEOUT_MS});
+      startText=started.stdout||'';
+    }
+    process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);
+    process.stdout.write(`${formatRemoteLifecycle('cloud_connected')}\n`);
+    for(const command of SESSION_ARM){
+      process.stdout.write(`🔐 [AUTH] Arming ${command.slice(3)}...\n`);
+      invokeController(ctx,command,{capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
     }
-    const startText=started[0]?.stdout||'';
     const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
     process.stdout.write('[OK] ONLINE\n');
     process.stdout.write(`${formatRemoteLifecycle('ready')}\n`);
@@ -320,6 +351,10 @@ async function runAudit(args){
 }
 async function main(argv){
   const [command,...rest]=argv;
+  if(command==='--version'||command==='-v'||command==='version'){
+    if(rest.length) throw new Error('version accepts no arguments');
+    process.stdout.write(`${DEADBYTE_VERSION}\n`);return;
+  }
   if(!command||command==='help'||command==='--help'||command==='-h'){printHelp();return;}
   if(command==='mcp'){
     if(rest.length) throw new Error('mcp accepts no arguments');

package/src/remote-live-log.mjs

@@ -1,3 +1,6 @@
+import { canonicalJson } from './canonical-json.mjs';
+import { sanitizeAuditArgs } from './tool-audit.mjs';
+
 const SAFE_ARG_KEYS=Object.freeze(['root_id','path','pattern','command_id','profile_id','session_id','goal_id','task_id','step_id','mode']);
 const LIFECYCLE=Object.freeze({
   device_start:'🚀 [DEVICE] Starting DEADBYTE MCP...',
@@ -30,6 +33,25 @@ function summarizeArgs(args){
   return parts.length?` ${parts.join(' ')}`:'';
 }
 
+const TOOL_COLUMN_WIDTH=32;
+
+function eventTimestamp(event,clock){
+  for(const value of [event?.created_at_utc,event?.observed_at_utc]){
+    const parsed=Date.parse(value);
+    if(typeof value==='string'&&Number.isFinite(parsed)) return new Date(parsed).toISOString();
+  }
+  const value=Number(clock());
+  return new Date(Number.isFinite(value)?value:Date.now()).toISOString();
+}
+
+export function formatRemoteToolCall(event,{clock=()=>Date.now()}={}){
+  if(!event||typeof event!=='object'||Array.isArray(event)||event.event_type!=='tool.request'||
+     typeof event.tool!=='string'||!event.tool) return null;
+  if(typeof clock!=='function') throw new Error('remote tool-call clock must be a function');
+  const args=sanitizeAuditArgs(event.args??{});
+  return `${eventTimestamp(event,clock)} | ${event.tool.padEnd(TOOL_COLUMN_WIDTH)} | Arguments: ${canonicalJson(args)}`;
+}
+
 function formatDuration(ms){
   const value=Number(ms);
   if(!Number.isFinite(value)||value<0) return '';
@@ -92,7 +114,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now()}={}){
       if(event.event_type==='tool.request'&&requestId&&tool){
         if(pending.has(requestId)||completed.has(requestId)) return null;
         pending.set(requestId,{request_id:requestId,tool,started_at_ms:clock()});
-        return `▶ [${shortSpanId(requestId)}] RUN ${tool}${summarizeArgs(event.args)}`;
+        return formatRemoteToolCall(event,{clock});
       }
       if(event.event_type==='tool.result'&&requestId&&tool){
         if(completed.has(requestId)) return null;

package/src/remote-result-journal.mjs

@@ -1,10 +1,12 @@
 import { lstat, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { sanitizeAuditArgs } from './tool-audit.mjs';
 
 export const REMOTE_RESULT_JOURNAL_SCHEMA='deadbyte.remote-result-journal.v1';
 const SESSION=/^[0-9a-f]{24}$/;
 const HASH=/^[0-9a-f]{64}$/;
 const STATUS=new Set(['ok','error']);
+const EVENT_TYPES=new Set(['tool.call','tool.result']);
 
 function text(value,label,max){
   if(typeof value!=='string'||value.length<1||value.length>max||value.includes('\0')) throw new Error(`${label} invalid`);
@@ -26,14 +28,22 @@ function validateEvent(raw,index=null){
   const sessionId=validateSession(raw.session_id);
   const requestId=text(raw.request_id,'remote result request_id',256);
   const tool=text(raw.tool,'remote result tool',128);
-  if(!STATUS.has(raw.status)) throw new Error('remote result status invalid');
+  const eventType=raw.event_type===undefined?'tool.result':raw.event_type;
+  if(!EVENT_TYPES.has(eventType)) throw new Error('remote result event_type invalid');
   const observed=iso(raw.observed_at_utc,'remote result observed_at_utc');
   if(typeof raw.payload_sha256!=='string'||!HASH.test(raw.payload_sha256)) throw new Error('remote result payload_sha256 invalid');
   if(index!==null&&seq!==index) throw new Error('remote result sequence mismatch');
-  return Object.freeze({session_id:sessionId,seq,request_id:requestId,tool,status:raw.status,
+  if(eventType==='tool.call'){
+    const rawArgs=raw.arguments??{};
+    if(!rawArgs||typeof rawArgs!=='object'||Array.isArray(rawArgs)) throw new Error('remote result call arguments invalid');
+    return Object.freeze({session_id:sessionId,seq,event_type:eventType,request_id:requestId,tool,
+      observed_at_utc:observed,payload_sha256:raw.payload_sha256,arguments:sanitizeAuditArgs(rawArgs)});
+  }
+  if(!STATUS.has(raw.status)) throw new Error('remote result status invalid');
+  return Object.freeze({session_id:sessionId,seq,event_type:eventType,request_id:requestId,tool,status:raw.status,
     observed_at_utc:observed,payload_sha256:raw.payload_sha256});
 }
-function identity(item){return `${item.request_id}\0${item.status}\0${item.payload_sha256}`;}
+function identity(item){return `${item.event_type}\0${item.request_id}\0${item.status??''}\0${item.payload_sha256}`;}
 export function parseRemoteResultCursor(cursor){
   if(typeof cursor!=='string') throw new Error('remote result cursor invalid');
   const match=/^r1:([0-9a-f]{24}):(0|[1-9][0-9]{0,15})$/.exec(cursor);
@@ -89,8 +99,17 @@ export async function openRemoteResultJournal({filePath,sessionId,maxEntries=204
   return Object.freeze({
     file_path:file,session_id:sid,
     cursor(){return cursorFor(sid,state.next_seq-1);},
+    async recordCall(input){
+      const candidate=validateEvent({session_id:sid,seq:state.next_seq,event_type:'tool.call',...input});
+      const key=identity(candidate);
+      const existing=state.events.find(event=>identity(event)===key);
+      if(existing) return {duplicate:true,event:existing,cursor:cursorFor(sid,state.next_seq-1)};
+      const event=candidate;
+      state.events.push(event);state.next_seq+=1;await persist();
+      return {duplicate:false,event,cursor:cursorFor(sid,event.seq)};
+    },
     async recordTerminal(input){
-      const candidate=validateEvent({session_id:sid,seq:state.next_seq,...input});
+      const candidate=validateEvent({session_id:sid,seq:state.next_seq,event_type:'tool.result',...input});
       const key=identity(candidate);
       const existing=state.events.find(event=>identity(event)===key);
       if(existing) return {duplicate:true,event:existing,cursor:cursorFor(sid,state.next_seq-1)};