deadbyte-mcp 0.15.28 → 0.15.30

package/test/r52-offline-predecessor-recovery.test.mjs

@@ -0,0 +1,77 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as runtimeUpdate from '../src/runtime-update.mjs';
+
+async function fixture(t,{revoke='success',armed=true}={}) {
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r52-offline-host-'));
+  t.after(()=>rm(base,{recursive:true,force:true}));
+  const controllerDir=path.join(base,'controller');
+  const runtimeDir=path.join(controllerDir,'runtime');
+  await mkdir(runtimeDir,{recursive:true});
+  const marker=path.join(runtimeDir,'host-grant.json');
+  if(armed) await writeFile(marker,'stale-host-grant\n','utf8');
+  const revokeSource=revoke==='failure' ? 'exit 7' : revoke==='unchanged' ? 'exit 0' : 'Remove-Item -LiteralPath $marker -Force -ErrorAction SilentlyContinue; exit 0';
+  const controller=[
+    'param([string]$Command)',
+    '$marker = Join-Path $PSScriptRoot "runtime\\host-grant.json"',
+    `if($Command -eq "disarmhost"){ ${revokeSource} }`,
+    'if($Command -eq "status"){',
+    '  if(Test-Path -LiteralPath $marker){ $hostState = "ARMED [standing-grant]" } else { $hostState = "DISARMED [disarmed]" }',
+    '  Write-Output "DEADBYTE MCP = OFFLINE"',
+    '  Write-Output "Bridge PID   : -"',
+    '  Write-Output "Cloud PID    : -"',
+    '  Write-Output "Local ready  : False"',
+    '  Write-Output "Process plane  : DISARMED [disarmed]"',
+    '  Write-Output "Coding plane   : DISARMED [disarmed]"',
+    '  Write-Output "Autonomous     : DISARMED [disarmed]"',
+    '  Write-Output "Desktop plane : DISARMED [disarmed]"',
+    '  Write-Output ("Host plane    : {0}" -f $hostState)',
+    '  exit 0',
+    '}',
+    'exit 9'
+  ].join('\r\n');
+  await writeFile(path.join(controllerDir,'deadbyte-controller.ps1'),controller,'utf8');
+  return {base,marker};
+}
+
+test('R52 offline predecessor recovery revokes stale Host authority before capture', async t => {
+  if(process.platform!=='win32'){ t.skip('Windows controller regression'); return; }
+  assert.equal(typeof runtimeUpdate.capturePredecessor,'function','capturePredecessor must be behavior-testable');
+  const {base,marker}=await fixture(t);
+  const result=await runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),true);
+  assert.equal(result.mode,'offline-recovery');
+  assert.equal(result.status.host_armed,false);
+  await assert.rejects(readFile(marker,'utf8'),error=>error?.code==='ENOENT');
+});
+
+test('R52 offline predecessor fails closed if Host revoke returns success but grant remains',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows controller regression');return;}
+  const {base,marker}=await fixture(t,{revoke:'unchanged'});
+  await assert.rejects(runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),true),/requires host plane DISARMED/);
+  assert.equal(await readFile(marker,'utf8'),'stale-host-grant\n');
+});
+
+test('R52 failed Host revoke leaves predecessor grant intact and denies capture',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows controller regression');return;}
+  const {base,marker}=await fixture(t,{revoke:'failure'});
+  await assert.rejects(runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),true));
+  assert.equal(await readFile(marker,'utf8'),'stale-host-grant\n');
+});
+
+test('R52 disarmed offline predecessor is accepted without invoking a failing revoke',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows controller regression');return;}
+  const {base}=await fixture(t,{revoke:'failure',armed:false});
+  const result=await runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),true);
+  assert.equal(result.mode,'offline-recovery');
+  assert.equal(result.status.host_armed,false);
+});
+
+test('R52 offline recovery requires explicit opt-in before any Host revocation',async t=>{
+  if(process.platform!=='win32'){t.skip('Windows controller regression');return;}
+  const {base,marker}=await fixture(t);
+  await assert.rejects(runtimeUpdate.capturePredecessor(runtimeUpdate.legacyContext(base),false),/requires ONLINE runtime/);
+  assert.equal(await readFile(marker,'utf8'),'stale-host-grant\n');
+});

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

