deadbyte-mcp 0.11.1 → 0.11.3

package/scripts/release-parity-r39.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-r39.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 R39_PREDECESSOR_RELEASE_ID='v0.11.2-058605dfccaa3035';
+export const R39_PREDECESSOR_MANIFEST='058605dfccaa3035a57c6393d53f2421c14e5a92bd145c2334477ba24d7cab8b';
+
+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 publicR39Disarmed(url){
+  const result=await probeR36CompactDisarmed(url);
+  assert(result.status==='passed'&&result.tool_count<=42&&result.capability_closure===true,'R39 predecessor public compact catalog mismatch');
+  assert(result.release_id===R39_PREDECESSOR_RELEASE_ID&&result.release_manifest_sha256===R39_PREDECESSOR_MANIFEST,'R39 predecessor machine binding mismatch');
+  assert(result.coding_armed===false&&result.autonomous_armed===false,'R39 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,'R39 generation missing coding core root');
+  const core=path.resolve(raw);const release=path.resolve(pointerValue.release_root);
+  assert(core.toLowerCase()!==release.toLowerCase(),'R39 coding core must not point at immutable active release slot');
+  return core;
+}
+
+export function validateParityEvidence(value){
+  assert(value?.schema==='deadbyte.r39-parity.v1','R39 parity schema mismatch');
+  assert(value.status==='passed','R39 parity status is not passed');
+  assert(value.rdc_operation_count===0&&value.execution_provider==='deadbyte_mcp','R39 parity used non-DEADBYTE execution');
+  assert(value.candidate?.version==='0.11.3'&&/^[0-9a-f]{64}$/.test(value.candidate?.manifest_sha256??''),'R39 candidate identity missing');
+  assert(value.local_full?.status==='passed'&&value.local_full?.tool_count===76&&value.local_full?.strict_output_schemas===true,'R39 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,'R39 public compact closure missing');
+  assert(value.autonomous?.status==='passed'&&value.autonomous?.signed_release_verified===true,'R39 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,'R39 pre-rollback disarm proof missing');
+  assert(value.rollback?.state==='completed'&&value.restore?.state==='completed','R39 rollback/restore not completed');
+  assert(value.stage_restore?.status==='restored'&&value.stage_restore?.manifest_sha256===value.candidate.manifest_sha256,'R39 stage restore proof missing');
+  assert(value.predecessor?.release_id===R39_PREDECESSOR_RELEASE_ID&&value.predecessor?.manifest_sha256===R39_PREDECESSOR_MANIFEST&&value.predecessor?.version==='0.11.2','R39 exact predecessor identity mismatch');
+  assert(value.predecessor_disarmed?.status==='passed'&&value.predecessor_disarmed?.tool_count<=42&&value.predecessor_disarmed?.capability_closure===true,'R39 predecessor public proof missing');
+  assert(value.successor?.version==='0.11.3'&&value.successor?.manifest_sha256===value.candidate.manifest_sha256,'R39 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,'R39 successor disarmed proof missing');
+  assert(value.immutable_slot?.protected===true&&value.immutable_slot?.development_root!==value.immutable_slot?.release_root,'R39 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,`R39 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.3','R39 parity requires active 0.11.3 candidate');
+  assert(active.manifest_sha256===candidateManifest,'active release is not canonical R39 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),'R39 active bridge root missing');
+  assert(typeof successorBridgeConfiguredSha==='string'&&/^[0-9a-f]{64}$/.test(successorBridgeConfiguredSha),'R39 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,'R39 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,'R39 autonomous compact parity');
+    assert(autonomous.status==='passed'&&autonomous.signed_release_verified===true,'R39 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===R39_PREDECESSOR_RELEASE_ID&&predecessor.manifest_sha256===R39_PREDECESSOR_MANIFEST&&predecessor.version==='0.11.2','rollback did not reach exact sealed R39 predecessor');
+  const predecessorDisarmed=await publicR39Disarmed(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.3'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R39 candidate');
+  const successorDisarmed=await probeR36CompactDisarmed(url);
+  await disarmAll();
+
+  const evidence={
+    schema:'deadbyte.r39-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,`r39-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-r39.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-r38.ps1

@@ -0,0 +1,9 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+$root = Split-Path -Parent $PSScriptRoot
+Push-Location $root
+try {
+    & node.exe --test test\controller.test.mjs test\r38-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 "R38 release parity tests failed with exit code $LASTEXITCODE" }
+    Write-Output 'R38 RELEASE PARITY TEST PASS'
+} finally { Pop-Location }

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

@@ -0,0 +1,9 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+$root = Split-Path -Parent $PSScriptRoot
+Push-Location $root
+try {
+    & node.exe --test test\controller.test.mjs test\r39-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 "R39 release parity tests failed with exit code $LASTEXITCODE" }
+    Write-Output 'R39 RELEASE PARITY TEST PASS'
+} finally { Pop-Location }

package/scripts/windows-gate-evidence-r38.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.2 / R38 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.2',`Windows gate evidence requires V0.11.2, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r38-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.2',
+    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,`r38-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.2'&&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-r39.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.3 / R39 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.3',`Windows gate evidence requires V0.11.3, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r39-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.3',
+    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,`r39-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.3'&&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/src/deadbyte-cli.mjs

@@ -55,9 +55,11 @@ 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,timeoutMs=null}={}){
+function invokeController(ctx,command,{capture=false,allowFailure=false,echoCaptured=true,timeoutMs=null,discardOutput=false}={}){
+  if(capture&&discardOutput) throw new Error('invokeController cannot capture and discard output together');
   const options={
-    stdio:capture?['ignore','pipe','pipe']:'inherit',encoding:capture?'utf8':undefined,windowsHide:false,shell:false
+    stdio:discardOutput?['ignore','ignore','ignore']:(capture?['ignore','pipe','pipe']:'inherit'),
+    encoding:capture?'utf8':undefined,windowsHide:false,shell:false
   };
   if(Number.isInteger(timeoutMs)&&timeoutMs>0) options.timeout=timeoutMs;
   const result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],options);
@@ -291,7 +293,9 @@ async function runRemoteSession({resumeCursor=null}={}){
       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});
+      invokeController(ctx,'start',{discardOutput:true,timeoutMs:REMOTE_START_TIMEOUT_MS});
+      const started=invokeController(ctx,'status',{capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+      if(started.status!==0||!controllerRuntimeReady(started.stdout)) throw new Error('remote controller start returned without a verified ONLINE runtime');
       startText=started.stdout||'';
     }
     process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);

package/src/release-generation.mjs

@@ -60,16 +60,33 @@ function rebindCodingPolicy(raw,{developmentRoot,stateRoot,parityScratchRoot}){
   policy.roots.parity_scratch={path:parityScratchRoot,read:true,write:true,exec:false,deny_paths:[]};
   return policy;
 }
+async function currentWindowsGateScript(rootPath){
+  const packagePath=path.join(rootPath,'package.json');
+  const stat=await lstat(packagePath);
+  if(!stat.isFile()||stat.isSymbolicLink()) throw new Error('windows release gate package.json invalid');
+  let pkg;
+  try{ pkg=JSON.parse(await readFile(packagePath,'utf8')); }
+  catch{ throw new Error('windows release gate package.json malformed'); }
+  const command=String(pkg?.scripts?.['gate:windows']??'').trim();
+  const match=/^powershell(?:\.exe)?\s+-NoProfile\s+-ExecutionPolicy\s+Bypass\s+-File\s+(scripts\/[A-Za-z0-9._\/-]+\.ps1)$/i.exec(command);
+  if(!match) throw new Error('windows release gate package script invalid');
+  return safeRel(match[1]);
+}
 async function rebindAutonomousPolicy(raw,{stateRoot,codingPolicy,codingPolicyBytes}){
   const policy=clone(raw);
   policy.lease_file=path.join(stateRoot,'runtime','autonomous-grant.json');
   policy.evidence_dir=path.join(stateRoot,'evidence','autonomous');
   policy.coding_policy_sha256=sha256(codingPolicyBytes);
   for(const [id,profile] of Object.entries(policy.profiles??{})){
-    const rel=safeRel(String(profile.script_path).replaceAll('\\','/'));
     const rootId=String(profile.root_id??'');
     const rootPath=codingPolicy.roots?.[rootId]?.path;
     if(typeof rootPath!=='string'||!path.isAbsolute(rootPath)) throw new Error(`profile root invalid: ${id}`);
+    if(id==='windows-release'){
+      if(profile.kind!=='command'||rootId!=='core'||profile.command_id!=='powershell_script') throw new Error('windows release profile shape invalid');
+      profile.script_path=await currentWindowsGateScript(rootPath);
+      profile.description='Full Windows target release gate; runs only when finish is requested.';
+    }
+    const rel=safeRel(String(profile.script_path).replaceAll('\\','/'));
     const file=path.resolve(rootPath,...rel.split('/'));
     const boundary=path.relative(rootPath,file);
     if(boundary.startsWith(`..${path.sep}`)||path.isAbsolute(boundary)) throw new Error(`profile path escapes coding root: ${id}`);

package/src/remote-live-log.mjs

@@ -34,14 +34,21 @@ function summarizeArgs(args){
 }
 
 const TOOL_COLUMN_WIDTH=32;
+const DISPLAY_UTC_OFFSET_MINUTES=7*60;
+const DISPLAY_UTC_OFFSET_LABEL='+07:00';
+
+function displayTimestamp(ms){
+  const shifted=new Date(ms+DISPLAY_UTC_OFFSET_MINUTES*60*1000).toISOString();
+  return `${shifted.slice(0,-1)}${DISPLAY_UTC_OFFSET_LABEL}`;
+}
 
 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();
+    if(typeof value==='string'&&Number.isFinite(parsed)) return displayTimestamp(parsed);
   }
   const value=Number(clock());
-  return new Date(Number.isFinite(value)?value:Date.now()).toISOString();
+  return displayTimestamp(Number.isFinite(value)?value:Date.now());
 }
 
 export function formatRemoteToolCall(event,{clock=()=>Date.now()}={}){

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.11.1';
+export const DEADBYTE_VERSION = '0.11.3';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/cli-entrypoint.test.mjs

@@ -21,7 +21,7 @@ test('npx CLI reports the canonical package version through --version, -v and ve
   for(const arg of ['--version','-v','version']){
     const result=spawnSync(process.execPath,[cliPath,arg],{cwd:root,encoding:'utf8',windowsHide:true});
     assert.equal(result.status,0,result.stderr);
-    assert.equal(result.stdout.trim(),'0.11.1');
+    assert.equal(result.stdout.trim(),'0.11.3');
   }
 });
 

package/test/controller.test.mjs

@@ -215,3 +215,14 @@ test('R34 supervisor lifecycle never arms privileged planes', async () => {
   assert.match(block,/Disarm-Process/);
   assert.match(block,/Disarm-Host/);
 });
+
+test('supervisor recovery never assigns PowerShell automatic variable $Host', async () => {
+  const source=await readFile(controller,'utf8');
+  const start=source.indexOf('function Recover-AutonomousSupervisor');
+  const end=source.indexOf('function Show-State',start);
+  assert.ok(start>=0&&end>start,'supervisor recovery block missing');
+  const block=source.slice(start,end);
+  assert.doesNotMatch(block,/\$host\s*=/i,'PowerShell $Host is read-only and names are case-insensitive');
+  assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus\s+\$Cfg/);
+  assert.match(block,/Host=\$hostStatus/);
+});

package/test/core.test.mjs

@@ -105,7 +105,7 @@ test('proof execution creates deterministic output and signed verifiable receipt
   assert.equal(result.receipt.request.schema, 'deadbyte.request.v1');
   assert.match(result.receipt.request.nonce, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.request.sha256, /^[0-9a-f]{64}$/);
-  assert.equal(result.receipt.runtime.package_version, '0.11.1');
+  assert.equal(result.receipt.runtime.package_version, '0.11.3');
   assert.match(result.receipt.runtime.mcp_ingress_adapter, /^(?:none|tunnel-stdio-probe-compat-v1)$/);
   assert.match(result.receipt.runtime.mcp_ingress_adapter_sha256, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.runtime.mcp_ingress_mode_source_sha256, /^[0-9a-f]{64}$/);

package/test/production-docs.test.mjs

@@ -9,9 +9,9 @@ const readme=()=>readFile(path.join(root,'README.txt'),'utf8');
 
 test('production README documents one-command stdio configs for major MCP clients',async()=>{
   const text=await readme();
-  assert.match(text,/npx -y deadbyte-mcp@0\.11\.1 mcp/);
+  assert.match(text,/npx -y deadbyte-mcp@0\.11\.3 mcp/);
   assert.match(text,/CLAUDE DESKTOP/);
-  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.11\.1"[\s\S]*?"mcp"/);
+  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.11\.3"[\s\S]*?"mcp"/);
   assert.match(text,/CURSOR/);
   assert.match(text,/\.cursor\/mcp\.json/);
   assert.match(text,/VS CODE/);
@@ -20,7 +20,7 @@ test('production README documents one-command stdio configs for major MCP client
   assert.match(text,/CODEX/);
   assert.match(text,/\[mcp_servers\.deadbyte\]/);
   assert.match(text,/command\s*=\s*"npx"/);
-  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.11\.1",\s*"mcp"\]/);
+  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.11\.3",\s*"mcp"\]/);
 });
 
 test('production README records tracer bullet, semantic scope, remote UX, safety and document extension',async()=>{

package/test/r33-closeout-regression.test.mjs

@@ -5,7 +5,7 @@ import { mkdtemp, mkdir, readFile, rm, writeFile, readdir } from 'node:fs/promis
 import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
-import * as parity from '../scripts/release-parity.mjs';
+import * as parity from '../scripts/release-parity-r39.mjs';
 import { createToolAudit } from '../src/tool-audit.mjs';
 import { verifyAuditChain } from '../src/audit-verify.mjs';
 import { generateTrustKeypair } from '../src/trust.mjs';
@@ -86,12 +86,12 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows R37 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
+test('Windows R39 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
   const stateRoot=await temp('deadbyte-r33-windows-evidence-');
   try{
-    const gate=await readFile(path.join(root,'scripts','gate-windows.ps1'),'utf8');
-    assert.match(gate,/windows-gate-evidence\.mjs/,'gate-windows.ps1 must invoke the evidence writer');
-    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence.mjs')],{
+    const gate=await readFile(path.join(root,'scripts','gate-windows-r39.ps1'),'utf8');
+    assert.match(gate,/windows-gate-evidence-r39\.mjs/,'gate-windows-r39.ps1 must invoke the evidence writer');
+    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence-r39.mjs')],{
       cwd:root,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
     });
     assert.equal(result.code,0,result.stderr||result.stdout);
@@ -99,12 +99,12 @@ test('Windows R37 gate emits manifest-bound machine-readable evidence outside th
     assert.equal(summary.status,'written');
     const evidence=JSON.parse(await readFile(summary.path,'utf8'));
     const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r37-windows-gate.v1');
+    assert.equal(evidence.schema,'deadbyte.r39-windows-gate.v1');
     assert.equal(evidence.status,'passed');
     assert.equal(evidence.exit_code,0);
-    assert.equal(evidence.version,'0.11.1');
+    assert.equal(evidence.version,'0.11.3');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.11.1 / R37 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.11.3 / R39 WINDOWS BATCH GATE: PASS');
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

package/test/r33-finalization.test.mjs

@@ -2,8 +2,8 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { R34_EXPECTED_TOOLS } from '../src/remote-mcp-r34-parity-client.mjs';
-import { validateParityEvidence } from '../scripts/release-parity.mjs';
-import { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
+import { validateParityEvidence } from '../scripts/release-parity-r39.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r39.mjs';
 
 const root = new URL('../', import.meta.url);
 const text = rel => readFile(new URL(rel, root), 'utf8');
@@ -19,28 +19,28 @@ test('R34 public parity catalog is exact, unique, and includes production coding
 
 test('release parity and final verifier are package entry points', async () => {
   const pkg = JSON.parse(await text('package.json'));
-  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify.mjs');
+  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r39.mjs');
+  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r39.mjs');
+  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r39.mjs');
   assert.equal(typeof validateParityEvidence, 'function');
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });
 
-test('R37 final closure verifier is implementation-independent from production helpers', async () => {
-  const verifier = await text('scripts/final-closure-verify.mjs');
-  const writer = await text('scripts/final-closure.mjs');
+test('R39 final closure verifier is implementation-independent from production helpers', async () => {
+  const verifier = await text('scripts/final-closure-verify-r39.mjs');
+  const writer = await text('scripts/final-closure-r39.mjs');
   assert.doesNotMatch(verifier, /from ['"]\.\.\/src\//);
   assert.match(verifier, /DEADBYTE-R27-SLOT-UPDATE-V1/);
   assert.match(verifier, /DEADBYTE-MACHINE-PING-V1/);
-  assert.match(verifier, /DEADBYTE-R37-FINAL-CLOSURE-V1/);
-  assert.match(writer, /pointer\.version==='0\.11\.1'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.11\.1'/);
-  assert.match(verifier, /release_label==='R37 FINAL MACHINE BASELINE'/);
-  assert.match(verifier, /08c2a0008b1f84c90f7ce7faa1e3decbd03f33612bc0fdc7d1ba591b548798e8/);
+  assert.match(verifier, /DEADBYTE-R39-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.11\.3'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.11\.3'/);
+  assert.match(verifier, /release_label==='R39 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /058605dfccaa3035a57c6393d53f2421c14e5a92bd145c2334477ba24d7cab8b/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {
-  const verifier = await text('scripts/final-closure-verify.mjs');
+  const verifier = await text('scripts/final-closure-verify-r39.mjs');
   assert.match(verifier, /const actual=\(await walk\(root\)\)\.filter\(rel=>rel!==manifestName\)\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
   assert.match(verifier, /const expected=\[\.\.\.entries\.keys\(\)\]\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
 });

package/test/r37-remote-tool-call-timeline.test.mjs

@@ -24,7 +24,7 @@ test('R37 unified timeline renders one sanitized tool-call line with ISO timesta
     }
   };
   const line=formatRemoteToolCall(event);
-  assert.match(line,/^2026-09-18T16:24:30\.125Z \| coding_file_write\s+\| Arguments: \{/);
+  assert.match(line,/^2026-09-18T23:24:30\.125\+07:00 \| coding_file_write\s+\| Arguments: \{/);
   assert.match(line,/"root_id":"projects"/);
   assert.match(line,/"path":"src\/example\.mjs"/);
   assert.match(line,/"reason":"payload"/);
@@ -37,7 +37,7 @@ test('R37 live tracker uses the tool-call line for request and keeps correlated
   const tracker=createLiveTimelineTracker({clock:()=>now});
   const call=tracker.observe({event_type:'tool.request',request_id:'abcdef1234567890',tool:'coding_tree',
     created_at_utc:'2026-09-18T16:24:30.125Z',args:{root_id:'projects',path:'src'}});
-  assert.match(call,/^2026-09-18T16:24:30\.125Z \| coding_tree\s+\| Arguments: \{"path":"src","root_id":"projects"\}$/);
+  assert.match(call,/^2026-09-18T23:24:30\.125\+07:00 \| coding_tree\s+\| Arguments: \{"path":"src","root_id":"projects"\}$/);
   now+=250;
   assert.equal(tracker.observe({event_type:'tool.result',request_id:'abcdef1234567890',tool:'coding_tree',
     outcome:{is_error:false,duration_ms:250}}),'✓ [abcdef12] OK  coding_tree 250ms');