deadbyte-mcp 0.15.1 → 0.15.3

package/scripts/final-closure-verify-r46.mjs

@@ -0,0 +1,119 @@
+import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DOMAIN=Buffer.from('DEADBYTE-R46-FINAL-CLOSURE-V1\0','utf8');
+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 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,message){if(!ok)throw new Error(message);}
+
+export async function verifyFinalClosureObject(envelope,{root=packageRoot,runtimeStateRoot=stateRoot}={}){
+  const candidate=path.resolve(root),state=path.resolve(runtimeStateRoot);
+  insist(envelope&&typeof envelope==='object'&&!Array.isArray(envelope),'R46 closure envelope invalid');
+  insist(envelope.body?.schema==='deadbyte.r46-final-closure.v1','R46 closure schema mismatch');
+  insist(envelope.body?.version==='0.15.2'&&envelope.body?.train==='R46','R46 closure version/train mismatch');
+  insist(envelope.body?.release_label==='FILELESS POWERSHELL PRODUCT BASELINE','R46 closure label mismatch');
+
+  const bodyBytes=Buffer.from(canonicalJson(envelope.body),'utf8');
+  insist(envelope.body_sha256===sha256(bodyBytes),'R46 closure body SHA-256 mismatch');
+  insist(envelope.attestation?.algorithm==='ed25519'&&envelope.attestation?.domain==='DEADBYTE-R46-FINAL-CLOSURE-V1','R46 closure attestation contract mismatch');
+  const publicKey=createPublicKey(await readFile(path.join(state,'trust','ed25519-public.pem')));
+  insist(publicKey.asymmetricKeyType==='ed25519','R46 closure verify key must be Ed25519');
+  const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
+  insist(envelope.attestation.key_id===keyId,'R46 closure signer key mismatch');
+  insist(typeof envelope.attestation.signature_base64==='string'&&cryptoVerify(
+    null,Buffer.concat([DOMAIN,bodyBytes]),publicKey,Buffer.from(envelope.attestation.signature_base64,'base64')
+  ),'R46 closure signature invalid');
+
+  const unsigned={body:envelope.body,body_sha256:envelope.body_sha256,attestation:envelope.attestation};
+  const closureSha256=sha256(Buffer.from(canonicalJson(unsigned),'utf8'));
+  insist(envelope.closure_sha256===closureSha256,'R46 closure digest mismatch');
+
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+  insist(pointer.version==='0.15.2'&&pointer.manifest_sha256===manifestSha256,'R46 active pointer/candidate mismatch');
+  insist(pointer.release_id===`v0.15.2-${manifestSha256.slice(0,16)}`,'R46 active release id mismatch');
+  insist(envelope.body.active_pointer?.release_id===pointer.release_id&&
+    envelope.body.active_pointer?.manifest_sha256===pointer.manifest_sha256&&
+    envelope.body.active_pointer?.generation_manifest_sha256===pointer.generation_manifest_sha256,
+    'R46 closure active pointer drift');
+
+  const gateRef=envelope.body.evidence?.windows_gate;
+  const parityRef=envelope.body.evidence?.parity;
+  for(const [label,ref] of [['windows gate',gateRef],['parity',parityRef]]){
+    insist(ref&&typeof ref.path==='string'&&/^[0-9a-f]{64}$/.test(String(ref.sha256??'')),`R46 ${label} evidence reference invalid`);
+    const bytes=await readFile(path.resolve(ref.path));
+    insist(sha256(bytes)===ref.sha256,`R46 ${label} evidence hash mismatch`);
+  }
+  const gate=JSON.parse(await readFile(path.resolve(gateRef.path),'utf8'));
+  const parity=JSON.parse(await readFile(path.resolve(parityRef.path),'utf8'));
+  insist(gate.schema==='deadbyte.r46-windows-gate.v1'&&gate.status==='passed'&&gate.version==='0.15.2','R46 gate evidence invalid');
+  insist(gate.manifest_sha256===manifestSha256,'R46 gate candidate mismatch');
+  insist(gate.parent?.release_id==='v0.15.1-d55f00b5144dc31a'&&gate.parent?.manifest_sha256==='d55f00b5144dc31a7fe39e4dc60d640a94780da6aaeca0918e87636b816d7854','R46 sealed parent identity invalid');
+  insist(gate.runtime_predecessor?.release_id==='v0.15.2-0fb46542f6a4345f'&&gate.runtime_predecessor?.manifest_sha256==='0fb46542f6a4345f1c527565d06bf6e9b8e283260e47bf684fb70a60308fcf34','R46 reopened runtime predecessor identity invalid');
+  insist(envelope.body.runtime_predecessor?.release_id===gate.runtime_predecessor.release_id&&envelope.body.runtime_predecessor?.manifest_sha256===gate.runtime_predecessor.manifest_sha256,'R46 closure runtime predecessor mismatch');
+  insist(parity.schema==='deadbyte.r46-parity.v1'&&parity.status==='passed'&&parity.version==='0.15.2','R46 parity evidence invalid');
+  insist(parity.candidate?.release_id===pointer.release_id&&
+    parity.candidate?.manifest_sha256===pointer.manifest_sha256&&
+    parity.candidate?.generation_manifest_sha256===pointer.generation_manifest_sha256,
+    'R46 parity active generation mismatch');
+  insist(parity.process_policy?.target_repin_verified===true,'R46 target-machine process repin proof missing');
+  insist(parity.fileless_powershell?.exit_code===0&&
+    parity.fileless_powershell?.pscommandpath_empty===true&&
+    parity.fileless_powershell?.invocation_path_empty===true&&
+    parity.fileless_powershell?.new_temp_ps1_count===0,
+    'R46 fileless PowerShell proof invalid');
+  insist(parity.persistent_powershell_repl?.state_persisted===true&&
+    parity.persistent_powershell_repl?.observed_value===42&&
+    parity.persistent_powershell_repl?.wait_for_verified===true&&
+    parity.persistent_powershell_repl?.tail_read_verified===true&&
+    parity.persistent_powershell_repl?.raw_input_not_journaled===true,
+    'R46 persistent PowerShell REPL proof invalid');
+  insist(parity.retained_output_ring?.eviction_verified===true&&
+    parity.retained_output_ring?.tail_marker_verified===true&&
+    parity.retained_output_ring?.earliest_offset>0,
+    'R46 retained-output ring proof invalid');
+  insist(envelope.body.process_policy?.target_repin_verified===true,'R46 closure process repin proof invalid');
+  insist(envelope.body.fileless_powershell?.exit_code===0&&
+    envelope.body.fileless_powershell?.new_temp_ps1_count===0,
+    'R46 closure fileless proof invalid');
+  insist(envelope.body.persistent_powershell_repl?.state_persisted===true&&
+    envelope.body.persistent_powershell_repl?.observed_value===42&&
+    envelope.body.persistent_powershell_repl?.raw_input_not_journaled===true,
+    'R46 closure persistent REPL proof invalid');
+  insist(envelope.body.retained_output_ring?.eviction_verified===true&&
+    envelope.body.retained_output_ring?.tail_marker_verified===true,
+    'R46 closure retained-output ring proof invalid');
+
+  return {
+    ok:true,status:'passed',version:'0.15.2',train:'R46',
+    release_id:pointer.release_id,
+    manifest_sha256:pointer.manifest_sha256,
+    generation_manifest_sha256:pointer.generation_manifest_sha256,
+    closure_sha256:envelope.closure_sha256,
+    signer_key_id:keyId,
+    fileless_powershell:true,
+    target_machine_process_repin:true
+  };
+}
+
+export async function verifyFinalClosure({file=null,root=packageRoot,runtimeStateRoot=stateRoot}={}){
+  const state=path.resolve(runtimeStateRoot),candidate=path.resolve(root);
+  const manifestSha256=sha256(await readFile(path.join(candidate,'MANIFEST.SHA256')));
+  const target=file?path.resolve(file):path.join(state,'evidence','release',`r46-final-${manifestSha256.slice(0,16)}.json`);
+  const envelope=JSON.parse(await readFile(target,'utf8'));
+  return {...await verifyFinalClosureObject(envelope,{root:candidate,runtimeStateRoot:state}),path:target};
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)verifyFinalClosure({file:process.argv[2]??null})
+  .then(value=>console.log(JSON.stringify(value,null,2)))
+  .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/scripts/full-regression-r46.mjs

