deadbyte-mcp 0.14.0 → 0.15.0

package/scripts/finalize-r44.mjs

@@ -0,0 +1,217 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { spawn, spawnSync } from 'node:child_process';
+import { lstat, mkdir, readFile, realpath, rename, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseActivePointer } from '../src/release-slot.mjs';
+import { loadPowerShellDataFile, parseControllerStatus, runSlotUpdateCli, windowsPowerShellEnvironment } from '../src/runtime-update.mjs';
+import { verifyR44Parent } from './verify-r44-parent.mjs';
+import { runReleaseParity } from './release-parity-r44.mjs';
+import { writeFinalClosure } from './final-closure-r44.mjs';
+import { verifyFinalClosureObject } from './final-closure-verify-r44.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const EXPECTED_VERSION='0.15.0';
+const PARENT_RELEASE_ID='v0.14.1-0a5a833892593283';
+const PARENT_MANIFEST='0a5a8338925932830986421dda60ec5643f62f600404de4992fda2a5e79d09a9';
+const PARENT_FINAL_CLOSURE='2f29e94dd726638c23b2e520a608dcf2a6919e43348855be3940599d557f920b';
+const here=path.dirname(fileURLToPath(import.meta.url));
+const packageRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const evidenceRoot=path.join(stateRoot,'evidence','release','r44-finalization');
+const launcher=path.join(stateRoot,'bin','DEADBYTE-MCP.ps1');
+const ps=path.join(process.env.SystemRoot||'C:\\Windows','System32','WindowsPowerShell','v1.0','powershell.exe');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+
+async function atomicJson(file,value){
+  await mkdir(path.dirname(file),{recursive:true});
+  const bytes=Buffer.from(`${JSON.stringify(value,null,2)}\n`,'utf8');
+  const temp=`${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+  await writeFile(temp,bytes,{flag:'wx'});
+  await rename(temp,file);
+  return {path:file,sha256:sha256(bytes)};
+}
+async function activePointer(){
+  return parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+}
+async function bridgeArgs(){
+  const pointer=await activePointer();
+  const config=await loadPowerShellDataFile(pointer.config_path);
+  const raw=config?.Bridge?.WorkingDirectory;
+  insist(typeof raw==='string'&&path.isAbsolute(raw),'active Bridge.WorkingDirectory must be absolute');
+  const root=await realpath(path.resolve(raw));
+  const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+  insist(pkg?.name==='deadbyte-chatgpt-bridge','active Bridge package identity mismatch');
+  const script=path.join(root,'src','bridge.mjs');
+  return ['--bridge-root',root,'--bridge-script-sha256',sha256(await readFile(script))];
+}
+async function activationArgs(manifestSha256){
+  insist(HEX64.test(manifestSha256??''),'R44 finalizer manifest must be lowercase SHA-256');
+  const processPolicy=path.join(packageRoot,'controller','deadbyte-process-policy.json');
+  const desktopPolicy=path.join(packageRoot,'controller','deadbyte-desktop-policy.json');
+  const semantic=path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json');
+  return [
+    '--stage',packageRoot,'--development-root',packageRoot,'--expected-version',EXPECTED_VERSION,
+    '--expected-manifest',manifestSha256,
+    '--process-policy',processPolicy,'--process-policy-sha256',sha256(await readFile(processPolicy)),
+    '--desktop-policy',desktopPolicy,'--desktop-policy-sha256',sha256(await readFile(desktopPolicy)),
+    '--semantic-lsp-config',semantic,'--semantic-lsp-config-sha256',sha256(await readFile(semantic)),
+    '--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor',
+    '--restore-standing-grants',
+    ...await bridgeArgs()
+  ];
+}
+export function validateFinalizerAuthorityStatus(status){
+  insist(status?.process_armed===true,'R44 finalizer requires Process standing grant');
+  insist(status?.coding_armed===true,'R44 finalizer requires Coding standing grant');
+  insist(status?.autonomous_armed===true,'R44 finalizer requires Autonomous standing grant');
+  insist(status?.desktop_armed===false,'R44 finalizer requires Desktop DISARMED');
+  insist(status?.host_armed===false,'R44 finalizer requires Host DISARMED');
+  return true;
+}
+function currentAuthorityStatus(){
+  const result=spawnSync(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,'status'],
+    {encoding:'utf8',windowsHide:true,timeout:20000,env:windowsPowerShellEnvironment()});
+  if(result.error) throw result.error;
+  if(result.status!==0) throw new Error(`R44 finalizer controller status failed: ${result.stderr||result.stdout}`);
+  return parseControllerStatus(result.stdout??'');
+}
+export function validateWindowsGateEvidence(value,manifestSha256,parent){
+  insist(value?.schema==='deadbyte.r44-windows-gate.v1'&&value.status==='passed'&&value.exit_code===0,'R44 Windows gate evidence invalid');
+  insist(value.version===EXPECTED_VERSION&&value.manifest_sha256===manifestSha256,'R44 Windows gate candidate mismatch');
+  insist(value.marker==='DEADBYTE V0.15.0 / R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS','R44 Windows gate marker mismatch');
+  insist(value.parent?.release_id===parent.release_id&&value.parent?.manifest_sha256===parent.manifest_sha256,'R44 Windows gate parent mismatch');
+  insist(value.parent?.generation_manifest_sha256===parent.generation_manifest_sha256,'R44 Windows gate parent generation mismatch');
+  insist(value.parent?.final_closure_sha256===PARENT_FINAL_CLOSURE&&value.parent?.final_closure_sha256===parent.closure_sha256,'R44 Windows gate parent final closure mismatch');
+  for(const key of ['skill_integrity','agent_backend_persistence','codex_protocol_contract','remote_device_identity','durable_job_supervisor','real_external_supervisor_smoke','full_regression_required']) {
+    insist(value.features?.[key]===true,`R44 Windows gate feature contract missing ${key}`);
+  }
+  return true;
+}
+function disarmFailClosed(){
+  const results=[];
+  for(const command of ['disarmdesktop','disarmautonomous','disarmcoding','disarmprocess','disarmhost']){
+    const result=spawnSync(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,command],
+      {encoding:'utf8',windowsHide:true,timeout:20000,env:windowsPowerShellEnvironment()});
+    results.push({command,status:result.status,signal:result.signal??null});
+  }
+  return results;
+}
+async function mirrorRoot(){
+  const pointer=await activePointer();
+  const policy=JSON.parse(await readFile(path.join(pointer.generation_root,'coding-policy.json'),'utf8'));
+  const raw=policy?.roots?.parity_scratch?.path??policy?.roots?.parity_scratch?.real_path;
+  if(typeof raw!=='string'||!path.isAbsolute(raw)) throw new Error('active generation parity_scratch root unavailable');
+  const stat=await lstat(raw);
+  if(!stat.isDirectory()||stat.isSymbolicLink()) throw new Error('parity_scratch root must be a real directory');
+  return raw;
+}
+async function writeMirror(manifestSha256,value){
+  const root=await mirrorRoot();
+  const file=path.join(root,`r44-final-${manifestSha256.slice(0,16)}.json`);
+  return atomicJson(file,value);
+}
+async function verifyInputs(manifestSha256){
+  insist(HEX64.test(manifestSha256??''),'R44 finalizer manifest invalid');
+  const manifestBytes=await readFile(path.join(packageRoot,'MANIFEST.SHA256'));
+  insist(sha256(manifestBytes)===manifestSha256,'R44 finalizer manifest drift');
+  const pkg=JSON.parse(await readFile(path.join(packageRoot,'package.json'),'utf8'));
+  insist(pkg?.name==='deadbyte-mcp'&&pkg?.version===EXPECTED_VERSION,'R44 finalizer package identity mismatch');
+  const parent=await verifyR44Parent(path.join(packageRoot,'R44-PARENT.json'));
+  const authorityStatus=currentAuthorityStatus();
+  validateFinalizerAuthorityStatus(authorityStatus);
+  const before=await activePointer();
+  insist(before.release_id===PARENT_RELEASE_ID&&before.manifest_sha256===PARENT_MANIFEST,'R44 finalizer must start from exact sealed R43 parent');
+  const windowsGatePath=path.join(stateRoot,'evidence','release',`r44-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  const windowsGateBytes=await readFile(windowsGatePath);
+  const windowsGate=JSON.parse(windowsGateBytes.toString('utf8').replace(/^\uFEFF/,''));
+  validateWindowsGateEvidence(windowsGate,manifestSha256,parent);
+  return {parent,before,authorityStatus,windowsGatePath,windowsGateFileSha256:sha256(windowsGateBytes)};
+}
+async function runWorker(manifestSha256,operationId){
+  const statePath=path.join(evidenceRoot,`${operationId}.json`);
+  let activation=null;
+  let parity=null;
+  try{
+    await atomicJson(statePath,{schema:'deadbyte.r44-finalization-state.v1',operation_id:operationId,status:'running',
+      manifest_sha256:manifestSha256,started_at_utc:new Date().toISOString()});
+    const inputs=await verifyInputs(manifestSha256);
+    activation=await runSlotUpdateCli(await activationArgs(manifestSha256),{stateRoot});
+    insist(activation?.pointer?.version===EXPECTED_VERSION&&activation.pointer.manifest_sha256===manifestSha256,'R44 activation result mismatch');
+    insist(activation?.final_authority?.process_armed===true&&activation?.final_authority?.coding_armed===true&&activation?.final_authority?.autonomous_armed===true,
+      'R44 activation must restore prior Process+Coding+Autonomous standing grants for detached parity');
+    insist(activation?.final_authority?.desktop_armed===false&&activation?.final_authority?.host_armed===false,
+      'R44 activation must keep Desktop+Host disarmed');
+
+    parity=await runReleaseParity(activation.receipt_path);
+    insist(parity?.evidence?.status==='passed'&&parity.evidence?.candidate?.manifest_sha256===manifestSha256,'R44 parity result mismatch');
+
+    const closure=await writeFinalClosure({parityPath:parity.evidence_path,activationPath:activation.receipt_path,
+      windowsGatePath:inputs.windowsGatePath});
+    const envelope=JSON.parse(await readFile(closure.path,'utf8'));
+    const verified=await verifyFinalClosureObject(envelope,{stateRoot});
+    insist(verified?.ok===true&&verified.status==='passed'&&verified.manifest_sha256===manifestSha256,'R44 independent final closure verification failed');
+
+    const pointer=await activePointer();
+    const result={schema:'deadbyte.r44-finalization-result.v1',status:'passed',verified:true,
+      completed_at_utc:new Date().toISOString(),release_id:pointer.release_id,version:pointer.version,
+      manifest_sha256:pointer.manifest_sha256,generation_manifest_sha256:pointer.generation_manifest_sha256,
+      activation_receipt_sha256:activation.receipt_sha256,
+      parity_sha256:parity.evidence_sha256,windows_gate_sha256:inputs.windowsGateFileSha256,
+      closure_file_sha256:closure.sha256,closure_sha256:closure.closure_sha256,
+      full_tool_count:verified.full_tool_count,compact_tool_count:verified.compact_tool_count,
+      parent_release_id:inputs.parent.release_id,parent_manifest_sha256:inputs.parent.manifest_sha256};
+    const mirror=await writeMirror(manifestSha256,result);
+    await atomicJson(statePath,{...result,operation_id:operationId,mirror_path:mirror.path,mirror_sha256:mirror.sha256,
+      activation_receipt_path:activation.receipt_path,parity_path:parity.evidence_path,closure_path:closure.path});
+    return result;
+  }catch(error){
+    let rollback=null;
+    try{
+      if(activation?.receipt_path){
+        const pointer=await activePointer().catch(()=>null);
+        if(pointer?.version===EXPECTED_VERSION&&pointer?.manifest_sha256===manifestSha256){
+          rollback=await runSlotUpdateCli(['--rollback-receipt',activation.receipt_path],{stateRoot});
+        }
+      }
+    }catch(rollbackError){rollback={error:String(rollbackError?.message??rollbackError)};}
+    const disarm=disarmFailClosed();
+    const failed={schema:'deadbyte.r44-finalization-result.v1',status:'failed',verified:false,
+      completed_at_utc:new Date().toISOString(),manifest_sha256:manifestSha256,
+      error:String(error?.message??error),rollback:rollback?{ok:rollback?.ok===true,error:rollback?.error??null}:null,disarm};
+    await atomicJson(statePath,{...failed,operation_id:operationId}).catch(()=>{});
+    await writeMirror(manifestSha256,failed).catch(()=>{});
+    throw error;
+  }
+}
+export async function scheduleFinalization(manifestSha256){
+  insist(HEX64.test(manifestSha256??''),'R44 finalizer manifest invalid');
+  const operationId=`r44-${manifestSha256.slice(0,16)}-${randomBytes(8).toString('hex')}`;
+  const statePath=path.join(evidenceRoot,`${operationId}.json`);
+  await atomicJson(statePath,{schema:'deadbyte.r44-finalization-state.v1',operation_id:operationId,status:'scheduled',
+    manifest_sha256:manifestSha256,scheduled_at_utc:new Date().toISOString()});
+  const child=spawn(process.execPath,[fileURLToPath(import.meta.url),manifestSha256,'--worker',operationId],{
+    cwd:packageRoot,detached:true,stdio:'ignore',windowsHide:true,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+  });
+  child.unref();
+  return {status:'scheduled',operation_id:operationId,state_path:statePath,manifest_sha256:manifestSha256,
+    execution_provider:'deadbyte_mcp',rdc_operation_count:0};
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  const [manifestSha256,flag,operationId]=process.argv.slice(2);
+  try{
+    if(flag==='--worker'){
+      insist(/^r44-[0-9a-f]{16}-[0-9a-f]{16}$/.test(operationId??''),'R44 finalizer worker operation id invalid');
+      await sleep(4000);
+      await runWorker(manifestSha256,operationId);
+    }else{
+      insist(flag===undefined&&operationId===undefined,'usage: node scripts/finalize-r44.mjs <manifest_sha256>');
+      console.log(JSON.stringify(await scheduleFinalization(manifestSha256)));
+    }
+  }catch(error){console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;}
+}

