deadbyte-mcp 0.15.34 → 0.15.35

package/test/r58-controller-json.test.mjs

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile,readdir} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createHash} from 'node:crypto';
+import {windowsPowerShellEnvironment} from '../src/runtime-update.mjs';
+import {classifyDoctorControllerObservation} from '../src/doctor-runtime-r58.mjs';
+
+const core=fileURLToPath(new URL('..',import.meta.url));
+const controller=path.join(core,'controller','deadbyte-controller.ps1');
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const quote=s=>"'"+s.replaceAll("'","''")+"'";
+test('R58 real controller JSON status is bounded read-only and cannot select mutation',async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'controller-json-'));
+ const script=path.join(root,'bridge.mjs');await writeFile(script,'// never executed fixture\n');
+ const helper=path.join(root,'public-tool-definitions.mjs');await writeFile(helper,'// pinned helper fixture\n');
+ const helperHash=sha(await readFile(helper));
+ const config=path.join(root,'config.psd1'),nodeHash=sha(await readFile(process.execPath)),scriptHash=sha(await readFile(script));
+ const spec=`@{ FilePath=${quote(process.execPath)}; FileSha256='${nodeHash}'; Arguments='UNLAUNCHED'; WorkingDirectory=${quote(root)} }`;
+ const bridge=spec.slice(0,-1)+`; ScriptPath=${quote(script)}; ScriptSha256='${scriptHash}'; Dependencies=@(@{Name='bridge-validator';Path=${quote(helper)};Sha256='${helperHash}'}) }`;
+ await writeFile(config,`@{ Schema='deadbyte.controller.v1'; CoreRoot=${quote(core)}; WorkspaceRoot=${quote(root)}; Bridge=${bridge}; Cloud=${spec}; MachineRuntimeEnabled=$false; AgentRuntimeEnabled=$false; ProcessRuntimeEnabled=$false; ProcessPolicyFile=''; CodingRuntimeEnabled=$false; CodingPolicyFile=''; DesktopRuntimeEnabled=$false; DesktopPolicyFile=''; AutonomousRuntimeEnabled=$false; AutonomousSupervisorEnabled=$false; AutonomousPolicyFile=''; HostPolicyFile=''; LocalReadyUri='http://127.0.0.1:1/health'; UrlRegex=''; McpUrlFile=''; McpPathFile=''; StartTimeoutSeconds=1; ProbeTimeoutSeconds=1 }`);
+ const runtime=path.join(root,'runtime');
+ const run=command=>spawnSync(path.join(process.env.SystemRoot,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoProfile','-File',controller,command,'-Json'],{encoding:'utf8',timeout:20000,env:windowsPowerShellEnvironment({...process.env,DEADBYTE_STATE_ROOT:root,DEADBYTE_CONTROLLER_CONFIG:config,DEADBYTE_CONTROLLER_RUNTIME_ROOT:runtime})});
+ const before=await readdir(root);
+ const observed=run('status');assert.equal(observed.status,0,observed.stderr);
+ const value=JSON.parse(observed.stdout);assert.equal(value.schema,'deadbyte.controller-observation.v1');assert.equal(value.state,'OFFLINE');assert.equal(value.local_ready,false);
+ assert.equal(value.bridge.alive,false);assert.equal(value.cloud.alive,false);
+ assert.equal(value.core.alive,false);assert.equal(value.core.reason,'bridge-unavailable');
+ assert.equal(classifyDoctorControllerObservation(value,core).status,'PASS');
+ for(const plane of ['process','coding','autonomous','desktop','host'])assert.equal(value.authority[plane].armed,false);
+ assert.deepEqual(await readdir(root),before,'status must not create runtime/logs/grants');
+ const denied=run('armcoding');assert.notEqual(denied.status,0);assert.match(denied.stderr,/JSON.*status|status.*JSON/i);
+ assert.deepEqual(await readdir(root),before,'JSON option must not invoke mutation');
+ assert.ok(!observed.stdout.includes('UNLAUNCHED'),'never expose launch arguments');
+ await writeFile(helper,'// changed helper fixture\n');
+ const drift=run('status');assert.notEqual(drift.status,0);assert.match(drift.stderr,/Bridge dependency hash mismatch/);
+ assert.deepEqual(await readdir(root),before,'dependency drift must fail before runtime creation');
+ await writeFile(helper,'// pinned helper fixture\n');
+ const other=path.join(root,'other-core');await mkdir(path.join(other,'src'),{recursive:true});
+ await writeFile(path.join(other,'package.json'),'{"name":"deadbyte-mcp"}');await writeFile(path.join(other,'src','mcp-server.mjs'),'// fixture only');
+ const configBefore=await readFile(config,'utf8');await writeFile(config,configBefore.replace('CoreRoot='+quote(core),'CoreRoot='+quote(other)));
+ const inventory=await readdir(root),wrongRoot=run('status');
+ assert.notEqual(wrongRoot.status,0);assert.match(wrongRoot.stderr,/controller root mismatch/);
+ assert.deepEqual(await readdir(root),inventory,'wrong-root observation must fail without runtime creation');
+});

package/test/r58-controller-live-local.test.mjs