@@ -0,0 +1,28 @@
+import { spawnSync } from 'node:child_process';
+import { readdir, stat } 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 excluded=new Set(['full-max-catalog-r44.test.mjs','full-max-catalog-r45.test.mjs']);
+const files=(await readdir(testDir,{withFileTypes:true}))
+  .filter(entry=>entry.isFile()&&entry.name.endsWith('.test.mjs')&&!excluded.has(entry.name));
+const weighted=[];
+for(const entry of files) weighted.push({path:path.join('test',entry.name),size:(await stat(path.join(testDir,entry.name))).size});
+weighted.sort((a,b)=>b.size-a.size||a.path.localeCompare(b.path,'en'));
+const batchCount=8;
+const batches=Array.from({length:batchCount},()=>[]);
+weighted.forEach((entry,index)=>batches[index%batchCount].push(entry.path));
+let total=0;
+for(let index=0;index<batchCount;index++){
+  const batch=batches[index].sort((a,b)=>a.localeCompare(b,'en'));
+  console.log(`R47-BOUNDED-REGRESSION batch=${index+1}/${batchCount} files=${batch.length}`);
+  const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...batch],{cwd:root,stdio:'inherit',windowsHide:true,shell:false});
+  if(result.error) throw result.error;
+  if(result.signal) throw new Error(`regression batch ${index} terminated by ${result.signal}`);
+  if(result.status!==0) throw new Error(`regression batch ${index} failed with exit code ${result.status}`);
+  total+=batch.length;
+}
+console.log(`R47-BOUNDED-REGRESSION PASS files=${total} batches=${batchCount}`);

