deadbyte-mcp 0.15.29 → 0.15.30

package/scripts/verify-r45-parent.mjs

@@ -76,7 +76,7 @@ export async function verifyR45Parent(parentFile,{stateRoot=path.join(os.homedir
   insist(envelope.body.version===parent.parent_version,'R45 parent closure version mismatch');
   insist(envelope.body.release_label==='R44 REMOTE AGENT SKILL BASELINE','R45 parent closure label mismatch');
 
-  const publicKey=createPublicKey(await readFile(path.join(path.resolve(stateRoot),'trust','ed25519-public.pem')));
+  const publicKey=createPublicKey(await readFile(path.resolve(process.env.DEADBYTE_PARENT_VERIFY_KEY||path.join(path.resolve(stateRoot),'trust','ed25519-public.pem'))));
   insist(publicKey.asymmetricKeyType==='ed25519','R45 parent trust key must be Ed25519');
   const keyId=sha256(Buffer.from(publicKey.export({type:'spki',format:'der'})));
   insist(keyId===parent.parent_final_closure_signer_key_id,'R45 parent trust key id mismatch');

package/scripts/windows-gate-evidence-r53.mjs

@@ -0,0 +1,102 @@
+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 { doctor } from '../src/doctor-r45.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+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 insist = (ok, message) => { if (!ok) throw new Error(message); };
+const pkg = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
+const release = JSON.parse(await readFile(path.join(root, 'RELEASE.json'), 'utf8'));
+const provenance = JSON.parse(await readFile(path.join(root, 'PROVENANCE.json'), 'utf8'));
+const matrix = JSON.parse(await readFile(path.join(root, 'TEST-MATRIX.json'), 'utf8'));
+const active = JSON.parse(await readFile(path.join(stateRoot, 'active-release.json'), 'utf8'));
+const manifestSha256 = sha256(await readFile(path.join(root, 'MANIFEST.SHA256')));
+
+insist(pkg.version === '0.15.30' && release.version === pkg.version && release.train === 'R53', 'R53 candidate identity mismatch');
+insist(
+  active.release_id === release.runtime_predecessor.release_id &&
+  active.manifest_sha256 === release.runtime_predecessor.manifest_sha256 &&
+  active.generation_manifest_sha256 === release.runtime_predecessor.generation_manifest_sha256,
+  'active runtime is not exact sealed 0.15.29 predecessor'
+);
+insist(release.parent.version === '0.15.29', 'R53 parent version mismatch');
+insist(release.parent.release_id === 'v0.15.29-f74eaa1b3d00e6fb', 'R53 parent release id mismatch');
+insist(release.parent.manifest_sha256 === 'f74eaa1b3d00e6fb5a36b2358efb815e3686c9fe9dbd3b84d25a713ef957748c', 'R53 parent manifest mismatch');
+insist(release.parent.generation_manifest_sha256 === '289b4fc065de0681da6864cc1bbe09aab198ca804945ffc27c786438dad13f5a', 'R53 parent generation mismatch');
+insist(release.parent.tarball_sha256 === 'f535d7121a384bed106d34bc7525afa9d4048c7e290f270699e25136d1e82eeb', 'R53 parent tarball mismatch');
+insist(provenance.parent_release_id === release.parent.release_id, 'R53 provenance parent release mismatch');
+insist(provenance.parent_manifest_sha256 === release.parent.manifest_sha256, 'R53 provenance parent manifest mismatch');
+insist(provenance.parent_generation_manifest_sha256 === release.parent.generation_manifest_sha256, 'R53 provenance parent generation mismatch');
+insist(provenance.operator_override?.four_hour_soak === 'NOT_COMPLETED', 'R53 soak bypass missing');
+insist(provenance.operator_override?.stable_final_claim === false, 'R53 must not claim stable/final');
+insist(matrix.operator_override?.four_hour_soak === 'NOT_COMPLETED', 'R53 matrix soak bypass missing');
+
+const health = await doctor();
+insist(health.status === 'ok' && health.package_version === pkg.version && health.manifest?.verified === true, 'R53 doctor evidence invalid');
+insist(health.policy?.host_v2_ready === true, 'R53 Host policy v2 is not ready');
+
+const evidence = {
+  schema: 'deadbyte.r53-windows-gate.v1',
+  status: 'passed',
+  exit_code: 0,
+  version: pkg.version,
+  train: 'R53',
+  completed_at_utc: new Date().toISOString(),
+  manifest_sha256: manifestSha256,
+  parent: release.parent,
+  runtime_predecessor: release.runtime_predecessor,
+  stabilization: release.stabilization,
+  operator_override: provenance.operator_override,
+  active_predecessor: {
+    release_id: active.release_id,
+    version: active.version,
+    manifest_sha256: active.manifest_sha256,
+    generation_manifest_sha256: active.generation_manifest_sha256
+  },
+  doctor: { verified_entries: health.manifest.verified_entries, host_v2_ready: true },
+  gates: {
+    r53_focused: true,
+    package_boundary: true,
+    release_smoke_isolation: true,
+    runtime_coherence: true,
+    coding_command_singleflight: true,
+    foreground_desktop_host_fail_closed: true,
+    full_regression: true,
+    commander_hardening: true,
+    donor_proof: true,
+    desktop_wait: true,
+    exact_catalog: true,
+    stdio_smokes: true,
+    manifest_final_verify: true,
+    four_hour_soak_completed: false
+  }
+};
+
+const bytes = Buffer.from(`${JSON.stringify(evidence, null, 2)}\n`);
+const dir = path.join(stateRoot, 'evidence', 'release');
+await mkdir(dir, { recursive: true });
+const target = path.join(dir, `r53-windows-gate-${manifestSha256.slice(0, 16)}.json`);
+
+try {
+  const handle = await open(target, 'wx', 0o600);
+  try { await handle.writeFile(bytes); await handle.sync(); }
+  finally { await handle.close(); }
+} catch (error) {
+  if (error?.code !== 'EEXIST') throw error;
+  const prior = JSON.parse(await readFile(target, 'utf8'));
+  insist(
+    prior.schema === evidence.schema &&
+    prior.status === 'passed' &&
+    prior.version === evidence.version &&
+    prior.manifest_sha256 === manifestSha256 &&
+    prior.parent?.release_id === release.parent.release_id &&
+    prior.operator_override?.four_hour_soak === 'NOT_COMPLETED',
+    'conflicting R53 gate evidence identity'
+  );
+}
+
+console.log(JSON.stringify({ status: 'passed', path: target, sha256: sha256(bytes), manifest_sha256: manifestSha256 }));

package/src/authority-smoke.mjs

@@ -60,6 +60,7 @@ const transport = new StdioClientTransport({
   cwd: repoRoot,
   env: {
     ...getDefaultEnvironment(),
+    DEADBYTE_STATE_ROOT: path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(trust,'state')),
     DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
     DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
     DEADBYTE_VERIFY_KEY: keys.publicKeyPath

package/src/deadbyte-cli.mjs

@@ -16,6 +16,8 @@ import { printDoctor } from './doctor-r45.mjs';
 import { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
 import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
 import { ensureRuntimeCoherence } from './runtime-coherence.mjs';
+import { windowsPowerShellEnvironment } from './runtime-update.mjs';
+import { resolveStateRoot } from './state-root.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
@@ -42,7 +44,7 @@ const CURRENT_DEPLOY_SCRIPT=path.join(CURRENT_PACKAGE_ROOT,'scripts','deploy-r48
 const REMOTE_UPDATE_TIMEOUT_MS=900000;
 const LIVE_LOG_DISCOVERY_INTERVAL_MS=1000;
 
-function stateRoot(){return path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));}
+function stateRoot(){return resolveStateRoot();}
 async function requireRegular(file,label){const info=await lstat(file);if(!info.isFile()||info.isSymbolicLink()) throw new Error(`${label} must be a regular non-symlink file`);return file;}
 function printHelp(){
   const exact=`deadbyte-mcp@${DEADBYTE_VERSION}`;
@@ -171,7 +173,7 @@ function invokeController(ctx,command,{capture=false,allowFailure=false,echoCapt
       stderrFd=openSync(redirectOutput.stderr_path,'w');
       stdio=['ignore',stdoutFd,stderrFd];
     }else stdio=capture?['ignore','pipe','pipe']:'inherit';
-    const options={stdio,encoding:capture?'utf8':undefined,windowsHide:false,shell:false};
+    const options={stdio,encoding:capture?'utf8':undefined,windowsHide:false,shell:false,env:windowsPowerShellEnvironment()};
     if(Number.isInteger(timeoutMs)&&timeoutMs>0) options.timeout=timeoutMs;
     result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],options);
   }finally{

package/src/doctor-r45.mjs

@@ -4,9 +4,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { DEADBYTE_VERSION, MCP_PROTOCOL_VERSION } from './version.mjs';
+import { resolveStateRoot } from './state-root.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
-const stateRoot=()=>path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const stateRoot=()=>resolveStateRoot();
 const sha256=b=>createHash('sha256').update(b).digest('hex');
 async function jsonOrNull(file){try{return JSON.parse((await readFile(file,'utf8')).replace(/^\uFEFF/,''));}catch(e){if(e?.code==='ENOENT')return null;throw e;}}
 async function fileHash(file){return sha256(await readFile(file));}

package/src/machine-fs-smoke-client.mjs

@@ -52,6 +52,7 @@ const client = new Client({ name: 'deadbyte-machine-fs-smoke', version: '0.8.0'
 const transport = new StdioClientTransport({
   command: process.execPath, args: [serverPath], cwd: repoRoot,
   env: { ...getDefaultEnvironment(), DEADBYTE_CODING_RUNTIME: '1', DEADBYTE_MACHINE_FS_RUNTIME: '1',
+    DEADBYTE_STATE_ROOT: path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(scratch,'state')),
     DEADBYTE_PRIVILEGED_POLICY: '',
     DEADBYTE_CODING_POLICY: policyPath, DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
     DEADBYTE_VERIFY_KEY: keys.publicKeyPath }, stderr: 'pipe'

package/src/mcp-contained-smoke-client.mjs

@@ -34,6 +34,7 @@ const transport = new StdioClientTransport({
   cwd: repoRoot,
   env: {
     ...getDefaultEnvironment(),
+    DEADBYTE_STATE_ROOT: path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(trust,'state')),
     DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
     DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
     DEADBYTE_VERIFY_KEY: keys.publicKeyPath

package/src/mcp-host-smoke-client.mjs

@@ -66,6 +66,7 @@ const transport = new StdioClientTransport({
   cwd: repoRoot,
   env: {
     ...getDefaultEnvironment(),
+    DEADBYTE_STATE_ROOT: path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(temp,'state')),
     DEADBYTE_WORKSPACE_ROOT: path.join(repoRoot, 'workspaces'),
     DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
     DEADBYTE_VERIFY_KEY: keys.publicKeyPath,

package/src/mcp-smoke-client.mjs

@@ -37,6 +37,7 @@ const transport = new StdioClientTransport({
   cwd: repoRoot,
   env: {
     ...getDefaultEnvironment(),
+    DEADBYTE_STATE_ROOT: path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(smokeTrust,'state')),
     DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
     DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
     DEADBYTE_VERIFY_KEY: keys.publicKeyPath,

package/src/process-smoke-client.mjs

@@ -39,6 +39,7 @@ const client = new Client({ name: 'deadbyte-process-smoke', version: '0.8.0' },
 const transport = new StdioClientTransport({
   command: process.execPath, args: [serverPath], cwd: repoRoot,
   env: { ...getDefaultEnvironment(), DEADBYTE_PRIVILEGED_POLICY: '', DEADBYTE_MACHINE_RUNTIME:'0', DEADBYTE_AGENT_RUNTIME:'0',
+    DEADBYTE_STATE_ROOT: path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(smokeTrust,'state')),
     DEADBYTE_PROCESS_RUNTIME: '1', DEADBYTE_PROCESS_POLICY: smokePolicyPath, DEADBYTE_CODING_RUNTIME:'0', DEADBYTE_MACHINE_FS_RUNTIME:'0',
     DEADBYTE_OBSERVATION_RUNTIME:'0', DEADBYTE_DESKTOP_RUNTIME:'0', DEADBYTE_AUTONOMOUS_RUNTIME:'0', DEADBYTE_AUDIT_RUNTIME:'0',
     DEADBYTE_CAPABILITY_PROFILE:'full', DEADBYTE_SIGNING_KEY: keys.privateKeyPath, DEADBYTE_VERIFY_KEY: keys.publicKeyPath },

package/src/release-slot.mjs

@@ -195,7 +195,8 @@ export function renderStableLauncherCmd(){
   return [
     '@echo off',
     'setlocal EnableExtensions DisableDelayedExpansion',
-    'powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File "%USERPROFILE%\\.deadbyte-mcp\\bin\\DEADBYTE-MCP.ps1" %*',
+    'if not defined DEADBYTE_STATE_ROOT set "DEADBYTE_STATE_ROOT=%USERPROFILE%\\.deadbyte-mcp"',
+    'powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File "%DEADBYTE_STATE_ROOT%\\bin\\DEADBYTE-MCP.ps1" %*',
     'exit /b %ERRORLEVEL%',
     ''
   ].join('\r\n');
@@ -208,7 +209,9 @@ export function renderStableLauncherPs1(){
     'param([Parameter(ValueFromRemainingArguments=$true)][string[]]$ControllerArgs)',
     'Set-StrictMode -Version 3.0',
     "$ErrorActionPreference = 'Stop'",
-    "$StateRoot = Join-Path $env:USERPROFILE '.deadbyte-mcp'",
+    "$StateRoot = if ([string]::IsNullOrEmpty($env:DEADBYTE_STATE_ROOT)) { Join-Path $env:USERPROFILE '.deadbyte-mcp' } else { $env:DEADBYTE_STATE_ROOT }",
+    '$StateRoot = [IO.Path]::GetFullPath($StateRoot)',
+    '$env:DEADBYTE_STATE_ROOT = $StateRoot',
     "$PointerPath = Join-Path $StateRoot 'active-release.json'",
     "function Fail([string]$m) { throw ('DEADBYTE launcher: ' + $m) }",
     "if (-not (Test-Path -LiteralPath $PointerPath -PathType Leaf)) { Fail 'active release pointer missing' }",

package/src/remote-session-guardian.mjs

@@ -4,6 +4,8 @@ import { spawnSync } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
+import { windowsPowerShellEnvironment } from './runtime-update.mjs';
+import { resolveStateRoot } from './state-root.mjs';
 
 const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park'];
 
@@ -36,9 +38,9 @@ function markerMatches(marker,{ownerPid,nonce}){
     marker?.owner_pid===ownerPid&&
     marker?.session_nonce===nonce;
 }
-function invokeCleanup(powershell,launcher,command){
+function invokeCleanup(powershell,launcher,command,stateRoot){
   const result=spawnSync(powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,command],{
-    stdio:'ignore',windowsHide:true,shell:false
+    stdio:'ignore',windowsHide:true,shell:false,env:windowsPowerShellEnvironment({...process.env,DEADBYTE_STATE_ROOT:stateRoot}),timeout:30000
   });
   return !result.error&&result.status===0;
 }
@@ -46,7 +48,7 @@ function invokeCleanup(powershell,launcher,command){
 async function main(){
   if(process.platform!=='win32') return;
   const args=parseArgs(process.argv.slice(2));
-  const root=path.resolve(args['state-root']||path.join(os.homedir(),'.deadbyte-mcp'));
+  const root=resolveStateRoot(args['state-root']);
   const ownerPid=Number(args['owner-pid']);
   const nonce=String(args['session-nonce']||'');
   if(!Number.isInteger(ownerPid)||ownerPid<1) throw new Error('guardian owner pid invalid');
@@ -66,7 +68,13 @@ async function main(){
       continue;
     }
 
-    for(const command of CLEANUP) invokeCleanup(powershell,launcher,command);
+    const failed=[];
+    for(const command of CLEANUP){
+      const latest=await readMarker(markerPath);
+      if(!latest||!markerMatches(latest,{ownerPid,nonce})) return;
+      if(!invokeCleanup(powershell,launcher,command,root)) failed.push(command);
+    }
+    if(failed.length) throw new Error('guardian cleanup failed; ownership marker retained: '+failed.join(','));
     const current=await readMarker(markerPath);
     if(current&&markerMatches(current,{ownerPid,nonce})) await rm(markerPath,{force:true});
     return;

package/src/runtime-coherence.mjs

@@ -1,10 +1,10 @@
-const SEMVER=/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+const SEMVER=/^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 const HEX64=/^[0-9a-f]{64}$/;
 
 function parseSemver(value){
   const match=SEMVER.exec(String(value??''));
-  if(!match) throw new Error(`runtime version invalid: ${String(value)}`);
-  return {major:Number(match[1]),minor:Number(match[2]),patch:Number(match[3]),prerelease:match[4]??null};
+  if(!match||match[0]!==String(value??'')||(match[4]??'').split('.').some(id=>/^0[0-9]+$/.test(id))) throw new Error(`runtime version invalid: ${String(value)}`);
+  return {major:BigInt(match[1]),minor:BigInt(match[2]),patch:BigInt(match[3]),prerelease:match[4]??null};
 }
 export function compareRuntimeVersions(a,b){
   const left=parseSemver(a),right=parseSemver(b);
@@ -12,7 +12,16 @@ export function compareRuntimeVersions(a,b){
   if(left.prerelease===right.prerelease) return 0;
   if(left.prerelease===null) return 1;
   if(right.prerelease===null) return -1;
-  return left.prerelease.localeCompare(right.prerelease,'en',{numeric:true,sensitivity:'case'});
+  const aIds=left.prerelease.split('.'),bIds=right.prerelease.split('.');
+  for(let i=0;i<Math.min(aIds.length,bIds.length);i++){
+    const x=aIds[i],y=bIds[i];
+    if(x===y) continue;
+    const xn=/^[0-9]+$/.test(x),yn=/^[0-9]+$/.test(y);
+    if(xn&&yn) return BigInt(x)<BigInt(y)?-1:1;
+    if(xn!==yn) return xn?-1:1;
+    return x<y?-1:1;
+  }
+  return aIds.length<bIds.length?-1:aIds.length>bIds.length?1:0;
 }
 function assertManifest(value,label){
   if(!HEX64.test(String(value??''))) throw new Error(`${label} must be lowercase SHA-256`);

package/src/runtime-update.mjs

@@ -17,6 +17,7 @@ import {
   verifyManifestTree
 } from './release-slot.mjs';
 import { createGenerationBundle, verifyGenerationBundle } from './release-generation.mjs';
+import { resolveStateRoot } from './state-root.mjs';
 
 const HEX64=/^[0-9a-f]{64}$/;
 const SEMVER=/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -25,7 +26,7 @@ const UPDATE_SCHEMA='deadbyte.r27-slot-update-receipt.v1';
 const HANDOFF_SCHEMA='deadbyte.r27-slot-update-handoff.v1';
 const FAILURE_SCHEMA='deadbyte.r27-slot-update-failure.v1';
 const ROLLBACK_SCHEMA='deadbyte.r31-slot-rollback-receipt.v1';
-const DEFAULT_STATE_ROOT=path.join(os.homedir(),'.deadbyte-mcp');
+const DEFAULT_STATE_ROOT=undefined;
 const TOP_LAUNCHER=path.join(os.homedir(),'Downloads','DEADBYTE-MCP.cmd');
 const RUNTIME_STABILITY_MS=12000;
 const RUNTIME_STABILITY_POLL_MS=500;
@@ -195,11 +196,21 @@ export function windowsPowerShellEnvironment(base=process.env){
   const systemRoot=base.SystemRoot||base.SYSTEMROOT||'C:\\Windows';
   const userProfile=base.USERPROFILE||os.homedir();
   const programFiles=base.ProgramFiles||base.PROGRAMFILES||'C:\\Program Files';
-  return {...base,PSModulePath:[
+  const environment={...base};
+  const inherited=Object.entries(base).filter(([key])=>key.toLowerCase()==='psmodulepath').flatMap(([,value])=>String(value??'').split(';')).filter(Boolean);
+  for(const key of Object.keys(environment)) if(key.toLowerCase()==='psmodulepath') delete environment[key];
+  const modules=[
+    path.join(systemRoot,'System32','WindowsPowerShell','v1.0','Modules'),
     path.join(userProfile,'Documents','WindowsPowerShell','Modules'),
     path.join(programFiles,'WindowsPowerShell','Modules'),
-    path.join(systemRoot,'System32','WindowsPowerShell','v1.0','Modules')
-  ].join(';')};
+    ...inherited
+  ];
+  const seen=new Set();
+  return {...environment,PSModulePath:modules.filter(modulePath=>{
+    const key=modulePath.toLowerCase();
+    if(seen.has(key)) return false;
+    seen.add(key);return true;
+  }).join(';')};
 }
 function commandEnvironment(exe,base=process.env){
   return path.resolve(exe).toLowerCase()===path.resolve(powershellPath()).toLowerCase()
@@ -582,7 +593,7 @@ function controllerInvocation(ctx,command){
     exe:powershellPath(),
     args:['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.controller_path,command],
     cwd:ctx.cwd,
-    env:{...process.env,DEADBYTE_CONTROLLER_CONFIG:ctx.pointer.config_path,DEADBYTE_CONTROLLER_RUNTIME_ROOT:ctx.runtime_root}
+    env:{...process.env,DEADBYTE_STATE_ROOT:resolveStateRoot(ctx.state_root),DEADBYTE_CONTROLLER_CONFIG:ctx.pointer.config_path,DEADBYTE_CONTROLLER_RUNTIME_ROOT:ctx.runtime_root}
   };
   return {exe:powershellPath(),args:['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.controller_path,command],cwd:ctx.cwd};
 }
@@ -1411,6 +1422,7 @@ async function resumeSlotUpdate({handoffPath}){
   }
 }
 export async function recoverInterruptedSlotUpdates({stateRoot=DEFAULT_STATE_ROOT}={}){
+  stateRoot=resolveStateRoot(stateRoot);
   const evidenceRoot=path.join(path.resolve(stateRoot),'evidence','updates');
   if(!existsSync(evidenceRoot)) return {ok:true,launched:0,updates:[]};
   const entries=await readdir(evidenceRoot,{withFileTypes:true});
@@ -1443,6 +1455,7 @@ export async function recoverInterruptedSlotUpdates({stateRoot=DEFAULT_STATE_ROO
 }
 
 export async function performSlotUpdate({stage,developmentRoot,expectedVersion,expectedManifest,sourceRoot=null,stateRoot=DEFAULT_STATE_ROOT,restoreStandingGrants=false,recoverOfflinePredecessor=false,cloudTransport=null,bridgeBootstrap=null,processPolicyBootstrap=null,hostPolicyBootstrap=null,codingPolicyBootstrap=null,desktopPolicyBootstrap=null,semanticLspBootstrap=null,enableMachineFs=false,enableObservation=false,enableDesktop=false,enableAutonomousSupervisor=false,hostCommandPins=[]}){
+  stateRoot=resolveStateRoot(stateRoot);
   if(process.platform!=='win32') throw new Error('R27 slot update is Windows-only');
   const state=path.resolve(stateRoot),stageRoot=path.resolve(stage),development=assertDevelopmentRootSafe(developmentRoot,state);
   const key=await loadUpdateKey(state),updateId='r27-'+expectedManifest.slice(0,16)+'-'+Date.now().toString(36)+'-'+randomBytes(4).toString('hex');
@@ -1527,6 +1540,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
 }
 
 export async function performSlotRollback({activationReceipt,stateRoot=DEFAULT_STATE_ROOT}){
+  stateRoot=resolveStateRoot(stateRoot);
   if(process.platform!=='win32') throw new Error('R31 slot rollback is Windows-only');
   const state=path.resolve(stateRoot),receiptFile=path.resolve(activationReceipt);
   const key=await loadUpdateKey(state);
@@ -1578,6 +1592,7 @@ export async function performSlotRollback({activationReceipt,stateRoot=DEFAULT_S
 }
 
 export async function runSlotUpdateCli(argv=process.argv.slice(2),{stateRoot=DEFAULT_STATE_ROOT}={}){
+  stateRoot=resolveStateRoot(stateRoot);
   if(argv.includes('--rollback-receipt')){
     const args=parseRollbackArgs(argv);
     const result=await performSlotRollback({activationReceipt:args.activationReceipt,stateRoot});

package/src/state-root.mjs

@@ -0,0 +1,8 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export function resolveStateRoot(explicit,environment=process.env){
+  const value=explicit===undefined?(environment.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')):explicit;
+  if(typeof value!=='string'||value.length===0||value.includes('\0')) throw new Error('state root invalid');
+  return path.resolve(value);
+}

package/src/trust.mjs

@@ -9,11 +9,12 @@ import { mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { sha256Bytes } from './hash.mjs';
+import { resolveStateRoot } from './state-root.mjs';
 
 const DOMAIN = Buffer.from('DEADBYTE-RECEIPT-V1\0', 'utf8');
 
 export function defaultTrustDir() {
-  return path.join(os.homedir(), '.deadbyte-mcp', 'trust');
+  return path.join(resolveStateRoot(), 'trust');
 }
 
 export function defaultPrivateKeyPath() {

package/src/tunnel-stdio-compat-smoke.mjs

@@ -101,6 +101,7 @@ async function modernPassThrough() {
     cwd: repoRoot,
     env: {
       ...getDefaultEnvironment(),
+      ...(process.env.DEADBYTE_STATE_ROOT?{DEADBYTE_STATE_ROOT:path.resolve(process.env.DEADBYTE_STATE_ROOT)}:{}),
       DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
       DEADBYTE_PRIVILEGED_POLICY: '',
       DEADBYTE_TUNNEL_STDIO_PROBE_COMPAT: '1'

package/src/version.mjs

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

package/test/commander-biff-reference-r48.test.mjs

@@ -6,7 +6,7 @@ import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-const oracleRoot='C:\\Users\\DEADBYTE\\.deadbyte-mcp\\evidence\\commander-biff-oracle';
+const oracleRoot=process.env.DEADBYTE_BIFF_TEST_ORACLE||'C:\\Users\\DEADBYTE\\.deadbyte-mcp\\evidence\\commander-biff-oracle';
 const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
 
 test('pinned reference rejects a real BIFF8 workbook and writes OOXML bytes under .xls',async()=>{

package/test/r44-finalizer.test.mjs

@@ -34,15 +34,16 @@ test('R44 detached finalizer accepts only exact signed-R43-parent feature gate e
   assert.throws(()=>validateWindowsGateEvidence({...valid(),features:{...features(),skill_integrity:false}},manifest,parent),/skill_integrity/);
 });
 
-test('R44 detached finalizer isolates Windows PowerShell modules from the parent runtime',()=>{
+test('R44 detached finalizer prioritizes native Windows modules and preserves custom paths',()=>{
   const env=windowsPowerShellEnvironment({
     SystemRoot:'C:\\Windows',USERPROFILE:'C:\\Users\\operator',ProgramFiles:'C:\\Program Files',
     PSModulePath:'C:\\poisoned-runtime-modules'
   });
   assert.equal(env.PSModulePath,[
+    'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\Modules',
     'C:\\Users\\operator\\Documents\\WindowsPowerShell\\Modules',
     'C:\\Program Files\\WindowsPowerShell\\Modules',
-    'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\Modules'
+    'C:\\poisoned-runtime-modules'
   ].join(';'));
-  assert.doesNotMatch(env.PSModulePath,/poisoned-runtime-modules/);
+  assert.equal(env.PSModulePath.split(';')[0],'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\Modules');
 });

package/test/r49-windows-gate.test.mjs

@@ -4,9 +4,11 @@ import test from 'node:test';
 
 const read = path => readFile(new URL(`../${path}`, import.meta.url), 'utf8');
 
-test('R52 canonical Windows gate is successor-bound and preserves R51/R50/R49 historical gates', async () => {
-  const [pkgText, gate, evidence, historicalR51, historicalEvidenceR51, historicalR50, historicalR49, deferred] = await Promise.all([
+test('R53 canonical Windows gate is successor-bound and preserves R52/R51/R50/R49 historical gates', async () => {
+  const [pkgText, gate, evidence, historicalR52, historicalEvidenceR52, historicalR51, historicalEvidenceR51, historicalR50, historicalR49, deferred] = await Promise.all([
     read('package.json'),
+    read('scripts/gate-windows-r53.ps1'),
+    read('scripts/windows-gate-evidence-r53.mjs'),
     read('scripts/gate-windows-r52.ps1'),
     read('scripts/windows-gate-evidence-r52.mjs'),
     read('scripts/gate-windows-r51.ps1'),
@@ -16,17 +18,20 @@ test('R52 canonical Windows gate is successor-bound and preserves R51/R50/R49 hi
     read('scripts/deferred-slot-operation-r46.mjs')
   ]);
   const pkg = JSON.parse(pkgText);
-  assert.match(pkg.scripts['gate:windows'], /gate-windows-r52\.ps1$/);
-  assert.match(gate, /DEADBYTE 0\.15\.29 \/ R52 WINDOWS GATE: PASS/);
-  assert.match(gate, /r52-package-boundary/);
-  assert.match(gate, /r52-focused-contracts/);
+  assert.match(pkg.scripts['gate:windows'], /gate-windows-r53\.ps1$/);
+  assert.match(gate, /DEADBYTE 0\.15\.30 \/ R53 WINDOWS GATE: PASS/);
+  assert.match(gate, /r53-package-boundary/);
+  assert.match(gate, /r53-focused-contracts/);
   assert.match(gate, /r49-remote-control-donors\.test\.mjs/);
   assert.match(gate, /desktop-runtime-r40\.test\.mjs/);
   assert.match(gate, /manifest-final-verify/);
-  assert.match(evidence, /deadbyte\.r52-windows-gate\.v1/);
-  assert.match(evidence, /pkg\.version === '0\.15\.29'/);
-  assert.match(evidence, /release\.train === 'R52'/);
-  assert.match(evidence, /source_predecessor\.version === '0\.15\.28'/);
+  assert.match(evidence, /deadbyte\.r53-windows-gate\.v1/);
+  assert.match(evidence, /pkg\.version === '0\.15\.30'/);
+  assert.match(evidence, /release\.train === 'R53'/);
+  assert.match(evidence, /release\.parent\.version === '0\.15\.29'/);
+  assert.match(evidence, /four_hour_soak_completed: false/);
+  assert.match(historicalR52, /DEADBYTE 0\.15\.29 \/ R52 WINDOWS GATE: PASS/);
+  assert.match(historicalEvidenceR52, /deadbyte\.r52-windows-gate\.v1/);
   assert.match(historicalR51, /DEADBYTE 0\.15\.28 \/ R51 WINDOWS GATE: PASS/);
   assert.match(historicalEvidenceR51, /deadbyte\.r51-windows-gate\.v1/);
   assert.match(historicalR50, /DEADBYTE 0\.15\.27 \/ R50 WINDOWS GATE: PASS/);

package/test/r52-release-contract.test.mjs

@@ -5,8 +5,12 @@ import { readFile } from 'node:fs/promises';
 const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 const json=rel=>read(rel).then(JSON.parse);
+const current=await json('package.json');
+const historical=current.version!=='0.15.29';
+const skipHistorical=t=>{if(historical){t.skip('R52 historical release contract is frozen at 0.15.29; current successor is '+current.version);return true;}return false;};
 
-test('R52 current release identity is coherent across package lock source metadata SBOM and gate',async()=>{
+test('R52 current release identity is coherent across package lock source metadata SBOM and gate',async t=>{
+  if(skipHistorical(t))return;
   const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([
     json('package.json'),json('package-lock.json'),json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs')
   ]);
@@ -25,7 +29,8 @@ test('R52 current release identity is coherent across package lock source metada
   assert.match(pkg.scripts['r52:focused:test'],/r52-offline-predecessor-recovery\.test\.mjs/);
 });
 
-test('R52 lineage binds published 0.15.28 parent separately from 0.15.27 runtime rollback target',async()=>{
+test('R52 lineage binds published 0.15.28 parent separately from 0.15.27 runtime rollback target',async t=>{
+  if(skipHistorical(t))return;
   const [release,provenance]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json')]);
   const activeParent={
     release_id:'v0.15.27-1b1dbe24b45ad06a',
@@ -52,7 +57,8 @@ test('R52 lineage binds published 0.15.28 parent separately from 0.15.27 runtime
   assert.equal(provenance.source_predecessor_activation_failure_receipt_sha256,'090f165c96da0d5a8e9c0815fd389fe94e8fe36c23a6878ee825b8f46bfb0bc2');
 });
 
-test('R52 advertises updater-owned offline predecessor Host revocation only after implementation',async()=>{
+test('R52 advertises updater-owned offline predecessor Host revocation only after implementation',async t=>{
+  if(skipHistorical(t))return;
   const release=await json('RELEASE.json');
   assert.equal(release.capabilities.offline_predecessor_host_revoke_before_capture,true);
 });

package/test/r53-release-contract.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const root=new URL('../',import.meta.url);
+const read=rel=>readFile(new URL(rel,root),'utf8');
+const json=rel=>read(rel).then(JSON.parse);
+
+test('R53 current release identity is coherent across package lock source metadata SBOM and gate',async()=>{
+  const [pkg,lock,release,provenance,matrix,sbom,versionSource]=await Promise.all([
+    json('package.json'),json('package-lock.json'),json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs')
+  ]);
+  assert.equal(pkg.version,'0.15.30');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.30'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R53');
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R53');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r53:0.15.30');
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r53\.ps1/);
+  assert.match(pkg.scripts['r53:focused:test'],/stabilization-semver\.test\.mjs/);
+});
+
+test('R53 lineage binds exact published 0.15.29 as parent and runtime predecessor',async()=>{
+  const [release,provenance]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json')]);
+  const parent={
+    release_id:'v0.15.29-f74eaa1b3d00e6fb',
+    manifest_sha256:'f74eaa1b3d00e6fb5a36b2358efb815e3686c9fe9dbd3b84d25a713ef957748c',
+    generation_manifest_sha256:'289b4fc065de0681da6864cc1bbe09aab198ca804945ffc27c786438dad13f5a'
+  };
+  assert.deepEqual(release.runtime_predecessor,parent);
+  assert.equal(release.parent.version,'0.15.29');
+  assert.equal(release.parent.release_id,parent.release_id);
+  assert.equal(release.parent.manifest_sha256,parent.manifest_sha256);
+  assert.equal(release.parent.generation_manifest_sha256,parent.generation_manifest_sha256);
+  assert.equal(release.parent.tarball_sha256,'f535d7121a384bed106d34bc7525afa9d4048c7e290f270699e25136d1e82eeb');
+  assert.equal(release.source_predecessor.version,'0.15.29');
+  assert.equal(release.source_predecessor.tarball_sha256,release.parent.tarball_sha256);
+  assert.equal(release.source_predecessor.manifest_file_sha256,release.parent.manifest_sha256);
+  assert.equal(release.source_predecessor.generation_manifest_sha256,release.parent.generation_manifest_sha256);
+  assert.equal(provenance.parent_release_id,parent.release_id);
+  assert.equal(provenance.parent_manifest_sha256,parent.manifest_sha256);
+  assert.equal(provenance.parent_generation_manifest_sha256,parent.generation_manifest_sha256);
+  assert.equal(provenance.parent_tarball_sha256,release.parent.tarball_sha256);
+  assert.deepEqual(provenance.runtime_predecessor,parent);
+});
+
+test('R53 records stabilization evidence and explicit soak bypass without STABLE/FINAL claim',async()=>{
+  const [release,provenance,matrix]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json')]);
+  assert.equal(release.stabilization.semver_strict_validation,true);
+  assert.equal(release.stabilization.powershell_child_environment_normalized,true);
+  assert.equal(release.stabilization.explicit_state_root_propagation,true);
+  assert.equal(release.stabilization.guardian_cleanup_fail_closed,true);
+  assert.equal(release.stabilization.local_isolated_state_acceptance,'PASS');
+  assert.equal(release.stabilization.full_regression,'PASS');
+  assert.equal(release.stabilization.four_hour_soak,'NOT_COMPLETED_OPERATOR_BYPASS');
+  assert.equal(release.stabilization.stable_final_claim,false);
+  assert.equal(provenance.operator_override.four_hour_soak,'NOT_COMPLETED');
+  assert.equal(provenance.operator_override.stable_final_claim,false);
+  assert.equal(matrix.operator_override.four_hour_soak,'NOT_COMPLETED');
+  assert.equal(matrix.operator_override.stable_final_claim,false);
+});

package/test/release-slot.test.mjs

@@ -104,7 +104,8 @@ test('R27 active pointer is schema bound and atomically replaceable', async () =
 test('R27 stable launcher resolves only the active pointer, not a release hardcode', () => {
   const cmd=renderStableLauncherCmd();
   const ps1=renderStableLauncherPs1();
-  assert.match(cmd,/\.deadbyte-mcp\\bin\\DEADBYTE-MCP\.ps1/i);
+  assert.match(cmd,/if not defined DEADBYTE_STATE_ROOT set "DEADBYTE_STATE_ROOT=%USERPROFILE%\\\.deadbyte-mcp"/i);
+  assert.match(cmd,/%DEADBYTE_STATE_ROOT%\\bin\\DEADBYTE-MCP\.ps1/i);
   assert.doesNotMatch(cmd,/deadbyte-mcp-v0\.6\.0/i);
   assert.match(ps1,/active-release\.json/);
   assert.match(ps1,/DEADBYTE_CONTROLLER_CONFIG/);