deadbyte-mcp 0.11.3 → 0.13.0

package/scripts/build-containment.ps1

@@ -1,6 +1,16 @@
 $ErrorActionPreference = 'Stop'
 Set-StrictMode -Version Latest
 
+function Get-Sha256Hex {
+    param([Parameter(Mandatory=$true)][string]$Path)
+    $Stream = [System.IO.File]::OpenRead([System.IO.Path]::GetFullPath($Path))
+    try {
+        $Hasher = [System.Security.Cryptography.SHA256]::Create()
+        try { return ([System.BitConverter]::ToString($Hasher.ComputeHash($Stream))).Replace('-', '').ToLowerInvariant() }
+        finally { $Hasher.Dispose() }
+    } finally { $Stream.Dispose() }
+}
+
 $Root = Split-Path -Parent $PSScriptRoot
 $Bin = Join-Path $Root 'bin'
 $Native = Join-Path $Root 'native'
@@ -209,19 +219,19 @@ if (-not (Test-Path -LiteralPath $ContainedReverseWorkerExe)) { throw "contained
 if (-not (Test-Path -LiteralPath $TunnelHostExe)) { throw "named tunnel host executable missing after successful compile: $TunnelHostExe" }
 if (-not (Test-Path -LiteralPath $ProcessHostExe)) { throw "process host executable missing after successful compile: $ProcessHostExe" }
 
-$LauncherHash = (Get-FileHash -LiteralPath $LauncherExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$ProbeHash = (Get-FileHash -LiteralPath $ProbeExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$BootstrapKernelHash = (Get-FileHash -LiteralPath $BootstrapKernelExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$BootstrapAdvapiHash = (Get-FileHash -LiteralPath $BootstrapAdvapiExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$StageLauncherHash = (Get-FileHash -LiteralPath $StageLauncherExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$BootstrapExitHash = (Get-FileHash -LiteralPath $BootstrapExitExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$ChildControlStageHash = (Get-FileHash -LiteralPath $ChildControlStageExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$ChildControlProbeHash = (Get-FileHash -LiteralPath $ChildControlProbeExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$ContainedLauncherHash = (Get-FileHash -LiteralPath $ContainedLauncherExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$ContainedWorkerHash = (Get-FileHash -LiteralPath $ContainedWorkerExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$ContainedReverseWorkerHash = (Get-FileHash -LiteralPath $ContainedReverseWorkerExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$TunnelHostHash = (Get-FileHash -LiteralPath $TunnelHostExe -Algorithm SHA256).Hash.ToLowerInvariant()
-$ProcessHostHash = (Get-FileHash -LiteralPath $ProcessHostExe -Algorithm SHA256).Hash.ToLowerInvariant()
+$LauncherHash = Get-Sha256Hex -Path $LauncherExe
+$ProbeHash = Get-Sha256Hex -Path $ProbeExe
+$BootstrapKernelHash = Get-Sha256Hex -Path $BootstrapKernelExe
+$BootstrapAdvapiHash = Get-Sha256Hex -Path $BootstrapAdvapiExe
+$StageLauncherHash = Get-Sha256Hex -Path $StageLauncherExe
+$BootstrapExitHash = Get-Sha256Hex -Path $BootstrapExitExe
+$ChildControlStageHash = Get-Sha256Hex -Path $ChildControlStageExe
+$ChildControlProbeHash = Get-Sha256Hex -Path $ChildControlProbeExe
+$ContainedLauncherHash = Get-Sha256Hex -Path $ContainedLauncherExe
+$ContainedWorkerHash = Get-Sha256Hex -Path $ContainedWorkerExe
+$ContainedReverseWorkerHash = Get-Sha256Hex -Path $ContainedReverseWorkerExe
+$TunnelHostHash = Get-Sha256Hex -Path $TunnelHostExe
+$ProcessHostHash = Get-Sha256Hex -Path $ProcessHostExe
 
 $WorkerRegistryLines = @(
     'schema=deadbyte.worker-registry.v1',
@@ -239,7 +249,7 @@ $WorkerRegistryLines = @(
 )
 $Utf8NoBom = New-Object System.Text.UTF8Encoding($false)
 [System.IO.File]::WriteAllText($WorkerRegistryManifest, (($WorkerRegistryLines -join "`n") + "`n"), $Utf8NoBom)
-$WorkerRegistryManifestHash = (Get-FileHash -LiteralPath $WorkerRegistryManifest -Algorithm SHA256).Hash.ToLowerInvariant()
+$WorkerRegistryManifestHash = Get-Sha256Hex -Path $WorkerRegistryManifest
 
 [ordered]@{
     status = 'built'

package/scripts/build-desktop-r40.ps1

@@ -0,0 +1,112 @@
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+function Get-Sha256Hex {
+  param([Parameter(Mandatory=$true)][string]$Path)
+  $Stream=[System.IO.File]::OpenRead([System.IO.Path]::GetFullPath($Path))
+  try{$Hasher=[System.Security.Cryptography.SHA256]::Create();try{return ([System.BitConverter]::ToString($Hasher.ComputeHash($Stream))).Replace('-','').ToLowerInvariant()}finally{$Hasher.Dispose()}}
+  finally{$Stream.Dispose()}
+}
+
+$Root=Split-Path -Parent $PSScriptRoot
+$Src=Join-Path $Root 'native\deadbyte-desktop-observer.cpp'
+$InputSrc=Join-Path $Root 'native\deadbyte-desktop-input.cpp'
+$UiaSrc=Join-Path $Root 'native\deadbyte-desktop-uia.cpp'
+$Bin=Join-Path $Root 'bin'
+$Exe=Join-Path $Bin 'deadbyte-desktop-observer-r40.exe'
+$Obj=Join-Path $Bin 'deadbyte-desktop-observer-r40.obj'
+$InputExe=Join-Path $Bin 'deadbyte-desktop-input-r40.exe'
+$InputObj=Join-Path $Bin 'deadbyte-desktop-input-r40.obj'
+$UiaExe=Join-Path $Bin 'deadbyte-desktop-uia-r40.exe'
+$UiaObj=Join-Path $Bin 'deadbyte-desktop-uia-r40.obj'
+New-Item -ItemType Directory -Force -Path $Bin | Out-Null
+
+$vswhere='C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe'
+if(-not (Test-Path -LiteralPath $vswhere)){throw 'vswhere.exe not found'}
+$install=(& $vswhere -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath | Select-Object -First 1)
+if(-not $install){throw 'MSVC x64 C++ toolchain not found'}
+$dev=Join-Path $install 'Common7\Tools\VsDevCmd.bat'
+if(-not (Test-Path -LiteralPath $dev)){throw "VsDevCmd.bat missing: $dev"}
+$cmd=if($env:ComSpec){$env:ComSpec}else{Join-Path $env:SystemRoot 'System32\cmd.exe'}
+
+Remove-Item -Force -ErrorAction SilentlyContinue $Exe,$Obj,$InputExe,$InputObj,$UiaExe,$UiaObj
+$common='/nologo /std:c++17 /permissive- /W4 /WX /O2 /MT /EHsc /guard:cf /diagnostics:caret /FC /utf-8 /Brepro /DUNICODE /D_UNICODE /D_WIN32_WINNT=0x0A00 /DWINVER=0x0A00'
+$compile='cl {0} "{1}" /Fo:"{2}" /Fe:"{3}" user32.lib gdi32.lib /link /Brepro /INCREMENTAL:NO' -f $common,$Src,$Obj,$Exe
+$line='call "{0}" -no_logo -arch=x64 -host_arch=x64 && {1}' -f $dev,$compile
+$out=& $cmd /d /s /c $line 2>&1
+$exit=$LASTEXITCODE
+$out | ForEach-Object { Write-Host ([string]$_) }
+if($exit -ne 0){throw "desktop observer compile failed exit=$exit"}
+if(-not (Test-Path -LiteralPath $Exe -PathType Leaf)){throw 'desktop observer exe missing after compile'}
+
+$inputCompile='cl {0} "{1}" /Fo:"{2}" /Fe:"{3}" user32.lib /link /Brepro /INCREMENTAL:NO' -f $common,$InputSrc,$InputObj,$InputExe
+$inputLine='call "{0}" -no_logo -arch=x64 -host_arch=x64 && {1}' -f $dev,$inputCompile
+$inputOut=& $cmd /d /s /c $inputLine 2>&1
+$inputExit=$LASTEXITCODE
+$inputOut | ForEach-Object { Write-Host ([string]$_) }
+if($inputExit -ne 0){throw "desktop input compile failed exit=$inputExit"}
+if(-not (Test-Path -LiteralPath $InputExe -PathType Leaf)){throw 'desktop input exe missing after compile'}
+
+$uiaCompile='cl {0} "{1}" /Fo:"{2}" /Fe:"{3}" user32.lib ole32.lib oleaut32.lib uiautomationcore.lib /link /Brepro /INCREMENTAL:NO' -f $common,$UiaSrc,$UiaObj,$UiaExe
+$uiaLine='call "{0}" -no_logo -arch=x64 -host_arch=x64 && {1}' -f $dev,$uiaCompile
+$uiaOut=& $cmd /d /s /c $uiaLine 2>&1
+$uiaExit=$LASTEXITCODE
+$uiaOut | ForEach-Object { Write-Host ([string]$_) }
+if($uiaExit -ne 0){throw "desktop UIA compile failed exit=$uiaExit"}
+if(-not (Test-Path -LiteralPath $UiaExe -PathType Leaf)){throw 'desktop UIA exe missing after compile'}
+
+$selfTest=& $InputExe --selftest 2>&1
+$selfExit=$LASTEXITCODE
+$selfTest | ForEach-Object { Write-Host ([string]$_) }
+if($selfExit -ne 0){throw "desktop input selftest failed exit=$selfExit"}
+if(-not (($selfTest -join [Environment]::NewLine) -match '"status":"passed"')){throw 'desktop input selftest did not report pass'}
+
+$uiaSelfTest=& $UiaExe --selftest 2>&1
+$uiaSelfExit=$LASTEXITCODE
+$uiaSelfTest | ForEach-Object { Write-Host ([string]$_) }
+if($uiaSelfExit -ne 0){throw "desktop UIA selftest failed exit=$uiaSelfExit"}
+if(-not (($uiaSelfTest -join [Environment]::NewLine) -match '"status":"passed"')){throw 'desktop UIA selftest did not report pass'}
+
+$depLine='call "{0}" -no_logo -arch=x64 -host_arch=x64 && dumpbin /nologo /dependents "{1}"' -f $dev,$Exe
+$deps=& $cmd /d /s /c $depLine 2>&1
+$depExit=$LASTEXITCODE
+$deps | ForEach-Object { Write-Host ([string]$_) }
+if($depExit -ne 0){throw "observer dumpbin failed exit=$depExit"}
+
+$inputDepLine='call "{0}" -no_logo -arch=x64 -host_arch=x64 && dumpbin /nologo /dependents "{1}"' -f $dev,$InputExe
+$inputDeps=& $cmd /d /s /c $inputDepLine 2>&1
+$inputDepExit=$LASTEXITCODE
+$inputDeps | ForEach-Object { Write-Host ([string]$_) }
+if($inputDepExit -ne 0){throw "input dumpbin failed exit=$inputDepExit"}
+
+$uiaDepLine='call "{0}" -no_logo -arch=x64 -host_arch=x64 && dumpbin /nologo /dependents "{1}"' -f $dev,$UiaExe
+$uiaDeps=& $cmd /d /s /c $uiaDepLine 2>&1
+$uiaDepExit=$LASTEXITCODE
+$uiaDeps | ForEach-Object { Write-Host ([string]$_) }
+if($uiaDepExit -ne 0){throw "UIA dumpbin failed exit=$uiaDepExit"}
+
+[pscustomobject]@{
+ status='built'
+ observer=[ordered]@{
+  source_sha256=Get-Sha256Hex -Path $Src
+  exe=$Exe
+  exe_sha256=Get-Sha256Hex -Path $Exe
+  obj_sha256=Get-Sha256Hex -Path $Obj
+  dependencies=@($deps | ForEach-Object {[string]$_})
+ }
+ input=[ordered]@{
+  source_sha256=Get-Sha256Hex -Path $InputSrc
+  exe=$InputExe
+  exe_sha256=Get-Sha256Hex -Path $InputExe
+  obj_sha256=Get-Sha256Hex -Path $InputObj
+  dependencies=@($inputDeps | ForEach-Object {[string]$_})
+  selftest=@($selfTest | ForEach-Object {[string]$_})
+ }
+ uia=[ordered]@{
+  source_sha256=Get-Sha256Hex -Path $UiaSrc
+  exe=$UiaExe
+  exe_sha256=Get-Sha256Hex -Path $UiaExe
+  obj_sha256=Get-Sha256Hex -Path $UiaObj
+  dependencies=@($uiaDeps | ForEach-Object {[string]$_})
+  selftest=@($uiaSelfTest | ForEach-Object {[string]$_})
+ }
+}|ConvertTo-Json -Depth 6

package/scripts/deferred-slot-operation-r40.mjs

@@ -0,0 +1,126 @@
+import { createHash, createPublicKey, randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, realpath, 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, runSlotUpdateCli, verifySlotUpdateEnvelope } from '../src/runtime-update.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const RECEIPT_ID=/^r27-[A-Za-z0-9-]+$/;
+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','deferred-slot-operations');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const atomicJson=async(file,value)=>{
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+  await writeFile(temp,`${JSON.stringify(value,null,2)}\n`,{flag:'wx'});
+  await import('node:fs/promises').then(fs=>fs.rename(temp,file));
+};
+function activationArgs(manifestSha){
+  if(!HEX64.test(manifestSha??'')) throw new Error('activate requires one lowercase manifest SHA-256');
+  return ['--stage',packageRoot,'--development-root',packageRoot,'--expected-version','0.12.0',
+    '--expected-manifest',manifestSha,'--process-policy',path.join(packageRoot,'controller','deadbyte-process-policy.json'),
+    '--process-policy-sha256',null,'--desktop-policy',path.join(packageRoot,'controller','deadbyte-desktop-policy.json'),
+    '--desktop-policy-sha256',null,'--semantic-lsp-config',path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json'),
+    '--semantic-lsp-config-sha256',null,'--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor'];
+}
+async function bridgeBootstrapArgs(explicitBridgeRoot=null,explicitBridgeSha256=null){
+  const hasRoot=typeof explicitBridgeRoot==='string'&&explicitBridgeRoot.length>0;
+  const hasSha=typeof explicitBridgeSha256==='string'&&explicitBridgeSha256.length>0;
+  if(hasRoot!==hasSha) throw new Error('bridge override requires exact root + SHA pair');
+  let bridgeRootRaw,expectedSha256=null;
+  if(hasRoot){
+    if(!path.isAbsolute(explicitBridgeRoot)||!HEX64.test(explicitBridgeSha256)) throw new Error('bridge override requires exact root + SHA pair');
+    bridgeRootRaw=explicitBridgeRoot;expectedSha256=explicitBridgeSha256;
+  }else{
+    const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+    const config=await loadPowerShellDataFile(pointer.config_path);
+    bridgeRootRaw=config?.Bridge?.WorkingDirectory;
+    if(typeof bridgeRootRaw!=='string'||!path.isAbsolute(bridgeRootRaw)) throw new Error('active controller Bridge.WorkingDirectory must be absolute');
+  }
+  const bridgeRoot=await realpath(path.resolve(bridgeRootRaw));
+  const packageFile=path.join(bridgeRoot,'package.json');
+  const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs');
+  const pkg=JSON.parse(await readFile(packageFile,'utf8'));
+  if(pkg?.name!=='deadbyte-chatgpt-bridge') throw new Error('active Bridge package identity mismatch');
+  const scriptSha256=sha256(await readFile(bridgeScript));
+  if(expectedSha256&&scriptSha256!==expectedSha256) throw new Error('bridge override SHA-256 mismatch');
+  return ['--bridge-root',bridgeRoot,'--bridge-script-sha256',scriptSha256];
+}
+async function rollbackArgs(receiptPath){
+  const resolved=await realpath(path.resolve(receiptPath));
+  const allowed=path.join(stateRoot,'evidence','updates')+path.sep;
+  if(!resolved.startsWith(allowed)||path.basename(resolved).toLowerCase()!=='receipt.json'||!RECEIPT_ID.test(path.basename(path.dirname(resolved)))) {
+    throw new Error('rollback receipt must be one signed activation receipt under the update evidence store');
+  }
+  const envelope=JSON.parse(await readFile(resolved,'utf8'));
+  const publicKey=createPublicKey(await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  if(!verifySlotUpdateEnvelope(envelope,publicKey)||envelope.body?.rollback_performed!==false) throw new Error('rollback activation receipt verification failed');
+  const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  if(pointer.release_id!==envelope.body?.active_pointer?.release_id||pointer.generation_root!==envelope.body?.active_pointer?.generation_root) {
+    throw new Error('rollback receipt does not identify the active release generation');
+  }
+  return ['--rollback-receipt',resolved];
+}
+async function normalizedArgs(mode,value,{explicitBridgeRoot=null,explicitBridgeSha256=null}={}){
+  if(mode==='activate'){
+    const args=activationArgs(value);
+    args[args.indexOf('--process-policy-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-process-policy.json')));
+    args[args.indexOf('--desktop-policy-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-desktop-policy.json')));
+    args[args.indexOf('--semantic-lsp-config-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json')));
+    args.push(...await bridgeBootstrapArgs(explicitBridgeRoot,explicitBridgeSha256));
+    return args;
+  }
+  if(mode==='rollback'){
+    if(explicitBridgeRoot||explicitBridgeSha256) throw new Error('rollback does not accept bridge override');
+    return rollbackArgs(value);
+  }
+  throw new Error("operation must be exactly 'activate' or 'rollback'");
+}
+const rawArgs=process.argv.slice(2);
+const mode=rawArgs[0],value=rawArgs[1];
+if(!value||!['activate','rollback'].includes(mode)) throw new Error('usage: deferred-slot-operation-r40.mjs <activate manifest_sha256|rollback activation_receipt> [--bridge-root ABS --bridge-script-sha256 HEX64]');
+let cursor=2,explicitBridgeRoot=null,explicitBridgeSha256=null;
+if(rawArgs[cursor]==='--bridge-root'){
+  explicitBridgeRoot=rawArgs[cursor+1]??null;
+  if(rawArgs[cursor+2]!=='--bridge-script-sha256') throw new Error('bridge override requires exact root + SHA pair');
+  explicitBridgeSha256=rawArgs[cursor+3]??null;cursor+=4;
+}
+let workerFlag=null,operationIdArg=null;
+if(rawArgs[cursor]==='--worker'){workerFlag='--worker';operationIdArg=rawArgs[cursor+1]??null;cursor+=2;}
+if(cursor!==rawArgs.length) throw new Error('deferred slot operation arguments invalid');
+if((explicitBridgeRoot===null)!==(explicitBridgeSha256===null)) throw new Error('bridge override requires exact root + SHA pair');
+if(mode==='rollback'&&(explicitBridgeRoot||explicitBridgeSha256)) throw new Error('rollback does not accept bridge override');
+if(workerFlag==='--worker'){
+  if(!/^[0-9a-f]{32}$/.test(operationIdArg??'')) throw new Error('deferred worker operation id invalid');
+  const statePath=path.join(evidenceRoot,`${operationIdArg}.json`);
+  await new Promise(resolve=>setTimeout(resolve,4000));
+  await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'running',started_at_utc:new Date().toISOString(),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  try{
+    const args=await normalizedArgs(mode,value,{explicitBridgeRoot,explicitBridgeSha256});
+    const result=await runSlotUpdateCli(args,{stateRoot});
+    await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'completed',
+      completed_at_utc:new Date().toISOString(),receipt_path:result.receipt_path,receipt_sha256:result.receipt_sha256,
+      active_release:result.pointer.release_id,generation_root:result.pointer.generation_root,bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  }catch(error){
+    await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'failed',
+      completed_at_utc:new Date().toISOString(),error:String(error?.message??error),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+    process.exitCode=1;
+  }
+}else{
+  const operationId=randomBytes(16).toString('hex');
+  const statePath=path.join(evidenceRoot,`${operationId}.json`);
+  await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationId,mode,state:'scheduled',scheduled_at_utc:new Date().toISOString(),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  const workerArgs=[fileURLToPath(import.meta.url),mode,value];
+  if(explicitBridgeRoot) workerArgs.push('--bridge-root',explicitBridgeRoot,'--bridge-script-sha256',explicitBridgeSha256);
+  workerArgs.push('--worker',operationId);
+  const child=spawn(process.execPath,workerArgs,{
+    cwd:packageRoot,detached:true,stdio:'ignore',windowsHide:true,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+  });
+  child.unref();
+  console.log(JSON.stringify({status:'scheduled',operation_id:operationId,mode,state_path:statePath,execution_provider:'deadbyte_mcp',rdc_operation_count:0,bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256}));
+}

package/scripts/deferred-slot-operation-r41.mjs

@@ -0,0 +1,127 @@
+import { createHash, createPublicKey, randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, realpath, 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, runSlotUpdateCli, verifySlotUpdateEnvelope } from '../src/runtime-update.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const RECEIPT_ID=/^r27-[A-Za-z0-9-]+$/;
+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','deferred-slot-operations');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const atomicJson=async(file,value)=>{
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+  await writeFile(temp,`${JSON.stringify(value,null,2)}\n`,{flag:'wx'});
+  await import('node:fs/promises').then(fs=>fs.rename(temp,file));
+};
+function activationArgs(manifestSha){
+  if(!HEX64.test(manifestSha??'')) throw new Error('activate requires one lowercase manifest SHA-256');
+  return ['--stage',packageRoot,'--development-root',packageRoot,'--expected-version','0.13.0',
+    '--expected-manifest',manifestSha,'--process-policy',path.join(packageRoot,'controller','deadbyte-process-policy.json'),
+    '--process-policy-sha256',null,'--desktop-policy',path.join(packageRoot,'controller','deadbyte-desktop-policy.json'),
+    '--desktop-policy-sha256',null,'--semantic-lsp-config',path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json'),
+    '--semantic-lsp-config-sha256',null,'--enable-machine-fs','--enable-observation','--enable-desktop','--enable-autonomous-supervisor'];
+}
+async function bridgeBootstrapArgs(explicitBridgeRoot=null,explicitBridgeSha256=null){
+  const hasRoot=typeof explicitBridgeRoot==='string'&&explicitBridgeRoot.length>0;
+  const hasSha=typeof explicitBridgeSha256==='string'&&explicitBridgeSha256.length>0;
+  if(hasRoot!==hasSha) throw new Error('bridge override requires exact root + SHA pair');
+  let bridgeRootRaw,expectedSha256=null;
+  if(hasRoot){
+    if(!path.isAbsolute(explicitBridgeRoot)||!HEX64.test(explicitBridgeSha256)) throw new Error('bridge override requires exact root + SHA pair');
+    bridgeRootRaw=explicitBridgeRoot;expectedSha256=explicitBridgeSha256;
+  }else{
+    const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+    const config=await loadPowerShellDataFile(pointer.config_path);
+    bridgeRootRaw=config?.Bridge?.WorkingDirectory;
+    if(typeof bridgeRootRaw!=='string'||!path.isAbsolute(bridgeRootRaw)) throw new Error('active controller Bridge.WorkingDirectory must be absolute');
+  }
+  const bridgeRoot=await realpath(path.resolve(bridgeRootRaw));
+  const packageFile=path.join(bridgeRoot,'package.json');
+  const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs');
+  const pkg=JSON.parse(await readFile(packageFile,'utf8'));
+  if(pkg?.name!=='deadbyte-chatgpt-bridge') throw new Error('active Bridge package identity mismatch');
+  const scriptSha256=sha256(await readFile(bridgeScript));
+  if(expectedSha256&&scriptSha256!==expectedSha256) throw new Error('bridge override SHA-256 mismatch');
+  return ['--bridge-root',bridgeRoot,'--bridge-script-sha256',scriptSha256];
+}
+async function rollbackArgs(receiptPath){
+  const resolved=await realpath(path.resolve(receiptPath));
+  const allowed=path.join(stateRoot,'evidence','updates')+path.sep;
+  if(!resolved.startsWith(allowed)||path.basename(resolved).toLowerCase()!=='receipt.json'||!RECEIPT_ID.test(path.basename(path.dirname(resolved)))) {
+    throw new Error('rollback receipt must be one signed activation receipt under the update evidence store');
+  }
+  const envelope=JSON.parse(await readFile(resolved,'utf8'));
+  const publicKey=createPublicKey(await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  if(!verifySlotUpdateEnvelope(envelope,publicKey)||envelope.body?.rollback_performed!==false) throw new Error('rollback activation receipt verification failed');
+  const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  if(pointer.release_id!==envelope.body?.active_pointer?.release_id||pointer.generation_root!==envelope.body?.active_pointer?.generation_root) {
+    throw new Error('rollback receipt does not identify the active release generation');
+  }
+  return ['--rollback-receipt',resolved];
+}
+async function normalizedArgs(mode,value,{explicitBridgeRoot=null,explicitBridgeSha256=null}={}){
+  if(mode==='activate'){
+    const args=activationArgs(value);
+    args[args.indexOf('--process-policy-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-process-policy.json')));
+    args[args.indexOf('--desktop-policy-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-desktop-policy.json')));
+    args[args.indexOf('--semantic-lsp-config-sha256')+1]=sha256(await readFile(path.join(packageRoot,'controller','deadbyte-semantic-lsp-config.json')));
+    args.push(...await bridgeBootstrapArgs(explicitBridgeRoot,explicitBridgeSha256));
+    return args;
+  }
+  if(mode==='rollback'){
+    if(explicitBridgeRoot||explicitBridgeSha256) throw new Error('rollback does not accept bridge override');
+    return rollbackArgs(value);
+  }
+  throw new Error("operation must be exactly 'activate' or 'rollback'");
+}
+const rawArgs=process.argv.slice(2);
+const mode=rawArgs[0],value=rawArgs[1];
+if(!value||!['activate','rollback'].includes(mode)) throw new Error('usage: deferred-slot-operation-r41.mjs <activate manifest_sha256|rollback activation_receipt> [--bridge-root ABS --bridge-script-sha256 HEX64]');
+let cursor=2,explicitBridgeRoot=null,explicitBridgeSha256=null;
+if(rawArgs[cursor]==='--bridge-root'){
+  explicitBridgeRoot=rawArgs[cursor+1]??null;
+  if(rawArgs[cursor+2]!=='--bridge-script-sha256') throw new Error('bridge override requires exact root + SHA pair');
+  explicitBridgeSha256=rawArgs[cursor+3]??null;cursor+=4;
+}
+let workerFlag=null,operationIdArg=null;
+if(rawArgs[cursor]==='--worker'){workerFlag='--worker';operationIdArg=rawArgs[cursor+1]??null;cursor+=2;}
+if(cursor!==rawArgs.length) throw new Error('deferred slot operation arguments invalid');
+if((explicitBridgeRoot===null)!==(explicitBridgeSha256===null)) throw new Error('bridge override requires exact root + SHA pair');
+if(mode==='rollback'&&(explicitBridgeRoot||explicitBridgeSha256)) throw new Error('rollback does not accept bridge override');
+if(workerFlag==='--worker'){
+  if(!/^[0-9a-f]{32}$/.test(operationIdArg??'')) throw new Error('deferred worker operation id invalid');
+  const statePath=path.join(evidenceRoot,`${operationIdArg}.json`);
+  await new Promise(resolve=>setTimeout(resolve,4000));
+  await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'running',started_at_utc:new Date().toISOString(),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  try{
+    const args=await normalizedArgs(mode,value,{explicitBridgeRoot,explicitBridgeSha256});
+    const result=await runSlotUpdateCli(args,{stateRoot});
+    await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'completed',
+      completed_at_utc:new Date().toISOString(),receipt_path:result.receipt_path,receipt_sha256:result.receipt_sha256,
+      active_release:result.pointer.release_id,generation_root:result.pointer.generation_root,bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  }catch(error){
+    await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationIdArg,mode,state:'failed',
+      completed_at_utc:new Date().toISOString(),error:String(error?.message??error),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+    process.exitCode=1;
+  }
+}else{
+  const operationId=randomBytes(16).toString('hex');
+  const statePath=path.join(evidenceRoot,`${operationId}.json`);
+  await atomicJson(statePath,{schema:'deadbyte.deferred-slot-operation.v1',operation_id:operationId,mode,state:'scheduled',scheduled_at_utc:new Date().toISOString(),bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256});
+  const workerArgs=[fileURLToPath(import.meta.url),mode,value];
+  if(explicitBridgeRoot) workerArgs.push('--bridge-root',explicitBridgeRoot,'--bridge-script-sha256',explicitBridgeSha256);
+  workerArgs.push('--worker',operationId);
+  const child=spawn(process.execPath,workerArgs,{
+    cwd:packageRoot,detached:true,stdio:'ignore',windowsHide:true,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
+  });
+  child.unref();
+  console.log(JSON.stringify({status:'scheduled',operation_id:operationId,mode,state_path:statePath,execution_provider:'deadbyte_mcp',rdc_operation_count:0,bridge_root:explicitBridgeRoot,bridge_script_sha256:explicitBridgeSha256}));
+}
+

package/scripts/final-closure-r40.mjs

@@ -0,0 +1,114 @@
+import { createHash, createPrivateKey, createPublicKey, sign as cryptoSign } from 'node:crypto';
+import { lstat, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { probeR40FullSurface } from '../src/r40-full-surface-probe.mjs';
+import { probeR40CompactDisarmed } from '../src/r40-compact-disarmed-probe.mjs';
+import {
+  validateParityEvidence,
+  R40_PREDECESSOR_RELEASE_ID,
+  R40_PREDECESSOR_MANIFEST
+} from './release-parity-r40.mjs';
+
+const DOMAIN=Buffer.from('DEADBYTE-R40-FINAL-CLOSURE-V1\0','utf8');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+function insist(ok,msg){if(!ok) throw new Error(msg);}
+function samePath(a,b){return path.resolve(String(a)).toLowerCase()===path.resolve(String(b)).toLowerCase();}
+async function fileEvidence(file){const abs=path.resolve(file),bytes=await readFile(abs);return {path:abs,sha256:sha256(bytes)};}
+async function publicUrl(){
+  const value=(await readFile(path.join(stateRoot,'bridge','mcp-url.txt'),'utf8')).trim();
+  const url=new URL(value);insist(url.protocol==='https:','final closure requires HTTPS public endpoint');return value;
+}
+async function grantAbsence(){
+  const out={};
+  for(const name of ['process-grant.json','coding-grant.json','autonomous-grant.json','desktop-grant.json','host-grant.json']){
+    let absent=false;try{await lstat(path.join(stateRoot,'runtime',name));}catch(error){if(error?.code==='ENOENT') absent=true;else throw error;}
+    insist(absent,`authority grant still present: ${name}`);out[name]=true;
+  }
+  return out;
+}
+async function atomicCreate(file,bytes){
+  await mkdir(path.dirname(file),{recursive:true});
+  const temp=`${file}.tmp-${process.pid}-${Math.random().toString(16).slice(2)}`;
+  const handle=await open(temp,'wx');
+  try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+  try{await rename(temp,file);}catch(error){await rm(temp,{force:true}).catch(()=>{});throw error;}
+}
+
+export async function writeFinalClosure({parityPath,activationPath,windowsGatePath}){
+  const pointer=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  insist(pointer.version==='0.12.0','final closure requires V0.12.0 active release');
+  insist(pointer.release_id===`v${pointer.version}-${pointer.manifest_sha256.slice(0,16)}`,'final closure release id/content address mismatch');
+
+  const parity=JSON.parse(await readFile(path.resolve(parityPath),'utf8'));
+  insist(parity.schema==='deadbyte.r40-parity.v1','R40 parity schema mismatch at final closure');
+  validateParityEvidence(parity);
+  insist(parity.candidate?.release_id===pointer.release_id&&parity.candidate?.manifest_sha256===pointer.manifest_sha256,'parity candidate/current release mismatch');
+  insist(parity.successor?.release_id===pointer.release_id&&parity.successor?.manifest_sha256===pointer.manifest_sha256,'parity successor/current release mismatch');
+  insist(parity.predecessor?.release_id===R40_PREDECESSOR_RELEASE_ID&&parity.predecessor?.manifest_sha256===R40_PREDECESSOR_MANIFEST,'parity predecessor identity mismatch');
+  insist(parity.rollback?.receipt_path&&parity.restore?.receipt_path,'parity rollback/restore receipt paths missing');
+  insist(parity.immutable_slot?.protected===true,'parity immutable-slot proof missing');
+  insist(samePath(parity.immutable_slot.release_root,pointer.release_root),'parity immutable release root mismatch');
+  insist(!samePath(parity.immutable_slot.development_root,pointer.release_root),'development_root must differ from immutable release_root');
+
+  const windowsGate=JSON.parse(await readFile(path.resolve(windowsGatePath),'utf8'));
+  insist(windowsGate.schema==='deadbyte.r40-windows-gate.v1'&&windowsGate.status==='passed'&&windowsGate.exit_code===0,'R40 Windows gate evidence invalid');
+  insist(windowsGate.version==='0.12.0'&&windowsGate.manifest_sha256===pointer.manifest_sha256,'R40 Windows gate/current release mismatch');
+  insist(windowsGate.marker==='DEADBYTE V0.12.0 / R40 WINDOWS BATCH GATE: PASS','R40 Windows gate marker mismatch');
+
+  const localFull=await probeR40FullSurface({packageRoot:pointer.release_root,generationRoot:pointer.generation_root,stateRoot});
+  insist(localFull.status==='passed'&&localFull.tool_count===80&&localFull.strict_output_schemas===true,'final local full 80-tool proof failed');
+  const compact=await probeR40CompactDisarmed(await publicUrl());
+  insist(compact.status==='passed'&&compact.tool_count===42&&compact.capability_closure===true,'final public compact capability closure failed');
+  insist(compact.coding_armed===false&&compact.autonomous_armed===false&&compact.desktop_armed===false,'final public compact authority is not DISARMED');
+  insist(compact.desktop_observation_receipt_verified===true&&compact.desktop_grounding_receipt_verified===true,'final public Desktop read-only proof missing');
+  insist(compact.release_id===pointer.release_id&&compact.release_manifest_sha256===pointer.manifest_sha256,'final public compact release binding mismatch');
+  insist(compact.machine_status?.release_id===pointer.release_id&&compact.machine_status?.release_manifest_sha256===pointer.manifest_sha256,'final machine status/current release mismatch');
+  insist(compact.machine_ping?.nonce===compact.nonce,'final machine ping nonce mismatch');
+
+  const evidence={
+    parity:await fileEvidence(parityPath),activation:await fileEvidence(activationPath),
+    rollback:await fileEvidence(parity.rollback.receipt_path),restore:await fileEvidence(parity.restore.receipt_path),
+    windows_gate:await fileEvidence(windowsGatePath)
+  };
+  const body={
+    schema:'deadbyte.r40-final-closure.v1',version:'0.12.0',release_label:'R40 FINAL MACHINE BASELINE',
+    completed_at_utc:new Date().toISOString(),active_pointer:pointer,
+    predecessor:{release_id:R40_PREDECESSOR_RELEASE_ID,version:'0.11.3',manifest_sha256:R40_PREDECESSOR_MANIFEST},
+    immutable_slot:{protected:true,release_root:path.resolve(pointer.release_root),development_root:path.resolve(parity.immutable_slot.development_root)},
+    surfaces:{
+      local_full:{status:localFull.status,profile:localFull.profile,tool_count:localFull.tool_count,catalog_sha256:localFull.catalog_sha256,strict_output_schemas:localFull.strict_output_schemas,protocol_revision:localFull.protocol_revision},
+      public_compact:{status:compact.status,profile:compact.profile,tool_count:compact.tool_count,catalog_sha256:compact.catalog_sha256,strict_output_schemas:compact.strict_output_schemas,ledger_sha256:compact.ledger_sha256,capability_count:compact.capability_count,production_non_host_capabilities:compact.production_non_host_capabilities,capability_closure:compact.capability_closure,coding_armed:compact.coding_armed,autonomous_armed:compact.autonomous_armed,desktop_armed:compact.desktop_armed,desktop_observation_receipt_verified:compact.desktop_observation_receipt_verified,desktop_grounding_receipt_verified:compact.desktop_grounding_receipt_verified,protocol_revision:compact.protocol_revision}
+    },
+    evidence,
+    machine:{status:compact.machine_status,ping:compact.machine_ping,nonce:compact.nonce},
+    authority:{all_disarmed:true,grants_absent:await grantAbsence()}
+  };
+  const privateKey=createPrivateKey(await readFile(path.join(stateRoot,'trust','ed25519-private.pem')));
+  const publicKey=createPublicKey(privateKey);
+  insist(privateKey.asymmetricKeyType==='ed25519'&&publicKey.asymmetricKeyType==='ed25519','closure signing key must be Ed25519');
+  const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+  const bodyBytes=Buffer.from(canonicalJson(body),'utf8');
+  const signature=cryptoSign(null,Buffer.concat([DOMAIN,bodyBytes]),privateKey);
+  const envelope={body,body_sha256:sha256(bodyBytes),attestation:{algorithm:'ed25519',domain:'DEADBYTE-R40-FINAL-CLOSURE-V1',key_id:keyId,signature_base64:signature.toString('base64')}};
+  envelope.closure_sha256=sha256(Buffer.from(canonicalJson(envelope),'utf8'));
+  const dir=path.join(stateRoot,'evidence','release');
+  const file=path.join(dir,`r40-final-${pointer.manifest_sha256.slice(0,16)}.json`);
+  const bytes=Buffer.from(`${JSON.stringify(envelope,null,2)}\n`,'utf8');
+  await atomicCreate(file,bytes);
+  return {status:'written',path:file,sha256:sha256(bytes),closure_sha256:envelope.closure_sha256,release_id:pointer.release_id};
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  const [parityPath,activationPath,windowsGatePath]=process.argv.slice(2);
+  if(!parityPath||!activationPath||!windowsGatePath) throw new Error('usage: node scripts/final-closure-r40.mjs <parity.json> <activation-receipt.json> <windows-gate.json>');
+  writeFinalClosure({parityPath,activationPath,windowsGatePath})
+    .then(result=>console.log(JSON.stringify(result,null,2)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}