package/scripts/gate-windows-r46.ps1

@@ -0,0 +1,58 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+
+function Invoke-GateStep {
+    param(
+        [Parameter(Mandatory = $true)][string]$Name,
+        [Parameter(Mandatory = $true)][string[]]$NpmArgs
+    )
+    Write-Host "==== $Name ===="
+    $LASTEXITCODE = 0
+    & npm.cmd @NpmArgs
+    if ($LASTEXITCODE -ne 0) {
+        throw "DEADBYTE V0.15.2 / R46 gate failed at $Name with exit code $LASTEXITCODE"
+    }
+}
+
+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 'hardware-build' -NpmArgs @('run','hardware:build')
+
+Write-Host '==== host-policy-hermetic-clean ===='
+$HostPolicyPath = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\controller\deadbyte-host-policy.json'))
+Remove-Item -LiteralPath $HostPolicyPath -Force -ErrorAction SilentlyContinue
+if (Test-Path -LiteralPath $HostPolicyPath) {
+    throw "DEADBYTE V0.15.2 / R46 gate could not remove machine-local Host policy before hermetic regression"
+}
+Write-Host 'HOST_POLICY_HERMETIC_ABSENT'
+
+Invoke-GateStep -Name 'r46-fileless-focused' -NpmArgs @('run','r46:fileless:test')
+Invoke-GateStep -Name 'full-regression' -NpmArgs @('run','r46: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 '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 'host-policy-refresh' -NpmArgs @('run','host:policy:init')
+Invoke-GateStep -Name 'release-manifest-write' -NpmArgs @('run','manifest:write')
+Invoke-GateStep -Name 'release-manifest' -NpmArgs @('run','manifest:verify')
+Invoke-GateStep -Name 'doctor' -NpmArgs @('run','doctor')
+Invoke-GateStep -Name 'mcp-host-smoke' -NpmArgs @('run','mcp:host:smoke')
+Invoke-GateStep -Name 'authority-smoke' -NpmArgs @('run','authority:smoke')
+Invoke-GateStep -Name 'release-manifest-final' -NpmArgs @('run','manifest:verify')
+
+Write-Host '==== windows-gate-evidence ===='
+$LASTEXITCODE = 0
+& node.exe (Join-Path $PSScriptRoot 'windows-gate-evidence-r46.mjs')
+if ($LASTEXITCODE -ne 0) {
+    throw "DEADBYTE V0.15.2 / R46 gate failed at windows-gate-evidence with exit code $LASTEXITCODE"
+}
+Write-Host '==== DEADBYTE V0.15.2 / R46 FILELESS POWERSHELL WINDOWS BATCH GATE: PASS ===='

package/scripts/inspect-r46-active.mjs

@@ -0,0 +1,2 @@
+import { readFile } from 'node:fs/promises'; import os from 'node:os'; import path from 'node:path';
+const p=path.join(os.homedir(),'.deadbyte-mcp','active-release.json'); console.log(JSON.stringify({cwd:process.cwd(),state:p,active:JSON.parse(await readFile(p,'utf8'))},null,2));

package/scripts/r47-core-failures.mjs

@@ -0,0 +1 @@
+import {spawnSync} from 'node:child_process'; const files=["test/autonomous-r34-e2e.test.mjs","test/autonomous-capability-r36.test.mjs","test/desktop-runtime-r40.test.mjs","test/coding-runtime.test.mjs"]; const r=spawnSync(process.execPath,['--test','--test-concurrency=1',...files],{stdio:'inherit',shell:false,windowsHide:true}); process.exit(r.status??1);

package/scripts/refresh-process-policy.mjs

@@ -1,5 +1,5 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { open, readFile, rename, rm } from 'node:fs/promises';
+import { lstat, open, readFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
@@ -14,7 +14,35 @@ function samePath(a, b) {
     : left === right;
 }
 
-export async function refreshProcessPolicy({ repoRoot, policyPath }) {
+async function regularPinnedExecutable(file, label) {
+  const info = await lstat(file);
+  if (!info.isFile() || info.isSymbolicLink()) throw new Error(`${label} must be a regular non-symlink file`);
+  return sha256(await readFile(file));
+}
+
+function resolveSystemRoot(explicit) {
+  const value = explicit ?? process.env.SystemRoot ?? process.env.WINDIR ?? null;
+  if (typeof value !== 'string' || value.length < 1) {
+    throw new Error('process policy Windows system profiles require SystemRoot/WINDIR');
+  }
+  return path.resolve(value);
+}
+
+async function refreshSystemProfile(policy, id, expectedExecutable) {
+  const profile = policy?.profiles?.[id];
+  if (!profile || typeof profile !== 'object' || Array.isArray(profile)) {
+    throw new Error(`process policy profile '${id}' missing`);
+  }
+  if (typeof profile.executable !== 'string' || !samePath(profile.executable, expectedExecutable)) {
+    throw new Error(`process policy profile '${id}' executable path mismatch`);
+  }
+  const digest = await regularPinnedExecutable(expectedExecutable, `process profile '${id}'`);
+  profile.executable = expectedExecutable;
+  profile.executable_sha256 = digest;
+  return digest;
+}
+
+export async function refreshProcessPolicy({ repoRoot, policyPath, systemRoot = null }) {
   const root = path.resolve(repoRoot);
   const file = path.resolve(policyPath);
   const rawBytes = await readFile(file);
@@ -29,9 +57,16 @@ export async function refreshProcessPolicy({ repoRoot, policyPath }) {
   if (!samePath(policy.native_host.path, expectedHost)) {
     throw new Error('process policy native_host path must equal candidate bin/deadbyte-process-host.exe');
   }
-  const hostBytes = await readFile(expectedHost);
-  const hostSha = sha256(hostBytes);
+  const hostSha = await regularPinnedExecutable(expectedHost, 'process native host');
   policy.native_host.sha256 = hostSha;
+
+  const windowsRoot = resolveSystemRoot(systemRoot);
+  const cmdPath = path.join(windowsRoot, 'System32', 'cmd.exe');
+  const powershellPath = path.join(windowsRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+  const cmdSha = await refreshSystemProfile(policy, 'ping_hold', cmdPath);
+  const powershellSha = await refreshSystemProfile(policy, 'powershell', powershellPath);
+  const powershellReplSha = await refreshSystemProfile(policy, 'powershell_repl', powershellPath);
+
   const output = Buffer.from(`${JSON.stringify(policy, null, 2)}\n`, 'utf8');
   const temp = `${file}.tmp-${process.pid}-${randomBytes(4).toString('hex')}`;
   const handle = await open(temp, 'wx');
@@ -47,8 +82,30 @@ export async function refreshProcessPolicy({ repoRoot, policyPath }) {
     await rm(temp, { force: true }).catch(() => {});
     throw error;
   }
-  if (sha256(await readFile(expectedHost)) !== hostSha) throw new Error('process native host changed during policy refresh');
-  return { policy_path: file, native_host_path: expectedHost, native_host_sha256: hostSha };
+
+  if (await regularPinnedExecutable(expectedHost, 'process native host') !== hostSha) {
+    throw new Error('process native host changed during policy refresh');
+  }
+  if (await regularPinnedExecutable(cmdPath, "process profile 'ping_hold'") !== cmdSha) {
+    throw new Error("process profile 'ping_hold' changed during policy refresh");
+  }
+  if (await regularPinnedExecutable(powershellPath, "process profile 'powershell'") !== powershellSha) {
+    throw new Error("process profile 'powershell' changed during policy refresh");
+  }
+  if (await regularPinnedExecutable(powershellPath, "process profile 'powershell_repl'") !== powershellReplSha) {
+    throw new Error("process profile 'powershell_repl' changed during policy refresh");
+  }
+
+  return {
+    policy_path: file,
+    native_host_path: expectedHost,
+    native_host_sha256: hostSha,
+    cmd_executable: cmdPath,
+    cmd_executable_sha256: cmdSha,
+    powershell_executable: powershellPath,
+    powershell_executable_sha256: powershellSha,
+    powershell_repl_executable_sha256: powershellReplSha
+  };
 }
 
 const invoked = process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url;
@@ -60,7 +117,7 @@ if (invoked) {
     : path.join(root, 'controller', 'deadbyte-process-policy.json');
   try {
     const result = await refreshProcessPolicy({ repoRoot: root, policyPath });
-    console.log(`PROCESS_POLICY_REFRESH_OK sha256=${result.native_host_sha256}`);
+    console.log(`PROCESS_POLICY_REFRESH_OK native=${result.native_host_sha256} cmd=${result.cmd_executable_sha256} powershell=${result.powershell_executable_sha256} powershell_repl=${result.powershell_repl_executable_sha256}`);
   } catch (error) {
     console.error(`PROCESS_POLICY_REFRESH_FAIL ${error?.message ?? error}`);
     process.exitCode = 1;

package/scripts/release-manifest.mjs

@@ -27,7 +27,7 @@ const requiredBundledDependencyRoots = [
   'node_modules/zod/package.json'
 ];
 const excludedPackagePrefixes = ['tmp/','.deadbyte-machine-fs-recovery/'];
-const excludedPackagePaths = new Set(['controller/deadbyte-host-policy.json']);
+const excludedPackagePaths = new Set(['controller/deadbyte-host-policy.json','controller/deadbyte-coding-policy.json']);
 const allowedWorkspacePayload = new Set([
   'workspaces/autonomous-live/fixture.txt',
   'workspaces/demo/input.txt'

package/scripts/release-parity-r46.mjs

@@ -0,0 +1,187 @@
+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';
+import { verifyGenerationBundle } from '../src/release-generation.mjs';
+import { loadProcessPolicy, processSessionStatus } from '../src/process-policy.mjs';
+import { createProcessRuntime } from '../src/process-runtime.mjs';
+
+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 sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+function insist(ok,message){if(!ok)throw new Error(message);}
+function samePath(a,b){return path.resolve(String(a)).toLowerCase()===path.resolve(String(b)).toLowerCase();}
+
+async function waitForExit(runtime,sessionId,timeoutMs=10000){
+  const deadline=Date.now()+timeoutMs;
+  let page=null,text='';
+  while(Date.now()<deadline){
+    page=await runtime.read({sessionId,offset:0,maxBytes:65536});
+    text=Buffer.from(page.data_base64,'base64').toString('utf8');
+    if(page.state==='exited'||page.state==='terminated') return {page,text};
+    await sleep(50);
+  }
+  throw new Error('R46 PowerShell parity timed out');
+}
+
+export async function runReleaseParity({
+  root=packageRoot,
+  runtimeStateRoot=stateRoot,
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(root);
+  const state=path.resolve(runtimeStateRoot);
+  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.15.2','R46 parity requires package version 0.15.2');
+
+  const pointer=JSON.parse(await readFile(path.join(state,'active-release.json'),'utf8'));
+  insist(pointer.version==='0.15.2'&&pointer.manifest_sha256===manifestSha256,'R46 active pointer candidate mismatch');
+  insist(pointer.release_id===`v0.15.2-${manifestSha256.slice(0,16)}`,'R46 active release id mismatch');
+  const releaseManifest=await readFile(path.join(pointer.release_root,'MANIFEST.SHA256'));
+  insist(sha256(releaseManifest)===manifestSha256,'R46 immutable release manifest mismatch');
+
+  const generation=await verifyGenerationBundle(pointer.generation_root,pointer.generation_manifest_sha256);
+  const processPolicyPath=path.join(pointer.generation_root,'process-policy.json');
+  const policy=await loadProcessPolicy(processPolicyPath);
+  const status=await processSessionStatus(policy);
+  insist(status.armed===true&&status.reason==='standing-grant','R46 parity requires restored Process standing grant');
+  insist(status.profile_ids.includes('powershell')&&status.root_ids.includes('core'),'R46 parity Process grant missing powershell/core');
+
+  const systemRoot=process.env.SystemRoot||process.env.WINDIR;
+  insist(typeof systemRoot==='string'&&systemRoot.length>0,'R46 parity requires SystemRoot/WINDIR');
+  const expectedPowerShell=path.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe');
+  const expectedCmd=path.join(systemRoot,'System32','cmd.exe');
+  insist(samePath(policy.profiles?.powershell?.executable,expectedPowerShell),'R46 generated PowerShell path is not target-bound');
+  insist(samePath(policy.profiles?.ping_hold?.executable,expectedCmd),'R46 generated cmd path is not target-bound');
+  insist(policy.profiles.powershell.executable_sha256===sha256(await readFile(expectedPowerShell)),'R46 generated PowerShell digest mismatch');
+  insist(policy.profiles.ping_hold.executable_sha256===sha256(await readFile(expectedCmd)),'R46 generated cmd digest mismatch');
+  insist(JSON.stringify(policy.profiles.powershell.prefix_args)===JSON.stringify(['-NoLogo','-NoProfile','-NonInteractive','-Command']),'R46 PowerShell prefix contract mismatch');
+  insist(policy.profiles.powershell.max_args===1&&policy.profiles.powershell.max_arg_bytes===8192,'R46 PowerShell argument bounds mismatch');
+
+  const runtime=createProcessRuntime({
+    policy,
+    signingKeyPath:path.join(state,'trust','ed25519-private.pem'),
+    verifyKeyPath:path.join(state,'trust','ed25519-public.pem')
+  });
+  const source="$ErrorActionPreference='Stop';$before=@(Get-ChildItem -LiteralPath $env:TEMP -Filter '*.ps1' -File -ErrorAction SilentlyContinue|ForEach-Object{$_.FullName});[Console]::WriteLine('DB_R46_FILELESS_PARITY');[Console]::WriteLine('PSCommandPath=' + [string]$PSCommandPath);[Console]::WriteLine('InvocationPath=' + [string]$MyInvocation.MyCommand.Path);$after=@(Get-ChildItem -LiteralPath $env:TEMP -Filter '*.ps1' -File -ErrorAction SilentlyContinue|ForEach-Object{$_.FullName});$new=@($after|Where-Object{$_ -notin $before});[Console]::WriteLine('NEW_TEMP_PS1_COUNT=' + $new.Count)";
+  const started=await runtime.start({profileId:'powershell',rootId:'core',cwd:'.',args:[source]});
+  const observed=await waitForExit(runtime,started.session_id);
+  insist(observed.page.state==='exited'&&observed.page.exit_code===0,'R46 PowerShell parity process did not exit cleanly');
+  insist(/DB_R46_FILELESS_PARITY/.test(observed.text),'R46 PowerShell parity marker missing');
+  insist(/PSCommandPath=\r?\n/.test(observed.text),'R46 PowerShell unexpectedly materialized PSCommandPath');
+  insist(/InvocationPath=\r?\n/.test(observed.text),'R46 PowerShell invocation path is not fileless');
+  insist(/NEW_TEMP_PS1_COUNT=0/.test(observed.text),'R46 PowerShell parity created a temp ps1');
+  const journal=await runtime.verifyEventJournal({sessionId:started.session_id});
+  insist(journal.ok===true,'R46 PowerShell process journal verification failed');
+
+
+  insist(status.profile_ids.includes('powershell_repl'),'R46 parity Process grant missing powershell_repl');
+  insist(samePath(policy.profiles?.powershell_repl?.executable,expectedPowerShell),'R46 generated PowerShell REPL path is not target-bound');
+  insist(policy.profiles.powershell_repl.executable_sha256===sha256(await readFile(expectedPowerShell)),'R46 generated PowerShell REPL digest mismatch');
+  insist(policy.profiles.powershell_repl.allow_raw_input===true&&policy.profiles.powershell_repl.transport==='pipe','R46 PowerShell REPL raw-input contract mismatch');
+
+  const repl=await runtime.start({profileId:'powershell_repl',rootId:'core',cwd:'.',args:[]});
+  const firstWrite=await runtime.write({sessionId:repl.session_id,input:"$x=41;[Console]::WriteLine('DB_R46_REPL_SET')",appendNewline:true});
+  insist(firstWrite.session.state==='running','R46 PowerShell REPL did not remain running after first write');
+  const firstRead=await runtime.read({sessionId:repl.session_id,offset:0,maxBytes:65536,waitMs:5000,waitFor:'DB_R46_REPL_SET'});
+  insist(firstRead.wait_satisfied===true,'R46 PowerShell REPL first wait was not satisfied');
+  const beforeSecond=(await runtime.status({sessionId:repl.session_id})).stream_head;
+  await runtime.write({sessionId:repl.session_id,input:"[Console]::WriteLine('DB_R46_REPL_VALUE=' + ($x+1))",appendNewline:true});
+  const secondRead=await runtime.read({sessionId:repl.session_id,offset:beforeSecond,maxBytes:65536,waitMs:5000,waitFor:'DB_R46_REPL_VALUE=42'});
+  const secondText=Buffer.from(secondRead.data_base64,'base64').toString('utf8');
+  insist(secondRead.wait_satisfied===true&&/DB_R46_REPL_VALUE=42/.test(secondText),'R46 PowerShell REPL state did not persist across writes');
+  const tailRead=await runtime.read({sessionId:repl.session_id,offset:-4096,maxBytes:4096});
+  insist(/DB_R46_REPL_VALUE=42/.test(Buffer.from(tailRead.data_base64,'base64').toString('utf8')),'R46 PowerShell REPL tail read missing state proof');
+  await runtime.terminate({sessionId:repl.session_id});
+  const replJournal=await runtime.verifyEventJournal({sessionId:repl.session_id});
+  insist(replJournal.ok===true,'R46 PowerShell REPL journal verification failed');
+  const replJournalText=await readFile(path.join(policy.state_dir,`${repl.session_id}.jsonl`),'utf8');
+  insist(!replJournalText.includes('$x=41')&&!replJournalText.includes('DB_R46_REPL_VALUE'),'R46 raw process input leaked into signed journal');
+
+  const ringSource="[Console]::Write(('A'*2097152));[Console]::WriteLine('DB_R46_RING_TAIL')";
+  const ring=await runtime.start({profileId:'powershell',rootId:'core',cwd:'.',args:[ringSource]});
+  const ringObserved=await waitForExit(runtime,ring.session_id,15000);
+  const ringStatus=await runtime.status({sessionId:ring.session_id});
+  insist(ringObserved.page.exit_code===0&&ringStatus.earliest_offset>0,'R46 retained-output ring did not evict under heavy output');
+  const ringTail=await runtime.read({sessionId:ring.session_id,offset:-4096,maxBytes:4096});
+  insist(/DB_R46_RING_TAIL/.test(Buffer.from(ringTail.data_base64,'base64').toString('utf8')),'R46 retained-output ring lost tail marker');
+
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'R46 parity clock invalid');
+  const evidence={
+    schema:'deadbyte.r46-parity.v1',
+    status:'passed',
+    version:'0.15.2',
+    completed_at_utc:completed.toISOString(),
+    candidate:{
+      release_id:pointer.release_id,
+      manifest_sha256:pointer.manifest_sha256,
+      generation_manifest_sha256:pointer.generation_manifest_sha256
+    },
+    generation:{files:generation.files,generation_manifest_sha256:generation.generation_manifest_sha256},
+    process_policy:{
+      sha256:policy.policy_sha256,
+      profile_ids:Object.keys(policy.profiles).sort(),
+      powershell_executable:policy.profiles.powershell.executable,
+      powershell_executable_sha256:policy.profiles.powershell.executable_sha256,
+      cmd_executable:policy.profiles.ping_hold.executable,
+      cmd_executable_sha256:policy.profiles.ping_hold.executable_sha256,
+      target_repin_verified:true
+    },
+    fileless_powershell:{
+      session_id:started.session_id,
+      child_pid:started.child_pid,
+      exit_code:observed.page.exit_code,
+      stream_sha256:observed.page.stream_sha256,
+      pscommandpath_empty:true,
+      invocation_path_empty:true,
+      new_temp_ps1_count:0,
+      journal_head_sha256:journal.head_sha256,
+      journal_event_count:journal.event_count
+    },
+    persistent_powershell_repl:{
+      session_id:repl.session_id,
+      child_pid:repl.child_pid,
+      state_persisted:true,
+      observed_value:42,
+      wait_for_verified:true,
+      tail_read_verified:true,
+      raw_input_not_journaled:true,
+      journal_head_sha256:replJournal.head_sha256,
+      journal_event_count:replJournal.event_count
+    },
+    retained_output_ring:{
+      session_id:ring.session_id,
+      stream_head:ringStatus.stream_head,
+      earliest_offset:ringStatus.earliest_offset,
+      eviction_verified:true,
+      tail_marker_verified:true
+    },
+    execution_provider:'deadbyte_mcp',
+    rdc_operation_count:0
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(state,'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r46-parity-${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',evidence_path:file,evidence_sha256:sha256(bytes),evidence};
+  }catch(error){
+    if(error?.code!=='EEXIST')throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed','existing R46 parity evidence invalid');
+    insist(existing.candidate?.manifest_sha256===manifestSha256,'existing R46 parity candidate mismatch');
+    return {status:'existing',evidence_path:file,evidence_sha256:sha256(existingBytes),evidence:existing};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked)runReleaseParity().then(value=>console.log(JSON.stringify(value))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});

package/scripts/run-r46-full-regression-background.mjs

@@ -0,0 +1,7 @@
+import { spawn } from 'node:child_process';
+import { openSync } from 'node:fs';
+const out=openSync('proof/r46-full-regression-background.log','w');
+const err=openSync('proof/r46-full-regression-background.err.log','w');
+const p=spawn(process.execPath,['scripts/full-regression-r46.mjs'],{cwd:process.cwd(),detached:true,stdio:['ignore',out,err],windowsHide:true});
+p.unref();
+console.log(JSON.stringify({pid:p.pid}));

package/scripts/run-r46-windows-gate-background.mjs

@@ -0,0 +1,6 @@
+import { spawn } from 'node:child_process';
+import { writeFile } from 'node:fs/promises';
+const child=spawn('powershell.exe',['-NoProfile','-ExecutionPolicy','Bypass','-File','scripts/gate-windows-r46.ps1'],{cwd:process.cwd(),detached:true,stdio:'ignore',windowsHide:true});
+await writeFile('proof/r46-windows-gate-background.pid.json',JSON.stringify({pid:child.pid,started_at_utc:new Date().toISOString()}));
+child.unref();
+console.log(JSON.stringify({status:'started',pid:child.pid}));

package/scripts/run-r46-windows-gate-background.ps1

@@ -0,0 +1,10 @@
+$ErrorActionPreference = 'Stop'
+$root = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
+$log = Join-Path $root 'proof/r46-windows-gate-background.log'
+$err = Join-Path $root 'proof/r46-windows-gate-background.err.log'
+$done = Join-Path $root 'proof/r46-windows-gate-background.done'
+Remove-Item -LiteralPath $done -Force -ErrorAction SilentlyContinue
+Remove-Item -LiteralPath $log -Force -ErrorAction SilentlyContinue
+Remove-Item -LiteralPath $err -Force -ErrorAction SilentlyContinue
+$p = Start-Process -FilePath 'powershell.exe' -ArgumentList @('-NoProfile','-ExecutionPolicy','Bypass','-File',(Join-Path $PSScriptRoot 'gate-windows-r46.ps1')) -WorkingDirectory $root -RedirectStandardOutput $log -RedirectStandardError $err -PassThru
+@{ pid=$p.Id; started_at_utc=(Get-Date).ToUniversalTime().ToString('o') } | ConvertTo-Json -Compress | Set-Content -LiteralPath $done -Encoding utf8