@@ -0,0 +1,64 @@
+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);
+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 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')
+  ]);
+  assert.equal(pkg.version,'0.15.29');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.29'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R52');
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R52');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r52:0.15.29');
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r52\.ps1/);
+  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 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',
+    manifest_sha256:'1b1dbe24b45ad06a62771d15f510662952f3d7c3e5aa08053c6c61511c523e47',
+    generation_manifest_sha256:'f87a1637b3c55ba050d079d8a5e0862a2244b306be7e985880708e0d8ded3db0'
+  };
+  assert.deepEqual(release.runtime_predecessor,activeParent);
+  assert.equal(release.parent.release_id,'v0.15.28-b879bdff63478f28');
+  assert.equal(release.parent.version,'0.15.28');
+  assert.equal(release.parent.manifest_sha256,release.source_predecessor.manifest_file_sha256);
+  assert.equal(release.parent.tarball_sha256,release.source_predecessor.tarball_sha256);
+  assert.equal(release.parent.generation_manifest_sha256,undefined);
+  assert.equal(release.source_predecessor.version,'0.15.28');
+  assert.equal(release.source_predecessor.tarball_sha256,'0a74332ba715d80a532dc871ece4826bdb917b8c7a442e71388a06d44698c411');
+  assert.equal(release.source_predecessor.manifest_file_sha256,'b879bdff63478f28d5dafadeedc8182a8fd090ab676dc0ff3566ea51ee07326f');
+  assert.equal(provenance.parent_release_id,release.parent.release_id);
+  assert.equal(provenance.parent_manifest_sha256,release.parent.manifest_sha256);
+  assert.equal(provenance.parent_tarball_sha256,release.parent.tarball_sha256);
+  assert.deepEqual(provenance.runtime_predecessor,activeParent);
+  assert.equal(provenance.parent_generation_manifest_sha256,undefined);
+  assert.equal(provenance.source_predecessor_version,'0.15.28');
+  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,release.source_predecessor.manifest_file_sha256);
+  assert.equal(provenance.source_predecessor_activation_failure_receipt_sha256,'090f165c96da0d5a8e9c0815fd389fe94e8fe36c23a6878ee825b8f46bfb0bc2');
+});
+
+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/);

package/test/skill-mcp-r44.test.mjs

@@ -6,6 +6,7 @@ import { mkdtemp, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { generateTrustKeypair } from '../src/trust.mjs';
 
 const here=path.dirname(fileURLToPath(import.meta.url));
 const repoRoot=path.resolve(here,'..');
@@ -13,8 +14,10 @@ const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
 
 test('R44 compact surface exposes one read-only skill_catalog without authority',async()=>{
   const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-skill-mcp-'));
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(state,'trust','private.pem'),publicKeyPath:path.join(state,'trust','public.pem')});
   const client=new Client({name:'deadbyte-r44-skill-mcp',version:'0.15.0-dev'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
   const env={...getDefaultEnvironment(),DEADBYTE_STATE_ROOT:state,DEADBYTE_CAPABILITY_PROFILE:'compact',
+    DEADBYTE_SIGNING_KEY:keys.privateKeyPath,DEADBYTE_VERIFY_KEY:keys.publicKeyPath,
     DEADBYTE_AUDIT_RUNTIME:'0',DEADBYTE_MACHINE_RUNTIME:'0',DEADBYTE_AGENT_RUNTIME:'0',
     DEADBYTE_PROCESS_RUNTIME:'0',DEADBYTE_CODING_RUNTIME:'0',DEADBYTE_MACHINE_FS_RUNTIME:'0',
     DEADBYTE_OBSERVATION_RUNTIME:'0',DEADBYTE_DESKTOP_RUNTIME:'0',DEADBYTE_AUTONOMOUS_RUNTIME:'0'};

package/test/stabilization-guardian.test.mjs

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+
+test('failed guardian cleanup preserves ownership evidence and reports failure',async()=>{
+  const base='D:/Projects/deadbyte-mcp/testing/0.15.30';
+  await mkdir(base,{recursive:true});
+  const root=await mkdtemp(path.join(base,'guardian-failure-'));
+  await mkdir(path.join(root,'bin'),{recursive:true});
+  await mkdir(path.join(root,'runtime'),{recursive:true});
+  const observedRoot=path.join(root,'observed-root.txt');
+  await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`[IO.File]::WriteAllText('${observedRoot.replaceAll("'","''")}',[string]$env:DEADBYTE_STATE_ROOT)\nexit 1\n`);
+  const owner=spawnSync(process.execPath,['-e','process.exit(0)']);
+  assert.equal(owner.status,0);
+  const marker={schema:'deadbyte.remote-session.v2',owner_pid:owner.pid,session_nonce:'a'.repeat(64)};
+  const markerPath=path.join(root,'runtime','remote-session.json');
+  await writeFile(markerPath,JSON.stringify(marker));
+  const result=spawnSync(process.execPath,['src/remote-session-guardian.mjs','--state-root',root,'--owner-pid',String(owner.pid),'--session-nonce',marker.session_nonce],{encoding:'utf8',timeout:20000,env:{...process.env,DEADBYTE_STATE_ROOT:path.join(base,'different-guardian-parent')}});
+  assert.equal(result.error,undefined,String(result.error));
+  assert.notEqual(result.status,0,'cleanup failure must not report success');
+  assert.deepEqual(JSON.parse(await readFile(markerPath,'utf8')),marker);
+  assert.equal(await readFile(observedRoot,'utf8'),root);
+});

package/test/stabilization-parent-context.test.mjs

@@ -0,0 +1,18 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp} from 'node:fs/promises';
+import path from 'node:path';
+import {generateTrustKeypair} from '../src/trust.mjs';
+import {verifyR43Parent} from '../scripts/verify-r43-parent.mjs';
+
+test('historical parent verifier rejects a different explicit public key',async()=>{
+  const base='D:/Projects/deadbyte-mcp/testing/0.15.30';
+  await mkdir(base,{recursive:true});
+  const root=await mkdtemp(path.join(base,'historical-key-context-'));
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(root,'private.pem'),publicKeyPath:path.join(root,'public.pem')});
+  const prior=process.env.DEADBYTE_PARENT_VERIFY_KEY;
+  try{
+    process.env.DEADBYTE_PARENT_VERIFY_KEY=keys.publicKeyPath;
+    await assert.rejects(verifyR43Parent(new URL('../R43-PARENT.json',import.meta.url)),/activation signer mismatch/);
+  }finally{if(prior===undefined)delete process.env.DEADBYTE_PARENT_VERIFY_KEY;else process.env.DEADBYTE_PARENT_VERIFY_KEY=prior;}
+});