@@ -0,0 +1,85 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,cp,readFile,writeFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {createServer} from 'node:net';
+import {createHash,randomBytes,generateKeyPairSync} from 'node:crypto';
+import path from 'node:path';
+import {makeDoctorCliFixture} from './helpers/r58-doctor-fixture.mjs';
+import {prepareBridgeSpec,windowsPowerShellEnvironment} from '../src/runtime-update.mjs';
+import {queryForegroundIdentity as queryForegroundProcessIdentity,foregroundIdentityMatches as sameForegroundProcessIdentity} from '../src/foreground-process-identity.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const quote=s=>"'"+s.replaceAll("'","''")+"'";
+const source=new URL('../controller/deadbyte-controller.ps1',import.meta.url);
+
+test('R58 actual isolated controller/bridge/core reaches ONLINE and stops without an orphan core',async()=>{
+ const f=await makeDoctorCliFixture();
+ const bridgeRoot=path.join(f.pkg,'bridge');
+ const keys=generateKeyPairSync('ed25519'),trust=path.join(f.state,'trust');await mkdir(trust);
+ await writeFile(path.join(trust,'ed25519-private.pem'),keys.privateKey.export({type:'pkcs8',format:'pem'}));
+ await writeFile(path.join(trust,'ed25519-public.pem'),keys.publicKey.export({type:'spki',format:'pem'}));
+ await mkdir(path.join(f.pkg,'controller'));
+ const controller=path.join(f.pkg,'controller','deadbyte-controller.ps1');await cp(source,controller);
+ const manifest=await readFile(path.join(f.pkg,'MANIFEST.SHA256'),'utf8');
+ await writeFile(path.join(f.pkg,'MANIFEST.SHA256'),[...manifest.trim().split('\n'),sha(await readFile(controller))+'  controller/deadbyte-controller.ps1'].sort().join('\n')+'\n');
+ const workspace=path.join(f.root,'workspace');await mkdir(workspace);
+ const listener=createServer();await new Promise(resolve=>listener.listen(0,'127.0.0.1',resolve));
+ const port=listener.address().port;await new Promise(resolve=>listener.close(resolve));
+ const cloud=path.join(f.root,'fixture-cloud.mjs');await writeFile(cloud,'setInterval(()=>{},1000);\n');
+ const url=path.join(f.root,'fixture-url.txt');await writeFile(url,'https://fixture.invalid/mcp\n');
+ const bridgeScript=path.join(bridgeRoot,'src','bridge.mjs'),nodeHash=sha(await readFile(process.execPath));
+ const preparedBridge=await prepareBridgeSpec({Bridge:{FilePath:process.execPath,FileSha256:nodeHash,Arguments:'src\\bridge.mjs',WorkingDirectory:bridgeRoot},Cloud:{}},{root:bridgeRoot,scriptSha256:sha(await readFile(bridgeScript))});
+ const dependencies=preparedBridge.Bridge.Dependencies.map(dependency=>`@{Name=${quote(dependency.Name)};Path=${quote(dependency.Path)};Sha256='${dependency.Sha256}'}`);
+ assert.deepEqual(preparedBridge.Bridge.Dependencies.map(x=>x.Name),['node-http-adapter.mjs','public-tool-definitions.mjs','r40-governor.mjs']);
+ const config=path.join(f.root,'controller-config.psd1'),runtime=path.join(f.state,'runtime');
+ await writeFile(config,`@{ Schema='deadbyte.controller.v1'; CoreRoot=${quote(f.pkg)}; WorkspaceRoot=${quote(workspace)}; Bridge=@{FilePath=${quote(process.execPath)};FileSha256='${nodeHash}';Arguments='src\\bridge.mjs';WorkingDirectory=${quote(bridgeRoot)};ScriptPath=${quote(bridgeScript)};ScriptSha256='${sha(await readFile(bridgeScript))}';Dependencies=@(${dependencies.join(';')})}; Cloud=@{FilePath=${quote(process.execPath)};FileSha256='${nodeHash}';Arguments=${quote('"'+cloud+'"')};WorkingDirectory=${quote(f.root)};Dependencies=@(@{Name='fixture-cloud';Path=${quote(cloud)};Sha256='${sha(await readFile(cloud))}'})}; MachineRuntimeEnabled=$false;AgentRuntimeEnabled=$false;ProcessRuntimeEnabled=$false;ProcessPolicyFile='';CodingRuntimeEnabled=$false;CodingPolicyFile='';MachineFsRuntimeEnabled=$false;ObservationRuntimeEnabled=$false;DesktopRuntimeEnabled=$false;DesktopPolicyFile='';AutonomousRuntimeEnabled=$false;AutonomousSupervisorEnabled=$false;AutonomousPolicyFile='';HostPolicyFile='';LocalReadyUri='http://127.0.0.1:${port}/healthz';UrlRegex='';McpUrlFile=${quote(url)};McpPathFile='';StartTimeoutSeconds=15;ProbeTimeoutSeconds=1 }`);
+ // Controller's existing audit mode requires machine runtime. It is observation
+ // only here; all optional authority planes remain disabled and unarmed.
+ const codingPolicy=path.join(f.root,'coding-policy.json');
+ await writeFile(codingPolicy,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:path.join(runtime,'coding-grant.json'),evidence_dir:path.join(f.state,'evidence','coding'),roots:{fixture:{path:workspace,read:true,write:false,exec:false,deny_paths:[]}},commands:{},max_read_bytes:65536,max_write_bytes:65536}));
+ await writeFile(config,(await readFile(config,'utf8')).replace('MachineRuntimeEnabled=$false','MachineRuntimeEnabled=$true').replace("CodingRuntimeEnabled=$false;CodingPolicyFile=''",`CodingRuntimeEnabled=$true;CodingPolicyFile=${quote(codingPolicy)}`));
+ // Audit context and machine identity require an exact isolated active binding.
+ // Bind the fixture package bytes to its own generation; never borrow production
+ // pointers, generations, launchers or signing keys.
+ const pkgIdentity=JSON.parse(await readFile(path.join(f.pkg,'package.json'),'utf8'));
+ const releaseManifestSha=sha(await readFile(path.join(f.pkg,'MANIFEST.SHA256')));
+ const generation=path.join(f.state,'generations',`fixture-${randomBytes(8).toString('hex')}`);
+ await mkdir(generation,{recursive:true});
+ const generationConfig=path.join(generation,'controller-config.psd1');
+ await cp(config,generationConfig);
+ const generationManifestBytes=Buffer.from(`${sha(await readFile(generationConfig))}  controller-config.psd1\n`,'utf8');
+ await writeFile(path.join(generation,'GENERATION.SHA256'),generationManifestBytes);
+ await writeFile(path.join(f.state,'active-release.json'),JSON.stringify({
+   schema:'deadbyte.active-release.v1',
+   release_id:`v${pkgIdentity.version}-${releaseManifestSha.slice(0,16)}`,
+   version:pkgIdentity.version,
+   manifest_sha256:releaseManifestSha,
+   release_root:f.pkg,
+   generation_root:generation,
+   generation_manifest_sha256:sha(generationManifestBytes),
+   launcher_sha256:'0'.repeat(64),
+   config_path:generationConfig
+ },null,2)+'\n');
+ const env=windowsPowerShellEnvironment({...f.env,DEADBYTE_CONTROLLER_CONFIG:config,DEADBYTE_CONTROLLER_RUNTIME_ROOT:runtime,DEADBYTE_BRIDGE_PORT:String(port),DEADBYTE_BRIDGE_PATH_TOKEN:randomBytes(32).toString('hex')});
+ const run=(command,json=false)=>spawnSync(path.join(process.env.SystemRoot,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoProfile','-File',controller,command,...(json?['-Json']:[])],{env,encoding:'utf8',timeout:45000});
+ let coreIdentity=null;
+ try{
+  const cold=run('status',true);assert.equal(cold.status,0,cold.stderr);assert.equal(JSON.parse(cold.stdout).state,'OFFLINE');
+  const started=run('start');assert.equal(started.status,0,started.stderr);
+  const status=run('status',true);assert.equal(status.status,0,status.stderr);const observed=JSON.parse(status.stdout);
+  assert.equal(observed.state,'ONLINE');assert.equal(observed.local_ready,true);assert.equal(observed.core.alive,true);assert.equal(observed.core.parent_pid,observed.bridge.pid);
+  for(const plane of Object.values(observed.authority))assert.equal(plane.armed,false);
+  coreIdentity=await queryForegroundProcessIdentity(observed.core.pid);assert.ok(coreIdentity);
+  const stopped=run('stop');assert.equal(stopped.status,0,stopped.stderr);
+  const terminal=run('status',true);assert.equal(terminal.status,0,terminal.stderr);const end=JSON.parse(terminal.stdout);
+  assert.equal(end.state,'OFFLINE');assert.equal(end.local_ready,false);assert.equal(end.bridge.alive,false);assert.equal(end.cloud.alive,false);
+  assert.equal(await queryForegroundProcessIdentity(coreIdentity.pid),null,'owned core must be gone after supported stop');
+ }finally{
+  const cleanup=run('stop');
+  // Only this fixture's already observed exact process identity can be removed.
+  // A cleanup failure remains a test failure, never hidden as successful stop.
+  if(coreIdentity){const remaining=await queryForegroundProcessIdentity(coreIdentity.pid);if(remaining&&sameForegroundProcessIdentity(coreIdentity,remaining))process.kill(coreIdentity.pid);}
+  assert.equal(cleanup.status,0,cleanup.stderr);
+ }
+});

