deadbyte-mcp 0.15.29 → 0.15.31

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

@@ -0,0 +1,68 @@
+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 currentPackage=await json('package.json');
+const r53test=currentPackage.version==='0.15.30'?test:test.skip;
+
+r53test('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/);
+});
+
+r53test('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);
+});
+
+r53test('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/r54-offline-predecessor-self-exclusion.test.mjs

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { pathToFileURL } from 'node:url';
+import path from 'node:path';
+
+const target=process.env.R54_RUNTIME_UPDATE_PATH
+  ? path.resolve(process.env.R54_RUNTIME_UPDATE_PATH)
+  : path.resolve(new URL('../src/runtime-update.mjs',import.meta.url).pathname.replace(/^\/(?:[A-Za-z]:)/,m=>m.slice(1)));
+const runtimeUpdate=await import(pathToFileURL(target).href+'?r54='+Date.now());
+
+test('R54 exposes behavior-testable offline recovery blocker selection',()=>{
+  assert.equal(typeof runtimeUpdate.selectOfflineRecoveryBlockers,'function');
+});
+
+test('R54 excludes only the current activation ancestry across non-Node wrapper processes',()=>{
+  const processes=[
+    {ProcessId:100,ParentProcessId:50,Name:'node.exe',CommandLine:'node npm-cli.js exec -- deadbyte-mcp@latest remote'},
+    {ProcessId:200,ParentProcessId:100,Name:'cmd.exe',CommandLine:'cmd /d /s /c deadbyte-mcp remote'},
+    {ProcessId:300,ParentProcessId:200,Name:'node.exe',CommandLine:'node C:\\cache\\deadbyte-mcp\\src\\deadbyte-cli.mjs remote'},
+    {ProcessId:400,ParentProcessId:300,Name:'node.exe',CommandLine:'node C:\\slot\\deadbyte-mcp\\scripts\\runtime-self-update.mjs --resume-handoff x'},
+    {ProcessId:900,ParentProcessId:1,Name:'node.exe',CommandLine:'node C:\\stale\\deadbyte-mcp\\src\\mcp-server.mjs'}
+  ];
+  const blockers=runtimeUpdate.selectOfflineRecoveryBlockers(processes,400);
+  assert.deepEqual(blockers.map(item=>item.ProcessId),[900]);
+});
+
+test('R54 does not exempt a sibling stale DEADBYTE runtime',()=>{
+  const processes=[
+    {ProcessId:100,ParentProcessId:50,Name:'node.exe',CommandLine:'node npm-cli.js exec -- deadbyte-mcp@latest remote'},
+    {ProcessId:200,ParentProcessId:100,Name:'cmd.exe',CommandLine:'cmd /d /s /c deadbyte-mcp remote'},
+    {ProcessId:300,ParentProcessId:200,Name:'node.exe',CommandLine:'node C:\\cache\\deadbyte-mcp\\src\\deadbyte-cli.mjs remote'},
+    {ProcessId:400,ParentProcessId:300,Name:'node.exe',CommandLine:'node C:\\slot\\deadbyte-mcp\\scripts\\runtime-self-update.mjs --resume-handoff x'},
+    {ProcessId:700,ParentProcessId:300,Name:'node.exe',CommandLine:'node C:\\stale\\deadbyte-mcp\\src\\mcp-server.mjs'}
+  ];
+  const blockers=runtimeUpdate.selectOfflineRecoveryBlockers(processes,400);
+  assert.deepEqual(blockers.map(item=>item.ProcessId),[700]);
+});
+
+test('R54 still blocks unrelated stale guardian, tunnel, and cloud DEADBYTE processes',()=>{
+  const processes=[
+    {ProcessId:400,ParentProcessId:300,Name:'node.exe',CommandLine:'node C:\\slot\\deadbyte-mcp\\scripts\\runtime-self-update.mjs --resume-handoff x'},
+    {ProcessId:910,ParentProcessId:1,Name:'node.exe',CommandLine:'node C:\\stale\\deadbyte-mcp\\src\\remote-session-guardian.mjs'},
+    {ProcessId:920,ParentProcessId:1,Name:'deadbyte-tunnel-host.exe',CommandLine:'C:\\stale\\deadbyte-tunnel-host.exe'},
+    {ProcessId:930,ParentProcessId:1,Name:'cloudflared.exe',CommandLine:'cloudflared tunnel --config C:\\deadbyte-mcp\\cloud.yml run'}
+  ];
+  const blockers=runtimeUpdate.selectOfflineRecoveryBlockers(processes,400);
+  assert.deepEqual(blockers.map(item=>item.ProcessId),[910,920,930]);
+});
+
+test('R54 ignores unrelated Node processes without DEADBYTE runtime identity',()=>{
+  const processes=[
+    {ProcessId:400,ParentProcessId:300,Name:'node.exe',CommandLine:'node C:\\slot\\deadbyte-mcp\\scripts\\runtime-self-update.mjs --resume-handoff x'},
+    {ProcessId:950,ParentProcessId:1,Name:'node.exe',CommandLine:'node C:\\work\\unrelated-app\\server.js'}
+  ];
+  assert.deepEqual(runtimeUpdate.selectOfflineRecoveryBlockers(processes,400),[]);
+});

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

@@ -0,0 +1,59 @@
+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('R54 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.31');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.31'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R54');
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R54');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r54:0.15.31');
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r54\.ps1/);
+  assert.match(pkg.scripts['r54:focused:test'],/r54-offline-predecessor-self-exclusion\.test\.mjs/);
+});
+
+test('R54 source predecessor is exact immutable published 0.15.30 while runtime predecessor remains exact 0.15.29',async()=>{
+  const [release,provenance]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json')]);
+  assert.equal(release.parent.version,'0.15.30');
+  assert.equal(release.parent.release_id,'v0.15.30-ddf7c7338d9a371f');
+  assert.equal(release.parent.manifest_sha256,'ddf7c7338d9a371f5667d7b138695e7f9cfced553d14073ac5a44fd2fe0a0399');
+  assert.equal(release.parent.tarball_sha256,'72881981bf76eb45527946b310caed8387943e2ca8e37ea6e606c32189dd5a70');
+  assert.equal(release.parent.activation_status,'PUBLISHED_NOT_ACTIVATED');
+  assert.equal(release.source_predecessor.version,'0.15.30');
+  assert.equal(release.source_predecessor.tarball_sha256,release.parent.tarball_sha256);
+  assert.equal(release.source_predecessor.manifest_file_sha256,release.parent.manifest_sha256);
+  assert.deepEqual(release.runtime_predecessor,{
+    release_id:'v0.15.29-f74eaa1b3d00e6fb',
+    manifest_sha256:'f74eaa1b3d00e6fb5a36b2358efb815e3686c9fe9dbd3b84d25a713ef957748c',
+    generation_manifest_sha256:'289b4fc065de0681da6864cc1bbe09aab198ca804945ffc27c786438dad13f5a'
+  });
+  assert.equal(provenance.parent_manifest_sha256,release.parent.manifest_sha256);
+  assert.deepEqual(provenance.runtime_predecessor,release.runtime_predecessor);
+});
+
+test('R54 records surgical activation recovery fix and preserves explicit non-final claim',async()=>{
+  const [release,provenance,matrix]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json')]);
+  assert.equal(release.hotfix.activation_ancestry_excluded,true);
+  assert.equal(release.hotfix.unrelated_stale_runtime_fail_closed,true);
+  assert.equal(release.hotfix.red_parent_0_15_30,'FAIL_5_OF_5');
+  assert.equal(release.hotfix.green_r54_candidate,'PASS_5_OF_5');
+  assert.equal(release.hotfix.stable_final_claim,false);
+  assert.equal(release.stabilization.four_hour_soak,'NOT_COMPLETED_OPERATOR_BYPASS');
+  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;}
+});