package/test/stabilization-powershell.test.mjs

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {windowsPowerShellEnvironment} from '../src/runtime-update.mjs';
+
+test('child normalization preserves custom module paths and unrelated environment',()=>{
+  const base={...process.env,PSModulePath:'D:\\custom-modules;D:\\other-modules',STABILIZATION_SENTINEL:'preserved'};
+  const normalized=windowsPowerShellEnvironment(base);
+  assert.ok(normalized.PSModulePath.split(';').includes('D:\\custom-modules'));
+  assert.ok(normalized.PSModulePath.split(';').includes('D:\\other-modules'));
+  assert.equal(normalized.STABILIZATION_SENTINEL,'preserved');
+  assert.equal(base.PSModulePath,'D:\\custom-modules;D:\\other-modules');
+});
+test('normalized Windows PowerShell resolves native Get-FileHash for inherited, missing and custom paths',()=>{
+  assert.equal(process.platform,'win32','this acceptance test requires Windows');
+  const executable=path.join(process.env.SystemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe');
+  for(const value of [process.env.PSModulePath,undefined,'D:\\custom-modules']){
+    const base={...process.env};
+    if(value===undefined) delete base.PSModulePath; else base.PSModulePath=value;
+    const result=spawnSync(executable,['-NoProfile','-Command',"$ErrorActionPreference='Stop'; $c=Get-Command Get-FileHash; $c.Name; $c.Module.Path"],{encoding:'utf8',timeout:20000,env:windowsPowerShellEnvironment(base)});
+    assert.equal(result.status,0,result.stderr);
+    assert.match(result.stdout,/Get-FileHash/);
+    assert.ok(result.stdout.toLowerCase().includes(path.join(process.env.SystemRoot,'System32','WindowsPowerShell','v1.0','Modules').toLowerCase()),result.stdout);
+  }
+});

package/test/stabilization-semver.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {compareRuntimeVersions as compare,ensureRuntimeCoherence} from '../src/runtime-coherence.mjs';
+
+test('strict SemVer grammar',()=>{
+  for(const v of ['01.0.0','1.00.0','1.0.00','1.0.0-01','1.0.0-alpha..1','1.0.0+.','1.0.0-','1.0.0+','1.0.0\n']) assert.throws(()=>compare(v,v),/invalid/,v);
+  for(const v of ['1.0.0','1.0.0-0','1.0.0-alpha.1','1.0.0+001','1.0.0-x-y']) assert.equal(compare(v,v),0);
+});
+test('ASCII, arbitrary precision and SemVer precedence laws',()=>{
+  const ordered=['1.0.0-0','1.0.0-1','1.0.0-A','1.0.0-a','1.0.0-alpha','1.0.0-alpha.1','1.0.0-alpha.beta','1.0.0-beta','1.0.0-beta.2','1.0.0-beta.11','1.0.0-rc.1','1.0.0','1.0.1','2.0.0'];
+  for(let i=0;i<ordered.length;i++) for(let j=0;j<ordered.length;j++){
+    assert.equal(compare(ordered[i],ordered[j]),Math.sign(i-j));
+    for(let k=j;k<ordered.length;k++) if(i<=j) assert.ok(compare(ordered[i],ordered[k])<=0);
+  }
+  assert.equal(compare('9007199254740992.0.0','9007199254740993.0.0'),-1);
+  assert.equal(compare('1.0.0-9007199254740992','1.0.0-9007199254740993'),-1);
+  assert.equal(compare('1.0.0+a','1.0.0+b'),0);
+});
+test('ASCII downgrade never dispatches authority or activation',async()=>{
+  let calls=0;
+  await assert.rejects(ensureRuntimeCoherence({cliVersion:'1.0.0-A',packageManifestSha256:'b'.repeat(64),readActive:async()=>({version:'1.0.0-a',manifest_sha256:'a'.repeat(64)}),disarmPrivileged:async()=>{calls++;},activateCurrentPackage:async()=>{calls++;}}),/refusing automatic downgrade/);
+  assert.equal(calls,0);
+});

package/test/stabilization-smoke-root.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {spawnSync} from 'node:child_process';
+
+test('MCP smoke preserves caller state root across SDK stdio transport',async()=>{
+  const base='D:/Projects/deadbyte-mcp/testing/0.15.30';
+  await mkdir(base,{recursive:true});
+  const root=await mkdtemp(path.join(base,'smoke-root-'));
+  const state=path.join(root,'isolated'),profile=path.join(root,'profile'),temp=path.join(root,'temp');
+  for(const dir of [path.join(state,'evidence','updates'),path.join(profile,'.deadbyte-mcp'),temp])await mkdir(dir,{recursive:true});
+  await writeFile(path.join(state,'active-release.json'),'INVALID_ISOLATED_POINTER');
+  const result=spawnSync(process.execPath,['src/mcp-smoke-client.mjs'],{encoding:'utf8',timeout:30000,env:{...process.env,DEADBYTE_STATE_ROOT:state,USERPROFILE:profile,TEMP:temp,TMP:temp}});
+  assert.notEqual(result.status,0,'smoke ignored corrupt explicitly-selected state');
+  assert.equal(result.error,undefined,String(result.error));
+  assert.match(result.stderr,/JSON|Unexpected token|connection closed/i);
+});
+test('release smoke child environments explicitly bind state root',async()=>{
+  for(const name of ['mcp-smoke-client','mcp-contained-smoke-client','process-smoke-client','machine-fs-smoke-client','authority-smoke','mcp-host-smoke-client']){
+    assert.match(await readFile(new URL('../src/'+name+'.mjs',import.meta.url),'utf8'),/DEADBYTE_STATE_ROOT\s*:/,name);
+  }
+});

package/test/stabilization-state-root.test.mjs

@@ -0,0 +1,60 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,writeFile,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {spawnSync} from 'node:child_process';
+import {renderStableLauncherPs1,renderStableLauncherCmd} from '../src/release-slot.mjs';
+import {windowsPowerShellEnvironment} from '../src/runtime-update.mjs';
+import {resolveStateRoot} from '../src/state-root.mjs';
+
+const base='D:/Projects/deadbyte-mcp/testing/0.15.30';
+test('trust default follows explicit environment in a fresh child',()=>{
+  const root=path.join(base,'trust-isolated');
+  const r=spawnSync(process.execPath,['--input-type=module','-e',"import {defaultTrustDir} from './src/trust.mjs'; console.log(defaultTrustDir());"],{encoding:'utf8',env:{...process.env,DEADBYTE_STATE_ROOT:root}});
+  assert.equal(r.status,0,r.stderr);
+  assert.equal(r.stdout.trim(),path.resolve(root,'trust'));
+});
+test('updater recovery reads the isolated pointer, not production',async()=>{
+  await mkdir(base,{recursive:true});
+  const root=await mkdtemp(path.join(base,'recovery-root-'));
+  await mkdir(path.join(root,'evidence','updates'),{recursive:true});
+  await writeFile(path.join(root,'active-release.json'),'INVALID_ISOLATED_POINTER');
+  const r=spawnSync(process.execPath,['scripts/runtime-self-update.mjs','--recover-interrupted'],{encoding:'utf8',env:{...process.env,DEADBYTE_STATE_ROOT:root},timeout:20000});
+  assert.notEqual(r.status,0);
+  assert.match(r.stderr,/JSON|Unexpected token/);
+});
+test('root precedence, default and invalid explicit roots',()=>{
+  assert.equal(resolveStateRoot('D:/explicit',{DEADBYTE_STATE_ROOT:'D:/environment'}),path.resolve('D:/explicit'));
+  assert.equal(resolveStateRoot(undefined,{DEADBYTE_STATE_ROOT:'D:/environment'}),path.resolve('D:/environment'));
+  assert.match(resolveStateRoot(undefined,{}),/\.deadbyte-mcp$/);
+  assert.throws(()=>resolveStateRoot(''),/invalid/);
+  assert.throws(()=>resolveStateRoot(null),/invalid/);
+  assert.throws(()=>resolveStateRoot('D:/bad\0'),/invalid/);
+});
+test('PS launcher selects isolated missing pointer rather than decoy production pointer',async()=>{
+  await mkdir(base,{recursive:true});
+  const fixture=await mkdtemp(path.join(base,'root-red-'));
+  const profile=path.join(fixture,'profile'),isolated=path.join(fixture,'isolated');
+  await mkdir(path.join(profile,'.deadbyte-mcp'),{recursive:true});
+  const decoy=path.join(profile,'.deadbyte-mcp','active-release.json');
+  await writeFile(decoy,'{"schema":"DECOY_PRODUCTION"}');
+  const launcher=path.join(fixture,'launcher.ps1');
+  await writeFile(launcher,renderStableLauncherPs1());
+  const r=spawnSync(path.join(process.env.SystemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe'),['-NoProfile','-File',launcher,'status'],{encoding:'utf8',timeout:20000,env:windowsPowerShellEnvironment({...process.env,USERPROFILE:profile,DEADBYTE_STATE_ROOT:isolated})});
+  assert.notEqual(r.status,0);
+  assert.match(r.stderr,/active release pointer missing/);
+  assert.doesNotMatch(r.stderr,/schema mismatch/);
+  assert.equal(await readFile(decoy,'utf8'),'{"schema":"DECOY_PRODUCTION"}');
+});
+test('CMD launcher transports explicit root with spaces to nested Node child',async()=>{
+  await mkdir(base,{recursive:true});
+  const fixture=await mkdtemp(path.join(base,'cmd-red-'));
+  const isolated=path.join(fixture,'isolated with spaces');
+  await mkdir(path.join(isolated,'bin'),{recursive:true});
+  await writeFile(path.join(isolated,'bin','DEADBYTE-MCP.ps1'),`& '${process.execPath.replaceAll("'","''")}' -e 'console.log(process.env.DEADBYTE_STATE_ROOT)'\nexit $LASTEXITCODE\n`);
+  const cmd=path.join(fixture,'launcher.cmd');
+  await writeFile(cmd,renderStableLauncherCmd());
+  const r=spawnSync(process.env.ComSpec,['/d','/c',cmd,'status'],{encoding:'utf8',timeout:20000,env:windowsPowerShellEnvironment({...process.env,DEADBYTE_STATE_ROOT:isolated,USERPROFILE:fixture})});
+  assert.equal(r.status,0,r.stderr);
+  assert.equal(r.stdout.trim(),isolated);
+});

package/test/stabilization-update-child-root.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {runControllerStartNoCapture} from '../src/runtime-update.mjs';
+
+test('explicit updater context root overrides inherited root for controller child',async()=>{
+  const base='D:/Projects/deadbyte-mcp/testing/0.15.30';
+  await mkdir(base,{recursive:true});
+  const root=await mkdtemp(path.join(base,'explicit-child-root-'));
+  const output=path.join(root,'observed-root.txt'),controller=path.join(root,'controller.ps1');
+  await writeFile(controller,`[IO.File]::WriteAllText('${output.replaceAll("'","''")}',[string]$env:DEADBYTE_STATE_ROOT)\nexit 0\n`);
+  const old=process.env.DEADBYTE_STATE_ROOT;
+  try{
+    process.env.DEADBYTE_STATE_ROOT=path.join(base,'different-parent-root');
+    const result=runControllerStartNoCapture({kind:'slot',state_root:root,controller_path:controller,cwd:root,runtime_root:path.join(root,'runtime'),pointer:{config_path:path.join(root,'config.psd1')}},10000);
+    assert.equal(result.status,0);
+    assert.equal(await readFile(output,'utf8'),root);
+  }finally{if(old===undefined)delete process.env.DEADBYTE_STATE_ROOT;else process.env.DEADBYTE_STATE_ROOT=old;}
+});