package/test/r58-controller-readonly.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile,mkdir,mkdtemp,writeFile,readdir} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {windowsPowerShellEnvironment} from '../src/runtime-update.mjs';
+
+test('R58 controller read-only dispatch must not create runtime/log state',async()=>{
+ const source=await readFile(new URL('../controller/deadbyte-controller.ps1',import.meta.url),'utf8');
+ const start=source.indexOf('function Run-CommandCore('),end=source.indexOf('function Run-Command(',start);
+ assert.ok(start>=0&&end>start);const dispatch=source.slice(start,end);
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'controller-readonly-'));
+ for(const command of ['status','url','hoststatus','processstatus','codingstatus','autonomousstatus','desktopstatus','supervisorstatus']){
+  const isolated=path.join(root,command);await mkdir(isolated);
+  const script=path.join(isolated,'fixture.ps1');
+  const prelude=`$ErrorActionPreference='Stop'\n$RuntimeDir='${path.join(isolated,'runtime').replaceAll("'","''")}'\n$LogDir=Join-Path $RuntimeDir 'logs'\nfunction Get-Config { return @{} }\nfunction Assert-ControllerRootBound($Cfg) {}\nfunction Ensure-Directory([string]$Path) { if (-not (Test-Path -LiteralPath $Path)) { New-Item -ItemType Directory -Path $Path | Out-Null } }\nfunction Show-State($Cfg) {}\nfunction Get-CurrentUrl($Cfg) { return 'FIXTURE' }\nfunction Show-HostStatus($Cfg) {}\nfunction Show-ProcessStatus($Cfg) {}\nfunction Show-CodingStatus($Cfg) {}\nfunction Show-AutonomousStatus($Cfg) {}\nfunction Show-DesktopStatus($Cfg) {}\nfunction Show-AutonomousSupervisorStatus($Cfg) {}\n`;
+  await writeFile(script,prelude+dispatch+`\nRun-CommandCore '${command}'\n`);
+  const observed=spawnSync(path.join(process.env.SystemRoot,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoProfile','-File',script],{encoding:'utf8',timeout:20000,env:windowsPowerShellEnvironment(process.env)});
+  assert.equal(observed.status,0,observed.stderr);
+  assert.deepEqual(await readdir(isolated),['fixture.ps1'],command+' must not create runtime state');
+ }
+});