package/scripts/full-regression-r43.mjs

@@ -0,0 +1,20 @@
+import { spawnSync } from 'node:child_process';
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const testDir=path.join(root,'test');
+const files=(await readdir(testDir,{withFileTypes:true}))
+  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs'))
+  .map(entry=>path.join('test',entry.name))
+  .sort((a,b)=>a.localeCompare(b,'en'));
+if(files.length<1) throw new Error('R43 full regression found no test files');
+console.log(`R43-FULL-REGRESSION files=${files.length}`);
+const result=spawnSync(process.execPath,['--test',...files],{
+  cwd:root,stdio:'inherit',windowsHide:true,shell:false
+});
+if(result.error) throw result.error;
+if(result.signal) throw new Error(`R43 full regression terminated by ${result.signal}`);
+process.exitCode=Number.isInteger(result.status)?result.status:1;

package/scripts/full-regression-r44.mjs

@@ -0,0 +1,20 @@
+import { spawnSync } from 'node:child_process';
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const testDir=path.join(root,'test');
+const files=(await readdir(testDir,{withFileTypes:true}))
+  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs'))
+  .map(entry=>path.join('test',entry.name))
+  .sort((a,b)=>a.localeCompare(b,'en'));
+if(files.length<1) throw new Error('R44 full regression found no test files');
+console.log(`R44-FULL-REGRESSION files=${files.length}`);
+const result=spawnSync(process.execPath,['--test',...files],{
+  cwd:root,stdio:'inherit',windowsHide:true,shell:false
+});
+if(result.error) throw result.error;
+if(result.signal) throw new Error(`R44 full regression terminated by ${result.signal}`);
+process.exitCode=Number.isInteger(result.status)?result.status:1;