package/test/r58-controller-state-coherence.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile,mkdir,mkdtemp,writeFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {windowsPowerShellEnvironment} from '../src/runtime-update.mjs';
+
+test('R58 controller human state cannot claim ONLINE/local ready without its verified core',async()=>{
+ const source=await readFile(new URL('../controller/deadbyte-controller.ps1',import.meta.url),'utf8');
+ const start=source.indexOf('function Get-ObservedState('),end=source.indexOf('function Wait-LocalReady(',start);
+ assert.ok(start>=0&&end>start);
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'state-coherence-'));
+ const cases=[
+  {bridge:true,cloud:true,ready:true,core:true,reason:'verified',state:'ONLINE',local:true},
+  {bridge:true,cloud:true,ready:true,core:false,reason:'startup-zero-child',state:'STARTING',local:false},
+  {bridge:true,cloud:true,ready:true,core:false,reason:'ambiguous-core',state:'FAILED',local:false},
+  {bridge:true,cloud:true,ready:true,core:false,reason:'wrong-core-generation',state:'FAILED',local:false},
+  {bridge:true,cloud:false,ready:true,core:true,reason:'verified',state:'FAILED',local:true},
+  {bridge:false,cloud:true,ready:false,core:false,reason:'bridge-unavailable',state:'PARKED',local:false},
+  {bridge:false,cloud:false,ready:false,core:false,reason:'bridge-unavailable',state:'OFFLINE',local:false},
+  {bridge:true,cloud:true,ready:false,core:true,reason:'verified',state:'FAILED',local:false}
+ ];
+ const data=path.join(root,'cases.json');await writeFile(data,JSON.stringify(cases));
+ const script=path.join(root,'fixture.ps1');
+ await writeFile(script,`$ErrorActionPreference='Stop'\n${source.slice(start,end)}\nfunction Test-OwnedInstance([string]$Name) { return [pscustomobject]@{Alive=[bool]$script:Case.$Name;Reason='verified';Ledger=[pscustomobject]@{pid=20}} }\nfunction Test-LocalReadyOwned($Cfg,$Bridge) { return [bool]$script:Case.ready }\nfunction Get-DownstreamCoreObservation($Cfg,$Bridge) { $script:Queries++; return [pscustomobject]@{alive=[bool]$script:Case.core;reason=[string]$script:Case.reason;pid=21} }\n$cases=Get-Content -LiteralPath '${data.replaceAll("'","''")}' -Raw | ConvertFrom-Json\nforeach($case in $cases) { $script:Case=$case; $script:Queries=0; $s=Get-ObservedState @{}; [pscustomobject]@{state=$s.State;local_ready=$s.LocalReady;queries=$script:Queries} | ConvertTo-Json -Compress | Write-Output }\n`);
+ const r=spawnSync(path.join(process.env.SystemRoot,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoProfile','-File',script],{encoding:'utf8',timeout:15000,env:windowsPowerShellEnvironment(process.env)});
+ assert.equal(r.status,0,r.stderr);
+ const rows=r.stdout.trim().split(/\r?\n/).map(JSON.parse);assert.equal(rows.length,cases.length);
+ rows.forEach((row,i)=>{assert.equal(row.state,cases[i].state,JSON.stringify(cases[i]));assert.equal(row.local_ready,cases[i].local);});
+ rows.forEach(row=>assert.equal(row.queries,1,'one observation, no duplicate core query or retry'));
+});
+
+test('R58 controller startup readiness retries only zero-child core visibility and rejects ambiguity immediately',async()=>{
+ const source=await readFile(new URL('../controller/deadbyte-controller.ps1',import.meta.url),'utf8');
+ const start=source.indexOf('function Wait-LocalReady('),end=source.indexOf('function Wait-PublicDnsReady(',start);
+ assert.ok(start>=0&&end>start);
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'core-ready-')),script=path.join(root,'fixture.ps1');
+ await writeFile(script,`$ErrorActionPreference='Stop'\n${source.slice(start,end)}\nfunction Test-OwnedInstance([string]$Name) { return [pscustomobject]@{Alive=$true} }\nfunction Test-LocalReadyOwned($Cfg,$Bridge) { return $true }\nfunction Start-Sleep { param($Milliseconds) $script:Sleeps++ }\nfunction Get-DownstreamCoreObservation($Cfg,$Bridge) { $script:Queries++; if($script:Mode -eq 'race' -and $script:Queries -ge 2) { return [pscustomobject]@{alive=$true;reason='verified'} }; return [pscustomobject]@{alive=$false;reason=$(if($script:Mode -eq 'race' -or $script:Mode -eq 'timeout'){'startup-zero-child'}else{'ambiguous-core'})} }\nforeach($mode in @('race','ambiguous','timeout')) { $script:Mode=$mode; $script:Queries=0; $script:Sleeps=0; $ready=Wait-LocalReady @{StartTimeoutSeconds=$(if($mode -eq 'timeout'){0}else{2})}; [pscustomobject]@{mode=$mode;ready=$ready;queries=$script:Queries;sleeps=$script:Sleeps} | ConvertTo-Json -Compress | Write-Output }\n`);
+ const r=spawnSync(path.join(process.env.SystemRoot,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoProfile','-File',script],{encoding:'utf8',timeout:15000,env:windowsPowerShellEnvironment(process.env)});
+ assert.equal(r.status,0,r.stderr);
+ const rows=r.stdout.trim().split(/\r?\n/).map(JSON.parse);
+ assert.deepEqual(rows,[{mode:'race',ready:true,queries:2,sleeps:1},{mode:'ambiguous',ready:false,queries:1,sleeps:0},{mode:'timeout',ready:false,queries:1,sleeps:0}]);
+});

package/test/r58-doctor-cli.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+import {writeFile,readFile,readdir} from 'node:fs/promises';
+import path from 'node:path';
+import {makeDoctorCliFixture} from './helpers/r58-doctor-fixture.mjs';
+
+test('R58 actual doctor CLI is read-only and reports nonzero for a failed installed-state check',async()=>{
+ const f=await makeDoctorCliFixture();
+ const run=()=>spawnSync(process.execPath,[f.entry,'doctor'],{encoding:'utf8',timeout:30000,env:f.env});
+ const healthy=run();assert.equal(healthy.status,0,healthy.stderr);
+ const body=JSON.parse(healthy.stdout);assert.equal(body.status,'ok');assert.equal(body.assessment,'PASS');
+ assert.equal(body.manifest.verified_entries,f.manifestFiles);assert.deepEqual(await readdir(f.state),[],'empty-state doctor must not bootstrap');
+ const manifest='a'.repeat(64),release='v0.15.34-'+manifest.slice(0,16);
+ const pointer={schema:'deadbyte.active-release.v1',version:'0.15.34',release_id:release,manifest_sha256:manifest,release_root:path.join(f.state,'releases',release),generation_root:path.join(f.state,'generations','missing'),generation_manifest_sha256:'b'.repeat(64),launcher_sha256:'c'.repeat(64),config_path:path.join(f.state,'generations','missing','controller-config.psd1')};
+ const file=path.join(f.state,'active-release.json'),bytes=JSON.stringify(pointer);await writeFile(file,bytes);
+ const failed=run();assert.equal(JSON.parse(failed.stdout).assessment,'FAIL',failed.stderr);
+ assert.notEqual(failed.status,0,'doctor FAIL must be visible to shell and release gate');
+ assert.equal(await readFile(file,'utf8'),bytes);assert.deepEqual(await readdir(f.state),['active-release.json']);
+});

package/test/r58-doctor-foreground.test.mjs

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile,readdir} from 'node:fs/promises';
+import path from 'node:path';
+import {inspectDoctorForeground} from '../src/doctor-foreground-r58.mjs';
+import {queryForegroundIdentity} from '../src/foreground-process-identity.mjs';
+
+const owner={schema:'deadbyte.foreground-process.v1',pid:101,parent_pid:100,creation_utc:'2026-10-01T00:00:00.000Z',executable_path:'C:/Windows/node.exe',command_line_sha256:'a'.repeat(64)};
+const guardian={...owner,pid:102,parent_pid:101,command_line_sha256:'b'.repeat(64)};
+const valid={schema:'deadbyte.remote-session.v2',owner_pid:101,guardian_pid:102,session_nonce:'c'.repeat(64),owner_identity:owner,guardian_identity:guardian};
+async function fixture(){const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});const root=await mkdtemp(path.join(base,'doctor-foreground-'));await mkdir(path.join(root,'runtime'));return {root,file:path.join(root,'runtime','remote-session.json')};}
+const observe=pid=>pid===101?owner:guardian;
+
+test('R58 doctor foreground validates bindings and distinguishes stale observations without mutation',async()=>{
+ const f=await fixture();
+ assert.equal((await inspectDoctorForeground(f.root)).status,'PASS');assert.deepEqual(await readdir(path.join(f.root,'runtime')),[]);
+ const cases=[
+  [valid,'PASS',observe],
+  [{...valid,session_nonce:'INVALID'},'FAIL',()=>{throw new Error('must not query');}],
+  [{...valid,owner_identity:{...owner,pid:103}},'FAIL',observe],
+  [{...valid,guardian_identity:{...guardian,parent_pid:999}},'FAIL',observe],
+  [{...valid,owner_identity:undefined,guardian_identity:undefined},'WARN',()=>{throw new Error('unverified PID must not query');}],
+  [{schema:'deadbyte.remote-session.v1',pid:101},'WARN',observe],
+  [valid,'WARN',()=>null],
+  [valid,'WARN',pid=>({...observe(pid),creation_utc:'2026-10-01T00:00:01.000Z'})],
+  [valid,'FAIL',()=>{throw new Error('observation denied');}]
+ ];
+ for(const [marker,expected,queryIdentity]of cases){
+  const bytes=JSON.stringify(marker);await writeFile(f.file,bytes);
+  const result=await inspectDoctorForeground(f.root,{queryIdentity});assert.equal(result.status,expected,bytes);
+  assert.equal(await readFile(f.file,'utf8'),bytes);
+  for(const finding of result.findings.filter(f=>f.level!=='PASS'))assert.ok(finding.what&&finding.next_action&&finding.evidence);
+  assert.ok(!JSON.stringify(result).includes(valid.session_nonce),'do not expose session nonce');
+ }
+});
+
+test('R58 doctor foreground malformed, oversized and unreadable markers fail closed',async()=>{
+ const f=await fixture();
+ for(const bytes of ['INVALID_JSON','x'.repeat(16385),'null']){
+  await writeFile(f.file,bytes);assert.equal((await inspectDoctorForeground(f.root)).status,'FAIL');assert.equal(await readFile(f.file,'utf8'),bytes);
+ }
+});
+
+test('R58 doctor actual owner observation verifies the current process, not PID alone',async()=>{
+ const f=await fixture();const identity=queryForegroundIdentity(process.pid);
+ await writeFile(f.file,JSON.stringify({...valid,owner_pid:process.pid,owner_identity:identity,guardian_pid:0,guardian_identity:undefined}));
+ const result=await inspectDoctorForeground(f.root);
+ assert.equal(result.findings.find(f=>f.id==='foreground_owner').level,'PASS');
+ assert.equal(result.status,'WARN','guardian reservation is not a verified healthy guardian');
+});

package/test/r58-doctor-installation.test.mjs

@@ -0,0 +1,55 @@
+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 { inspectDoctorInstallation } from '../src/doctor-installation-r58.mjs';
+import { sha256Bytes } from '../src/release-slot.mjs';
+
+async function fixture(){
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const state=await mkdtemp(path.join(base,'doctor-installation-'));
+ const packageBytes=Buffer.from(JSON.stringify({name:'deadbyte-mcp',version:'0.15.34'}));
+ const manifest=Buffer.from(sha256Bytes(packageBytes)+'  package.json\n');
+ const manifest_sha256=sha256Bytes(manifest),release_id='v0.15.34-'+manifest_sha256.slice(0,16);
+ const release=path.join(state,'releases',release_id),generation=path.join(state,'generations','fixture');
+ await mkdir(release,{recursive:true});await mkdir(generation,{recursive:true});await mkdir(path.join(state,'bin'));
+ const config=Buffer.from('@{}\r\n'),generationManifest=Buffer.from(sha256Bytes(config)+'  controller-config.psd1\n'),launcher=Buffer.from('# isolated launcher\r\n');
+ const files=new Map([[path.join(release,'package.json'),packageBytes],[path.join(release,'MANIFEST.SHA256'),manifest],[path.join(generation,'controller-config.psd1'),config],[path.join(generation,'GENERATION.SHA256'),generationManifest],[path.join(state,'bin','DEADBYTE-MCP.ps1'),launcher]]);
+ for(const [file,bytes]of files)await writeFile(file,bytes);
+ const pointer={schema:'deadbyte.active-release.v1',version:'0.15.34',release_id,manifest_sha256,release_root:release,generation_root:generation,generation_manifest_sha256:sha256Bytes(generationManifest),launcher_sha256:sha256Bytes(launcher),config_path:path.join(generation,'controller-config.psd1')};
+ return {state,pointer,files};
+}
+
+test('R58 doctor independently verifies installed bytes and never repairs fixture files',async()=>{
+ const f=await fixture();
+ const good=await inspectDoctorInstallation(f.pointer,f.state);
+ assert.equal(good.status,'PASS');assert.equal(good.findings.length,4);
+ for(const [file,bytes]of f.files){
+   await writeFile(file,Buffer.concat([bytes,Buffer.from('CORRUPTION')]));
+   const result=await inspectDoctorInstallation(f.pointer,f.state);
+   assert.equal(result.status,'FAIL',file);
+   const failure=result.findings.find(item=>item.level==='FAIL');assert.ok(failure);
+   assert.ok(failure.what&&failure.next_action&&failure.evidence.check);
+   assert.deepEqual(await readFile(file),Buffer.concat([bytes,Buffer.from('CORRUPTION')]),'no auto-repair');
+   await writeFile(file,bytes);
+ }
+ assert.equal((await inspectDoctorInstallation(f.pointer,f.state)).status,'PASS');
+ for(const [file,bytes]of f.files)assert.deepEqual(await readFile(file),bytes);
+});
+
+test('R58 doctor stops before following drifted release, generation or config paths',async()=>{
+ const f=await fixture();
+ for(const field of ['release_root','generation_root','config_path']){
+   const result=await inspectDoctorInstallation({...f.pointer,[field]:'C:/DO_NOT_READ_OUTSIDE_FIXTURE'},f.state);
+   assert.equal(result.status,'FAIL');assert.equal(result.findings.length,1);
+   assert.equal(result.findings[0].id,'active_paths');
+ }
+ await assert.rejects(inspectDoctorInstallation({...f.pointer,schema:'invalid'},f.state),/pointer schema/);
+});
+
+test('R58 doctor does not accept a valid-schema pointer to an absent installed slot',async()=>{
+ const f=await fixture();
+ const root=await mkdtemp(path.join(path.dirname(f.state),'doctor-empty-'));
+ const result=await inspectDoctorInstallation({...f.pointer,release_root:path.join(root,'releases',f.pointer.release_id),generation_root:path.join(root,'generations','fixture'),config_path:path.join(root,'generations','fixture','controller-config.psd1')},root);
+ assert.equal(result.status,'FAIL');assert.equal(result.findings[0].id,'active_paths');
+});