package/scripts/gate-windows-r43.ps1

@@ -0,0 +1,36 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+function Invoke-GateStep {
+    param([Parameter(Mandatory = $true)][string]$Name,[Parameter(Mandatory = $true)][string[]]$NpmArgs)
+    Write-Host "==== $Name ===="
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE V0.14.1 / R43 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+Invoke-GateStep -Name 'r43-parent-verify' -NpmArgs @('run','r43:parent:verify')
+Invoke-GateStep -Name 'containment-build' -NpmArgs @('run','containment:build')
+Invoke-GateStep -Name 'process-policy-refresh' -NpmArgs @('run','process:policy:refresh')
+Invoke-GateStep -Name 'desktop-policy-refresh' -NpmArgs @('run','desktop:policy:refresh')
+Invoke-GateStep -Name 'release-manifest-write' -NpmArgs @('run','manifest:write')
+Invoke-GateStep -Name 'release-manifest' -NpmArgs @('run','manifest:verify')
+Write-Host '==== r43-hardening-focused ===='
+& powershell.exe -NoProfile -ExecutionPolicy Bypass -File (Join-Path $PSScriptRoot 'release-parity-tests-r43.ps1')
+if ($LASTEXITCODE -ne 0) { throw "DEADBYTE V0.14.1 / R43 gate failed at r43-hardening-focused with exit code $LASTEXITCODE" }
+Invoke-GateStep -Name 'full-regression' -NpmArgs @('run','r43:full:test')
+Invoke-GateStep -Name 'mcp-smoke' -NpmArgs @('run','mcp:smoke')
+Invoke-GateStep -Name 'mcp-agent-smoke' -NpmArgs @('run','mcp:agent:smoke')
+Invoke-GateStep -Name 'mcp-coding-smoke' -NpmArgs @('run','mcp:coding:smoke')
+Invoke-GateStep -Name 'mcp-machine-fs-smoke' -NpmArgs @('run','mcp:machine-fs:smoke')
+Invoke-GateStep -Name 'mcp-observation-smoke' -NpmArgs @('run','mcp:observation:smoke')
+Invoke-GateStep -Name 'mcp-process-smoke' -NpmArgs @('run','mcp:process:smoke')
+Invoke-GateStep -Name 'mcp-autonomous-smoke' -NpmArgs @('run','mcp:autonomous:smoke')
+Invoke-GateStep -Name 'tunnel-stdio-compat-smoke' -NpmArgs @('run','mcp:tunnel-compat:smoke')
+Invoke-GateStep -Name 'mcp-host-smoke' -NpmArgs @('run','mcp:host:smoke')
+Invoke-GateStep -Name 'authority-smoke' -NpmArgs @('run','authority:smoke')
+Invoke-GateStep -Name 'containment-smoke' -NpmArgs @('run','containment:smoke')
+Invoke-GateStep -Name 'contained-smoke' -NpmArgs @('run','contained:smoke')
+Invoke-GateStep -Name 'mcp-contained-smoke' -NpmArgs @('run','mcp:contained:smoke')
+Invoke-GateStep -Name 'release-manifest-final' -NpmArgs @('run','manifest:verify')
+Write-Host '==== windows-gate-evidence ===='
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r43.mjs')
+if ($LASTEXITCODE -ne 0) { throw "DEADBYTE V0.14.1 / R43 gate failed at windows-gate-evidence with exit code $LASTEXITCODE" }
+Write-Host '==== DEADBYTE V0.14.1 / R43 AUTHORITY HARDENING WINDOWS BATCH GATE: PASS ===='

package/scripts/gate-windows-r44.ps1

@@ -0,0 +1,36 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+function Invoke-GateStep {
+    param([Parameter(Mandatory = $true)][string]$Name,[Parameter(Mandatory = $true)][string[]]$NpmArgs)
+    Write-Host "==== $Name ===="
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) { throw "DEADBYTE V0.15.0 / R44 gate failed at $Name with exit code $LASTEXITCODE" }
+}
+Invoke-GateStep -Name 'r44-parent-verify' -NpmArgs @('run','r44:parent:verify')
+Invoke-GateStep -Name 'containment-build' -NpmArgs @('run','containment:build')
+Invoke-GateStep -Name 'process-policy-refresh' -NpmArgs @('run','process:policy:refresh')
+Invoke-GateStep -Name 'desktop-policy-refresh' -NpmArgs @('run','desktop:policy:refresh')
+Invoke-GateStep -Name 'release-manifest-write' -NpmArgs @('run','manifest:write')
+Invoke-GateStep -Name 'release-manifest' -NpmArgs @('run','manifest:verify')
+Write-Host '==== r44-feature-focused ===='
+& powershell.exe -NoProfile -ExecutionPolicy Bypass -File (Join-Path $PSScriptRoot 'release-parity-tests-r44.ps1')
+if ($LASTEXITCODE -ne 0) { throw "DEADBYTE V0.15.0 / R44 gate failed at r44-feature-focused with exit code $LASTEXITCODE" }
+Invoke-GateStep -Name 'full-regression' -NpmArgs @('run','r44:full:test')
+Invoke-GateStep -Name 'mcp-smoke' -NpmArgs @('run','mcp:smoke')
+Invoke-GateStep -Name 'mcp-agent-smoke' -NpmArgs @('run','mcp:agent:smoke')
+Invoke-GateStep -Name 'mcp-coding-smoke' -NpmArgs @('run','mcp:coding:smoke')
+Invoke-GateStep -Name 'mcp-machine-fs-smoke' -NpmArgs @('run','mcp:machine-fs:smoke')
+Invoke-GateStep -Name 'mcp-observation-smoke' -NpmArgs @('run','mcp:observation:smoke')
+Invoke-GateStep -Name 'mcp-process-smoke' -NpmArgs @('run','mcp:process:smoke')
+Invoke-GateStep -Name 'mcp-autonomous-smoke' -NpmArgs @('run','mcp:autonomous:smoke')
+Invoke-GateStep -Name 'tunnel-stdio-compat-smoke' -NpmArgs @('run','mcp:tunnel-compat:smoke')
+Invoke-GateStep -Name 'mcp-host-smoke' -NpmArgs @('run','mcp:host:smoke')
+Invoke-GateStep -Name 'authority-smoke' -NpmArgs @('run','authority:smoke')
+Invoke-GateStep -Name 'containment-smoke' -NpmArgs @('run','containment:smoke')
+Invoke-GateStep -Name 'contained-smoke' -NpmArgs @('run','contained:smoke')
+Invoke-GateStep -Name 'mcp-contained-smoke' -NpmArgs @('run','mcp:contained:smoke')
+Invoke-GateStep -Name 'release-manifest-final' -NpmArgs @('run','manifest:verify')
+Write-Host '==== windows-gate-evidence ===='
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r44.mjs')
+if ($LASTEXITCODE -ne 0) { throw "DEADBYTE V0.15.0 / R44 gate failed at windows-gate-evidence with exit code $LASTEXITCODE" }
+Write-Host '==== DEADBYTE V0.15.0 / R44 REMOTE AGENT SKILL WINDOWS BATCH GATE: PASS ===='

package/scripts/release-parity-r43.mjs

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