package/test/r58-doctor-pointer.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, writeFile, readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { readDoctorActivePointer } from '../src/doctor-r45.mjs';
+
+test('R58 doctor validates canonical active pointer without repair or production fallback', async () => {
+  const base = 'D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
+  await mkdir(base, {recursive:true});
+  const root = await mkdtemp(path.join(base, 'doctor-pointer-green-'));
+  assert.equal(await readDoctorActivePointer(root), null);
+  assert.deepEqual(await readdir(root), []);
+  const pointerPath = path.join(root, 'active-release.json');
+  const valid = {
+    schema:'deadbyte.active-release.v1',version:'0.15.34',
+    manifest_sha256:'a'.repeat(64),release_id:'v0.15.34-'+'a'.repeat(16),
+    generation_manifest_sha256:'b'.repeat(64),launcher_sha256:'c'.repeat(64),
+    release_root:path.join(root,'releases','fixture'),
+    generation_root:path.join(root,'generations','fixture'),config_path:path.join(root,'config.psd1')
+  };
+  for (const [field, value] of [
+    ['schema','INVALID_FIXTURE'],['release_id','fabricated'],
+    ['version','invalid'],['manifest_sha256','bad'],
+    ['generation_manifest_sha256','bad'],['launcher_sha256','bad'],
+    ['config_path',''],['release_root',''],['generation_root','']
+  ]) {
+    const text = JSON.stringify({...valid,[field]:value});
+    await writeFile(pointerPath,text);
+    await assert.rejects(readDoctorActivePointer(root), /active pointer/);
+    assert.equal(await readFile(pointerPath,'utf8'),text);
+  }
+  for (const prefix of ['', '\ufeff']) {
+    const text = prefix+JSON.stringify(valid);
+    await writeFile(pointerPath,text);
+    assert.deepEqual(await readDoctorActivePointer(root),valid);
+    assert.equal(await readFile(pointerPath,'utf8'),text);
+  }
+  await writeFile(pointerPath,'BROKEN_JSON');
+  await assert.rejects(readDoctorActivePointer(root),/active pointer JSON invalid/);
+  assert.deepEqual(await readdir(root),['active-release.json']);
+});

package/test/r58-doctor-runtime.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {classifyDoctorControllerObservation,validateDoctorControllerObservation} from '../src/doctor-runtime-r58.mjs';
+
+const coreRoot='D:/Projects/fixture/core';
+const birth='2026-10-01T00:00:00.000Z';
+const absent={alive:false,reason:'no-ledger',pid:null,creation_time_utc:null};
+const authority=()=>Object.fromEntries(['process','coding','autonomous','desktop','host'].map(k=>[k,{configured:false,armed:false,reason:'no-policy'}]));
+const offline=()=>({schema:'deadbyte.controller-observation.v1',observed_at_utc:birth,state:'OFFLINE',core_root:coreRoot,local_ready:false,bridge:{...absent},cloud:{...absent},core:{alive:false,reason:'bridge-unavailable',pid:null,parent_pid:null,creation_time_utc:null,identity_basis:null},supervisor:{configured:false,running:false,reason:'disabled'},authority:authority()});
+const online=()=>({...offline(),state:'ONLINE',local_ready:true,bridge:{alive:true,reason:'verified',pid:101,creation_time_utc:birth},cloud:{alive:true,reason:'verified',pid:103,creation_time_utc:birth},core:{alive:true,reason:'verified',pid:102,parent_pid:101,creation_time_utc:birth,identity_basis:'command-line'}});
+const missingCore=reason=>({alive:false,reason,pid:null,parent_pid:null,creation_time_utc:null,identity_basis:null});
+test('R58 doctor runtime cannot inherit ONLINE when downstream topology contradicts it',()=>{
+ assert.equal(classifyDoctorControllerObservation(offline(),coreRoot).status,'PASS');
+ const good=classifyDoctorControllerObservation(online(),coreRoot);assert.equal(good.status,'PASS');assert.equal(good.availability.state,'ONLINE');
+ for(const reason of ['ambiguous-core','wrong-core-generation','core-image-mismatch','core-observation-failed']){
+  const report=classifyDoctorControllerObservation({...online(),core:missingCore(reason)},coreRoot);
+  assert.equal(report.status,'FAIL');assert.equal(report.availability.state,'FAILED');assert.ok(report.findings.find(f=>f.id==='runtime_core'&&f.level==='FAIL'));
+ }
+ const transient=classifyDoctorControllerObservation({...online(),core:missingCore('startup-zero-child')},coreRoot);
+ assert.equal(transient.status,'WARN');assert.equal(transient.availability.state,'STARTING');
+});
+test('R58 doctor separates healthy local topology from remote/cloud disconnect',()=>{
+ const partial=classifyDoctorControllerObservation({...online(),state:'DEGRADED',cloud:{...absent,reason:'process-missing'}},coreRoot);
+ assert.equal(partial.availability.local_healthy,true);assert.equal(partial.availability.remote_connected,false);
+ assert.notEqual(partial.availability.state,'ONLINE');assert.equal(partial.status,'WARN');
+ const parked=classifyDoctorControllerObservation({...offline(),state:'PARKED',cloud:online().cloud},coreRoot);
+ assert.equal(parked.availability.state,'PARKED');assert.equal(parked.status,'WARN');
+});
+test('R58 doctor strict snapshot rejects injection, wrong root and topology/schema drift',()=>{
+ for(const changes of [{extra:'injected'},{core_root:'C:/wrong'},{local_ready:'true'},{schema:'invalid'}])assert.throws(()=>validateDoctorControllerObservation({...online(),...changes},coreRoot));
+ assert.throws(()=>validateDoctorControllerObservation({...online(),core:{...online().core,parent_pid:999}},coreRoot));
+ assert.throws(()=>validateDoctorControllerObservation({...online(),bridge:{...online().bridge,reason:'unverified'}},coreRoot));
+ assert.throws(()=>validateDoctorControllerObservation({...offline(),core:{...offline().core,pid:101}},coreRoot));
+ assert.throws(()=>validateDoctorControllerObservation({...online(),authority:{...authority(),host:{configured:false,armed:true,reason:'standing-grant'}}},coreRoot));
+});
+test('R58 doctor surfaces corrupt grants and authority dependency loss without silently disarming',()=>{
+ const corrupt=online();corrupt.authority.coding={configured:true,armed:false,reason:'policy-digest'};
+ const copy=structuredClone(corrupt),result=classifyDoctorControllerObservation(corrupt,coreRoot);
+ assert.equal(result.status,'FAIL');assert.deepEqual(corrupt,copy);
+ const dependent=online();dependent.authority.autonomous={configured:true,armed:true,reason:'standing-grant'};
+ assert.equal(classifyDoctorControllerObservation(dependent,coreRoot).status,'FAIL');
+ const host=online();host.authority.host={configured:true,armed:true,reason:'standing-grant'};
+ const report=classifyDoctorControllerObservation(host,coreRoot);assert.equal(report.status,'WARN');assert.equal(host.authority.host.armed,true);
+ for(const finding of report.findings.filter(f=>f.level!=='PASS'))assert.ok(finding.what&&finding.evidence&&finding.next_action);
+});

package/test/r58-doctor-transactions.test.mjs

@@ -0,0 +1,21 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile,readdir} from 'node:fs/promises';
+import path from 'node:path';
+import {inspectDoctorTransactions} from '../src/doctor-transactions-r58.mjs';
+
+test('R58 bounded transaction inventory flags residue without recovering or overwriting it',async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'doctor-transactions-'));
+ assert.equal((await inspectDoctorTransactions(root)).status,'PASS');assert.deepEqual(await readdir(root),[]);
+ const transactions=path.join(root,'evidence','updates');await mkdir(transactions,{recursive:true});
+ const write=async(name,body)=>{const dir=path.join(transactions,name);await mkdir(dir);const file=path.join(dir,'state.json'),bytes=JSON.stringify(body);await writeFile(file,bytes);return {file,bytes};};
+ const done=await write('done',{schema:'deadbyte.r27-slot-update-state.v1',phase:'completed'});
+ assert.equal((await inspectDoctorTransactions(root)).status,'PASS');
+ const pending=await write('pending',{schema:'deadbyte.r31-slot-rollback-state.v1',phase:'prior_pointer_restored',supervisor_pid:process.pid});
+ const result=await inspectDoctorTransactions(root);assert.equal(result.status,'WARN');assert.ok(result.findings.some(f=>f.evidence.recorded_phase==='prior_pointer_restored'));
+ for(const item of [done,pending])assert.equal(await readFile(item.file,'utf8'),item.bytes);
+ const bounded=await inspectDoctorTransactions(root,{maxEntries:1});assert.equal(bounded.status,'WARN');assert.ok(bounded.findings.some(f=>f.evidence.inventory_complete===false));
+ const corrupt=await write('corrupt',{schema:'INVALID',phase:'completed'});assert.equal((await inspectDoctorTransactions(root)).status,'FAIL');assert.equal(await readFile(corrupt.file,'utf8'),corrupt.bytes);
+ await assert.rejects(inspectDoctorTransactions(root,{maxEntries:257}),/budget invalid/);
+});

package/test/r58-guardian-channel.test.mjs

@@ -0,0 +1,26 @@
+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 {fileURLToPath} from 'node:url';
+import {spawn} from 'node:child_process';
+import {setTimeout as delay} from 'node:timers/promises';
+
+test('R58 guardian rejects an IPC parent that does not match its declared owner before cleanup', {timeout:10000}, async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'guardian-channel-'));await mkdir(path.join(root,'bin'));await mkdir(path.join(root,'runtime'));
+ const trace=path.join(root,'trace.txt'),markerPath=path.join(root,'runtime','remote-session.json');
+ const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid+100000,session_nonce:'c'.repeat(64)};
+ await writeFile(markerPath,JSON.stringify(marker));
+ await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)\n[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine)\nexit 0\n`);
+ const child=spawn(process.execPath,[fileURLToPath(new URL('../src/remote-session-guardian.mjs',import.meta.url)),'--state-root',root,'--owner-pid',String(marker.owner_pid),'--session-nonce',marker.session_nonce,'--owner-channel','ipc'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['ignore','ignore','ignore','ipc']});
+ const closed=new Promise(resolve=>child.once('exit',code=>resolve(code)));
+ try{
+  await delay(400);if(child.connected)child.disconnect();
+  const code=await Promise.race([closed,delay(4000).then(()=>null)]);
+  assert.notEqual(code,null,'wrong parent must fail promptly');
+  assert.notEqual(code,0,'wrong IPC parent must not be accepted');
+  await assert.rejects(readFile(trace),{code:'ENOENT'},'invalid guardian must run no controller commands');
+  assert.deepEqual(JSON.parse(await readFile(markerPath,'utf8')),marker);
+ }finally{if(child.exitCode===null)child.kill();await closed;}
+});

package/test/r58-launcher-shell.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { renderStableLauncherPs1 } from '../src/release-slot.mjs';
+
+test('R58 launcher dispatch uses native Windows PowerShell even when entered from pwsh', async () => {
+  const base = 'D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
+  await mkdir(base, { recursive: true });
+  const fixture = await mkdtemp(path.join(base, 'launcher-shell-'));
+  const controller = path.join(fixture, 'controller.ps1');
+  await writeFile(controller, "param([string]$Action)\nWrite-Output ('FIXTURE:' + $Action)\nexit 7\n");
+  const rendered = renderStableLauncherPs1();
+  const start = rendered.indexOf('$powershell =');
+  assert.ok(start > 0, 'generated launcher has a dispatch boundary');
+  const dispatch = path.join(fixture, 'dispatch.ps1');
+  // Execute the actual generated dispatch, independently of preceding manifest checks.
+  await writeFile(dispatch, "$ErrorActionPreference = 'Stop'\n$controller = '" + controller.replaceAll("'", "''") + "'\n$ControllerArgs = @('status')\n" + rendered.slice(start));
+  const native = path.join(process.env.SystemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+  const modern = path.join(process.env.USERPROFILE, '.cache', 'codex-runtimes', 'codex-primary-runtime', 'dependencies', 'native', 'powershell', 'pwsh.exe');
+  for (const executable of [native, modern]) {
+    const observed = spawnSync(executable, ['-NoProfile', '-File', dispatch], { encoding: 'utf8', timeout: 20000 });
+    assert.ifError(observed.error);
+    assert.equal(observed.status, 7, observed.stderr);
+    assert.match(observed.stdout, /FIXTURE:status/);
+  }
+});

package/test/r58-owner-identity.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {foregroundIdentityMatches,queryForegroundIdentity} from '../src/foreground-process-identity.mjs';
+
+test('R58 owner identity rejects PID reuse and every material identity drift',()=>{
+ const expected={schema:'deadbyte.foreground-process.v1',pid:100,parent_pid:50,creation_utc:'2026-10-01T00:00:00.000Z',executable_path:'C:/Windows/node.exe',command_line_sha256:'a'.repeat(64)};
+ assert.equal(foregroundIdentityMatches(expected,{...expected}),true);
+ assert.equal(foregroundIdentityMatches(expected,null),false);
+ for(const changes of [{pid:101},{parent_pid:51},{creation_utc:'2026-10-01T00:00:01.000Z'},{executable_path:'C:/other/node.exe'},{command_line_sha256:'b'.repeat(64)}])assert.equal(foregroundIdentityMatches(expected,{...expected,...changes}),false);
+ assert.throws(()=>foregroundIdentityMatches(undefined,expected),/unverified/);
+ assert.throws(()=>foregroundIdentityMatches(expected,{}),/incomplete/);
+});
+
+test('R58 narrow identity query binds the current live process and rejects injection',()=>{
+ const identity=queryForegroundIdentity(process.pid);
+ assert.equal(identity.pid,process.pid);assert.equal(identity.parent_pid,process.ppid);
+ assert.equal(foregroundIdentityMatches(identity,queryForegroundIdentity(process.pid)),true);
+ assert.throws(()=>queryForegroundIdentity('1;anything'),/positive Windows PID/);
+ assert.throws(()=>queryForegroundIdentity(0),/positive Windows PID/);
+});

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

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+const json=rel=>read(rel).then(JSON.parse);
+
+test('R58 identity is coherent and parent is exact production-accepted 0.15.34',async()=>{
+  const [pkg,lock,release,prov,matrix,sbom,version,bridgePkg]=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'),json('bridge/package.json')
+  ]);
+  assert.equal(pkg.version,'0.15.35');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.35'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R58');
+  assert.equal(prov.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R58');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(bridgePkg.version,pkg.version);
+  assert.deepEqual(release.runtime_predecessor,{
+    release_id:'v0.15.34-2199bb59f0e0fc20',
+    manifest_sha256:'2199bb59f0e0fc205d470d11f990d3ce3df444be5eba2a7d8dbc60d5f5b790bb',
+    generation_manifest_sha256:'1a20a62aaeb324a9b5c03d158952f35092d58fedf2ac7725820ba2b094a4a88f'
+  });
+  assert.equal(release.parent.tarball_sha256,'a6f7b21faf34793ca17dfb6d0e9ec03320f1468d011e75d8349098df82fc2639');
+});
+
+test('R58 consolidation evidence preserves fail-closed and non-final claims',async()=>{
+  const [release,prov,matrix]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json')]);
+  assert.equal(release.consolidation.bridge_bundled_inside_release,true);
+  assert.equal(release.consolidation.bridge_recursive_local_dependency_binding,true);
+  assert.equal(release.consolidation.bridge_dynamic_relative_import_fail_closed,true);
+  assert.equal(release.consolidation.bridge_path_escape_fail_closed,true);
+  assert.equal(release.consolidation.performance_acceptance,'PASS_BOUNDED_PREPUBLISH');
+  assert.equal(release.consolidation.cross_plane_acceptance,'PASS');
+  assert.equal(release.consolidation.public_surface_compatibility,'PASS_43_TOOLS_NO_SCHEMA_DRIFT');
+  assert.equal(matrix.observed_pre_release_evidence.cross_plane.status,'PASS');
+  assert.equal(matrix.observed_pre_release_evidence.public_surface.candidate_tool_count,43);
+  assert.equal(matrix.observed_pre_release_evidence.performance.status,'PASS_BOUNDED_PREPUBLISH');
+  assert.ok(['PENDING_R58_FRESH','PASS'].includes(matrix.observed_pre_release_evidence.full_regression.status));
+  assert.equal(prov.operator_override.four_hour_soak,'NOT_COMPLETED');
+  assert.equal(prov.operator_override.clean_machine,'NOT_COMPLETED');
+  assert.equal(prov.operator_override.stable_final_claim,false);
+  assert.equal(matrix.operator_override.stable_final_claim,false);
+  assert.equal(release.stabilization.stable_final_claim,false);
+});