deadbyte-mcp 0.15.34 → 0.15.35

package/src/remote-session-guardian.mjs

@@ -8,6 +8,10 @@ import { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
 
 const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park'];
+// This inherited IPC channel is an OS-owned parent lifetime handle, not a PID
+// poll. A reused PID cannot keep a new foreground guardian alive.
+let ownerDisconnected=false;
+process.once('disconnect',()=>{ownerDisconnected=true;});
 
 function parseArgs(argv){
   const out={};
@@ -51,7 +55,10 @@ async function main(){
   const root=resolveStateRoot(args['state-root']);
   const ownerPid=Number(args['owner-pid']);
   const nonce=String(args['session-nonce']||'');
+  const ipcOwner=args['owner-channel']==='ipc';
+  if(ipcOwner&&typeof process.send!=='function')throw new Error('guardian owner IPC channel missing');
   if(!Number.isInteger(ownerPid)||ownerPid<1) throw new Error('guardian owner pid invalid');
+  if(ipcOwner&&process.ppid!==ownerPid)throw new Error('guardian IPC parent does not match declared owner');
   if(!/^[0-9a-f]{64}$/.test(nonce)) throw new Error('guardian session nonce invalid');
 
   const launcher=await requireRegular(path.join(root,'bin','DEADBYTE-MCP.ps1'),'stable DEADBYTE launcher');
@@ -63,7 +70,7 @@ async function main(){
   for(;;){
     const marker=await readMarker(markerPath);
     if(!marker||!markerMatches(marker,{ownerPid,nonce})) return;
-    if(pidAlive(ownerPid)){
+    if(ipcOwner?!ownerDisconnected:pidAlive(ownerPid)){
       await sleep(250);
       continue;
     }

package/src/runtime-update.mjs

@@ -1,7 +1,7 @@
 import { createHash, createPrivateKey, createPublicKey, randomBytes, sign as cryptoSign, verify as cryptoVerify } from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { lstat, mkdir, open, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, open, readFile, readdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -306,6 +306,69 @@ async function normalizeComponentIdentities(config){
   return next;
 }
 
+function bridgeDependencyName(relativePath,usedNames){
+  const normalized=String(relativePath).replaceAll('\\','/').replaceAll('/','_');
+  let name=normalized;
+  if(!/^[A-Za-z0-9._-]{1,32}$/.test(name)||usedNames.has(name)){
+    name=`dep-${sha256Bytes(Buffer.from(String(relativePath),'utf8')).slice(0,20)}`;
+  }
+  if(usedNames.has(name)) throw new Error(`bridge dependency name collision: ${relativePath}`);
+  usedNames.add(name);
+  return name;
+}
+function bridgeStaticRelativeImports(source,file){
+  const found=[];
+  for(const [index,line] of String(source).split(/\r?\n/).entries()){
+    if(/\bimport\s*\(\s*['"]\.\.?\//.test(line)) throw new Error(`bridge dynamic relative import is forbidden: ${file}:${index+1}`);
+    const importStart=/^\s*import\b/.test(line);
+    const exportStart=/^\s*export\b/.test(line)&&/\bfrom\b/.test(line);
+    if(!importStart&&!exportStart) continue;
+    const match=importStart
+      ? /^\s*import\s+(?:(?:[^'"]+?)\s+from\s*)?['"]([^'"]+)['"]\s*;?\s*$/.exec(line)
+      : /^\s*export\s+[^'"]*?\s+from\s*['"]([^'"]+)['"]\s*;?\s*$/.exec(line);
+    if(!match) throw new Error(`bridge import syntax unsupported for dependency binding: ${file}:${index+1}`);
+    if(match[1].startsWith('.')) found.push(match[1]);
+  }
+  return found;
+}
+async function discoverBridgeLocalDependencies(root,entryScript){
+  const absoluteRoot=path.resolve(root),realRoot=await realpath(absoluteRoot);
+  const srcRoot=path.join(absoluteRoot,'src');
+  const queue=[path.resolve(entryScript)],visited=new Set(),files=[];
+  while(queue.length){
+    const current=queue.shift();
+    const currentReal=await realpath(current);
+    const relativeReal=path.relative(realRoot,currentReal);
+    if(relativeReal.startsWith('..')||path.isAbsolute(relativeReal)) throw new Error(`bridge dependency escapes bridge root: ${current}`);
+    if(visited.has(currentReal)) continue;
+    visited.add(currentReal);
+    if(visited.size>16) throw new Error('bridge local dependency closure exceeds 16 files');
+    const stat=await lstat(current);
+    if(!stat.isFile()||stat.isSymbolicLink()) throw new Error(`bridge dependency must be a regular file: ${current}`);
+    const source=await readFile(current,'utf8');
+    const specifiers=bridgeStaticRelativeImports(source,current);
+    if(currentReal!==await realpath(entryScript)) files.push(currentReal);
+    for(const specifier of specifiers){
+      if(!specifier.startsWith('./')) throw new Error(`bridge relative import escapes bridge root: ${specifier}`);
+      if(specifier.includes('?')||specifier.includes('#')) throw new Error(`bridge relative import query/fragment unsupported: ${specifier}`);
+      const resolved=path.resolve(path.dirname(current),specifier);
+      const relative=path.relative(absoluteRoot,resolved);
+      if(relative.startsWith('..')||path.isAbsolute(relative)) throw new Error(`bridge dependency escapes bridge root: ${specifier}`);
+      if(!/\.(?:mjs|js)$/i.test(resolved)) throw new Error(`bridge local dependency must be .mjs/.js: ${specifier}`);
+      queue.push(resolved);
+    }
+  }
+  const unique=[...new Set(files)].sort((a,b)=>a.localeCompare(b));
+  const usedNames=new Set();
+  const dependencies=[];
+  for(const file of unique){
+    const relative=path.relative(srcRoot,file).replaceAll('\\','/');
+    if(relative.startsWith('..')||path.isAbsolute(relative)) throw new Error(`bridge dependency must remain under src: ${file}`);
+    dependencies.push({Name:bridgeDependencyName(relative,usedNames),Path:file,Sha256:await sha256File(file)});
+  }
+  return dependencies;
+}
+
 export async function prepareBridgeSpec(config,bootstrap){
   if(!bootstrap) return structuredClone(config);
   if(typeof bootstrap.root!=='string'||!path.isAbsolute(bootstrap.root)||!HEX64.test(String(bootstrap.scriptSha256??''))) {
@@ -327,6 +390,7 @@ export async function prepareBridgeSpec(config,bootstrap){
   next.Bridge.Arguments='src\\bridge.mjs';
   next.Bridge.ScriptPath=script;
   next.Bridge.ScriptSha256=actual;
+  next.Bridge.Dependencies=await discoverBridgeLocalDependencies(root,script);
   return next;
 }
 
@@ -1334,6 +1398,23 @@ function handoffPriorPointer(body){
 function handoffNewPointer(body){
   return body.new_pointer?parseActivePointer(JSON.stringify(body.new_pointer)):null;
 }
+async function verifyCompletedUpdateReceipt(body,state,statePath,key){
+  const candidate=handoffNewPointer(body),prior=handoffPriorPointer(body);
+  if(!candidate||!samePublicPointer(candidate,statePointer(state,'new_pointer'))||!samePublicPointer(prior,statePointer(state,'prior_pointer'))) throw new Error('completed update handoff pointer binding mismatch');
+  if(state.expected_version!==candidate.version||state.expected_manifest_sha256!==candidate.manifest_sha256) throw new Error('completed update journal subject mismatch');
+  const expectedPath=path.join(path.dirname(statePath),'receipt.json');
+  if(typeof state.receipt_path!=='string'||!path.isAbsolute(state.receipt_path)||path.resolve(state.receipt_path)!==expectedPath||!HEX64.test(String(state.receipt_sha256??''))) throw new Error('completed update receipt reference invalid');
+  const info=await lstat(expectedPath);
+  if(!info.isFile()||info.isSymbolicLink()) throw new Error('completed update receipt must be a regular file');
+  const receipt=await readJson(expectedPath);
+  if(!verifySlotUpdateEnvelope(receipt,key.publicKey)||receipt.receipt_sha256!==state.receipt_sha256) throw new Error('completed update receipt signature or digest mismatch');
+  const subject=receipt.body;
+  if(subject.schema!==UPDATE_SCHEMA||subject.rollback_performed!==false||subject.update_id!==body.update_id||subject.release_version!==candidate.version||subject.candidate_manifest_sha256!==candidate.manifest_sha256||
+     !samePublicPointer(statePointer(subject,'active_pointer'),candidate)||!samePublicPointer(statePointer(subject,'prior_pointer'),prior)||
+     subject.release_slot?.release_id!==candidate.release_id||subject.release_slot?.release_root!==candidate.release_root||subject.release_slot?.manifest_sha256!==candidate.manifest_sha256||
+     subject.generation?.generation_root!==candidate.generation_root||subject.generation?.generation_manifest_sha256!==candidate.generation_manifest_sha256||subject.launcher?.sha256!==candidate.launcher_sha256) throw new Error('completed update receipt subject binding mismatch');
+  return {receipt_path:expectedPath,receipt_sha256:receipt.receipt_sha256};
+}
 async function resumeSlotUpdate({handoffPath}){
   const absoluteHandoff=path.resolve(handoffPath),probe=await readJson(absoluteHandoff);
   const stateRoot=path.resolve(String(probe?.body?.state_root??path.dirname(path.dirname(path.dirname(path.dirname(absoluteHandoff))))));
@@ -1342,8 +1423,9 @@ async function resumeSlotUpdate({handoffPath}){
   if(releaseState.schema!=='deadbyte.r27-slot-update-state.v1'||releaseState.update_id!==body.update_id) throw new Error('handoff state binding mismatch');
   let phase=String(releaseState.phase??'');
   if(phase==='completed'){
+    const verifiedReceipt=await verifyCompletedUpdateReceipt(body,releaseState,statePath,key);
     return {ok:true,resumed:false,completed:true,update_id:body.update_id,state_path:statePath,
-      receipt_path:releaseState.receipt_path??null,receipt_sha256:releaseState.receipt_sha256??null};
+      ...verifiedReceipt,historical_receipt_verified:true,current_runtime_verified:false};
   }
   if(phase.startsWith('failed')) throw new Error('slot update already failed at phase='+phase);
   const priorPointer=handoffPriorPointer(body),candidatePointer=handoffNewPointer(body);
@@ -1735,6 +1817,7 @@ export async function runSlotUpdateCli(argv=process.argv.slice(2),{stateRoot=DEF
     console.log('UPDATE_ID '+result.update_id);
     console.log('STATE_PATH '+result.state_path);
     if(result.receipt_sha256) console.log('RECEIPT_SHA256 '+result.receipt_sha256);
+    if(result.historical_receipt_verified===true) console.log('VERIFICATION_SCOPE historical-signed-receipt; current-runtime-not-observed');
     return result;
   }
   if(argv.includes('--recover-interrupted')){

package/src/version.mjs

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

package/test/controller-r211.test.mjs

@@ -17,5 +17,8 @@ test('R21.1 binds controller execution to CoreRoot controller directory', async
 
 test('R21.1 validates controller root before creating command runtime directories', async () => {
   const source = await readFile(controller, 'utf8');
-  assert.match(source, /function Run-Command[\s\S]*?\$cfg = Get-Config\s+Assert-ControllerRootBound \$cfg\s+Ensure-Directory \$RuntimeDir/);
+  const dispatch = source.slice(source.indexOf('function Run-CommandCore('), source.indexOf('function Run-Command(', source.indexOf('function Run-CommandCore(')));
+  assert.match(dispatch, /\$cfg = Get-Config\s+Assert-ControllerRootBound \$cfg\s+\$readOnly = \$Name -in/);
+  assert.match(dispatch, /if \(-not \$readOnly\) \{ Ensure-Directory \$RuntimeDir; Ensure-Directory \$LogDir \}/);
+  assert.ok(dispatch.indexOf('Assert-ControllerRootBound $cfg') < dispatch.indexOf('Ensure-Directory $RuntimeDir'));
 });

package/test/controller.test.mjs

@@ -12,7 +12,8 @@ test('controller derives runtime state from observed identities and readiness',
   assert.match(source, /'OFFLINE'/);
   assert.match(source, /'PARKED'/);
   assert.match(source, /'ONLINE'/);
-  assert.match(source, /'DEGRADED'/);
+  assert.match(source, /'STARTING'/);
+  assert.match(source, /'FAILED'/);
   assert.doesNotMatch(source, /state\.txt/i);
 });
 

package/test/helpers/r58-doctor-fixture.mjs

@@ -0,0 +1,26 @@
+import {cp,mkdir,mkdtemp,readFile,writeFile,readdir,symlink} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createHash} from 'node:crypto';
+
+const source=fileURLToPath(new URL('../..',import.meta.url));
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+export async function makeDoctorCliFixture(){
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'doctor-cli-')),pkg=path.join(root,'package'),state=path.join(root,'state'),temp=path.join(root,'temp');
+ await mkdir(pkg);await mkdir(state);await mkdir(temp);await mkdir(path.join(pkg,'bin'));
+ // Test-only package copy: current source bytes plus required doctor metadata.
+ // This is NOT an npm pack, immutable slot, or release acceptance artifact.
+ await cp(path.join(source,'src'),path.join(pkg,'src'),{recursive:true});
+ await cp(path.join(source,'bridge'),path.join(pkg,'bridge'),{recursive:true});
+ for(const file of ['package.json','RELEASE.json','TEST-MATRIX.json','PROVENANCE.json','SBOM.cdx.json','bin/deadbyte-hardware-observer-r45.exe'])await cp(path.join(source,file),path.join(pkg,file));
+ const rows=[];
+ const walk=async dir=>{for(const entry of await readdir(dir,{withFileTypes:true})){const file=path.join(dir,entry.name);if(entry.isDirectory())await walk(file);else if(entry.isFile())rows.push(sha(await readFile(file))+'  '+path.relative(pkg,file).replaceAll('\\','/'));else throw new Error('unexpected fixture source link');}};
+ await walk(pkg);rows.sort();await writeFile(path.join(pkg,'MANIFEST.SHA256'),rows.join('\n')+'\n');
+ // Dependency junction belongs exclusively to this fresh fixture and points to
+ // candidate dependencies, never production state or a release slot.
+ await symlink(path.join(source,'node_modules'),path.join(pkg,'node_modules'),'junction');
+ const env={...process.env};for(const key of Object.keys(env))if(key.startsWith('DEADBYTE_'))delete env[key];
+ Object.assign(env,{DEADBYTE_STATE_ROOT:state,TEMP:temp,TMP:temp});
+ return {root,pkg,state,env,entry:path.join(pkg,'src','deadbyte-cli.mjs'),manifestFiles:rows.length};
+}

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

@@ -4,7 +4,7 @@ import test from 'node:test';
 
 const read=path=>readFile(new URL(`../${path}`,import.meta.url),'utf8');
 
-test('R57 canonical Windows gate is successor-bound and preserves R56/R55/R54/R53/R52/R51/R50/R49 historical gates',async()=>{
+test('R58 canonical Windows gate is successor-bound while the R57/R56/R55/R54/R53/R52/R51/R50/R49 historical gates stay frozen',async()=>{
   const [pkgText,gate,evidence,historicalR56,historicalEvidenceR56,historicalR55,historicalEvidenceR55,historicalR54,historicalEvidenceR54,historicalR53,historicalEvidenceR53,historicalR52,historicalEvidenceR52,historicalR51,historicalEvidenceR51,historicalR50,historicalR49,deferred]=await Promise.all([
     read('package.json'),
     read('scripts/gate-windows-r57.ps1'),
@@ -26,7 +26,7 @@ test('R57 canonical Windows gate is successor-bound and preserves R56/R55/R54/R5
     read('scripts/deferred-slot-operation-r46.mjs')
   ]);
   const pkg=JSON.parse(pkgText);
-  assert.match(pkg.scripts['gate:windows'],/gate-windows-r57\.ps1$/);
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r58\.ps1$/);
   assert.match(gate,/DEADBYTE 0\.15\.34 \/ R57 WINDOWS GATE: PASS/);
   assert.match(gate,/r57-package-boundary/);
   assert.match(gate,/r57-focused-contracts/);

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

@@ -5,8 +5,10 @@ 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 r57test=currentPackage.version==='0.15.34'?test:test.skip;
 
-test('R57 release identity is coherent across package lock source metadata SBOM and gate',async()=>{
+r57test('R57 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')
   ]);
@@ -25,7 +27,7 @@ test('R57 release identity is coherent across package lock source metadata SBOM
   assert.match(pkg.scripts['r57:focused:test'],/r57-core-startup-race\.test\.mjs/);
 });
 
-test('R57 source and runtime predecessor are exact active published 0.15.33',async()=>{
+r57test('R57 source and runtime predecessor are exact active published 0.15.33',async()=>{
   const [release,provenance]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json')]);
   assert.equal(release.parent.version,'0.15.33');
   assert.equal(release.parent.release_id,'v0.15.33-776a51cb916e28dd');
@@ -44,7 +46,7 @@ test('R57 source and runtime predecessor are exact active published 0.15.33',asy
   assert.deepEqual(provenance.runtime_predecessor,release.runtime_predecessor);
 });
 
-test('R57 records bounded zero-child retry RED to GREEN and preserves fail-closed controls',async()=>{
+r57test('R57 records bounded zero-child retry RED to GREEN and preserves fail-closed controls',async()=>{
   const [release,provenance,matrix]=await Promise.all([json('RELEASE.json'),json('PROVENANCE.json'),json('TEST-MATRIX.json')]);
   assert.equal(release.hotfix.bounded_core_discovery_after_online,true);
   assert.equal(release.hotfix.retry_only_missing_core,true);

package/test/r58-bridge-dependency-binding.test.mjs

@@ -0,0 +1,62 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,writeFile,readFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const target=process.env.R58_RUNTIME_UPDATE_PATH
+  ? path.resolve(process.env.R58_RUNTIME_UPDATE_PATH)
+  : path.resolve(new URL('../src/runtime-update.mjs',import.meta.url).pathname.replace(/^\/(?:[A-Za-z]:)/,m=>m.slice(1)));
+const {prepareBridgeSpec}=await import(new URL('file:///'+target.replaceAll('\\','/')).href+'?r58-bridge-deps='+Date.now());
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r58-bridge-deps-'));
+  await mkdir(path.join(root,'src'),{recursive:true});
+  await writeFile(path.join(root,'package.json'),JSON.stringify({name:'deadbyte-chatgpt-bridge',version:'0.58.0'})+'\n');
+  await writeFile(path.join(root,'src','bridge.mjs'),
+    "import './a.mjs';\nimport {b} from './b.mjs';\nexport const ready=b;\n");
+  await writeFile(path.join(root,'src','a.mjs'),
+    "import './nested/c.mjs';\nexport const a=1;\n");
+  await mkdir(path.join(root,'src','nested'));
+  await writeFile(path.join(root,'src','nested','c.mjs'),'export const c=3;\n');
+  await writeFile(path.join(root,'src','b.mjs'),'export const b=2;\n');
+  const script=path.join(root,'src','bridge.mjs');
+  return {root,script,scriptSha:sha(await readFile(script))};
+}
+function baseConfig(){
+  return {Bridge:{FilePath:process.execPath,FileSha256:'0'.repeat(64),Arguments:'src\\old.mjs',WorkingDirectory:path.parse(process.execPath).root,ScriptPath:'x',ScriptSha256:'0'.repeat(64)},Cloud:{}};
+}
+
+test('R58 bridge bootstrap binds the complete recursive local static import closure',async()=>{
+  const f=await fixture();
+  const out=await prepareBridgeSpec(baseConfig(),{root:f.root,scriptSha256:f.scriptSha});
+  const deps=out.Bridge.Dependencies;
+  assert.ok(Array.isArray(deps),'Bridge.Dependencies must be materialized by bootstrap');
+  assert.deepEqual(deps.map(x=>x.Name),['a.mjs','b.mjs','nested_c.mjs']);
+  for(const dep of deps){
+    assert.match(dep.Sha256,/^[0-9a-f]{64}$/);
+    assert.equal(dep.Sha256,sha(await readFile(dep.Path)));
+  }
+});
+
+test('R58 bridge dependency discovery rejects relative dynamic imports',async()=>{
+  const f=await fixture();
+  await writeFile(f.script,"const x=await import('./a.mjs');\nexport default x;\n");
+  const scriptSha=sha(await readFile(f.script));
+  await assert.rejects(
+    prepareBridgeSpec(baseConfig(),{root:f.root,scriptSha256:scriptSha}),
+    /dynamic relative import/i
+  );
+});
+
+test('R58 bridge dependency discovery rejects path escape',async()=>{
+  const f=await fixture();
+  await writeFile(f.script,"import '../escape.mjs';\n");
+  const scriptSha=sha(await readFile(f.script));
+  await assert.rejects(
+    prepareBridgeSpec(baseConfig(),{root:f.root,scriptSha256:scriptSha}),
+    /escapes bridge root|relative import/i
+  );
+});

package/test/r58-bundled-bridge.test.mjs

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+test('R58 deployment activates the bridge bundled inside the candidate release, not predecessor mutable workspace',async()=>{
+  const deploy=await readFile(new URL('../scripts/deploy-r48.mjs',import.meta.url),'utf8');
+  assert.match(deploy,/const bridgeRoot=path\.join\(root,'bridge'\)/);
+  assert.doesNotMatch(deploy,/bridgeRoot=path\.resolve\(cfg\.Bridge\.WorkingDirectory\)/);
+  assert.match(deploy,/const bridgeScript=path\.join\(bridgeRoot,'src','bridge\.mjs'\)/);
+});
+
+test('R58 bundled bridge package is present and version-bound to 0.15.35',async()=>{
+  const [pkg,bridgePkg,bridge]=await Promise.all([
+    readFile(new URL('../package.json',import.meta.url),'utf8').then(JSON.parse),
+    readFile(new URL('../bridge/package.json',import.meta.url),'utf8').then(JSON.parse),
+    readFile(new URL('../bridge/src/bridge.mjs',import.meta.url),'utf8')
+  ]);
+  assert.equal(bridgePkg.name,'deadbyte-chatgpt-bridge');
+  assert.equal(bridgePkg.version,'0.15.35');
+  assert.equal(pkg.version,'0.15.35');
+  assert.match(bridge,/node-http-adapter\.mjs/);
+});

package/test/r58-cleanup-retention.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+
+test('R58 foreground cleanup failure retains ownership evidence for recovery', {timeout:30000}, async () => {
+  const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';
+  await mkdir(base,{recursive:true});
+  const root=await mkdtemp(path.join(base,'cleanup-'));
+  await mkdir(path.join(root,'bin'));
+  await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)
+switch ($Command) {
+ 'status' { Write-Output 'DEADBYTE MCP = ONLINE'; Write-Output 'Bridge PID   : 1001 [verified]'; Write-Output 'Cloud PID    : 1002 [verified]'; Write-Output 'Local ready  : True'; Write-Output 'Loop supervisor: RUNNING [verified]' }
+ 'processstatus' { Write-Output 'Process plane  : ARMED [standing-grant]' }
+ 'codingstatus' { Write-Output 'Coding plane  : ARMED [standing-grant]' }
+ 'autonomousstatus' { Write-Output 'Autonomous     : ARMED [standing-grant]' }
+ 'desktopstatus' { Write-Output 'Desktop plane : DISARMED [disarmed]' }
+ 'hoststatus' { Write-Output 'Host plane    : DISARMED [disarmed]' }
+ 'disarmprocess' { exit 9 }
+ default { Write-Output "$Command OK" }
+}
+exit 0
+`);
+  const child=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},windowsHide:true,stdio:['pipe','pipe','pipe']});
+  let stdout='',stderr='';
+  child.stdout.on('data',b=>{stdout+=b;});child.stderr.on('data',b=>{stderr+=b;});
+  const closed=new Promise(resolve=>child.once('close',code=>resolve(code)));
+  try {
+    const deadline=Date.now()+12000;
+    while(!stdout.includes('ARMED: process, coding, autonomous')&&child.exitCode===null&&Date.now()<deadline) await delay(50);
+    assert.match(stdout,/ARMED: process, coding, autonomous/,stderr);
+    child.stdin.end();
+    assert.notEqual(await closed,0,'cleanup failure must not report a successful foreground exit');
+    assert.match(stderr,/cleanup disarmprocess exit=9/);
+    const marker=JSON.parse(await readFile(path.join(root,'runtime','remote-session.json'),'utf8'));
+    assert.equal(marker.owner_pid,child.pid);
+    assert.match(marker.session_nonce,/^[0-9a-f]{64}$/);
+  } finally {
+    if(child.exitCode===null) child.kill();
+    // A failed cleanup intentionally leaves state as reproducible evidence.
+  }
+});

package/test/r58-completed-update-receipt.test.mjs

@@ -0,0 +1,76 @@
+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 {generateKeyPairSync,createHash,sign} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {verifySlotUpdateEnvelope} from '../src/runtime-update.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'?Object.fromEntries(Object.keys(value).sort().map(k=>[k,canonical(value[k])])):value;
+const json=value=>JSON.stringify(canonical(value));
+const domain=Buffer.from('DEADBYTE-R27-SLOT-UPDATE-V1\0');
+const cli=fileURLToPath(new URL('../scripts/runtime-self-update.mjs',import.meta.url));
+
+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,'completed-receipt-'));await mkdir(path.join(root,'trust'));
+ const keys=generateKeyPairSync('ed25519');
+ await writeFile(path.join(root,'trust','ed25519-private.pem'),keys.privateKey.export({type:'pkcs8',format:'pem'}));
+ await writeFile(path.join(root,'trust','ed25519-public.pem'),keys.publicKey.export({type:'spki',format:'pem'}));
+ const envelope=body=>{const bytes=Buffer.from(json(body));const value={body,body_sha256:sha(bytes),attestation:{algorithm:'ed25519',domain:'DEADBYTE-R27-SLOT-UPDATE-V1',key_id:sha(keys.publicKey.export({type:'spki',format:'der'})),signature_base64:sign(null,Buffer.concat([domain,bytes]),keys.privateKey).toString('base64')}};return {...value,receipt_sha256:sha(Buffer.from(json(value)))};};
+ const dir=path.join(root,'evidence','updates','fixture');await mkdir(dir,{recursive:true});
+ const statePath=path.join(dir,'state.json'),handoffPath=path.join(dir,'handoff.json'),supervisor=path.join(root,'supervisor.mjs');
+ await writeFile(supervisor,'// hash fixture; must never execute\n');
+ const pointer={schema:'deadbyte.active-release.v1',version:'0.15.34',manifest_sha256:'a'.repeat(64),release_id:'v0.15.34-'+('a'.repeat(16)),release_root:path.join(root,'releases','fixture'),generation_root:path.join(root,'generations','fixture'),generation_manifest_sha256:'b'.repeat(64),launcher_sha256:'c'.repeat(64),config_path:path.join(root,'generations','fixture','controller-config.psd1')};
+ const body={schema:'deadbyte.r27-slot-update-handoff.v1',update_id:'fixture',state_root:root,state_path:statePath,handoff_path:handoffPath,supervisor_script:supervisor,supervisor_script_sha256:sha(await readFile(supervisor)),prior_pointer:null,new_pointer:pointer};
+ await writeFile(handoffPath,JSON.stringify(envelope(body)));
+ const state={schema:'deadbyte.r27-slot-update-state.v1',update_id:'fixture',phase:'completed',expected_version:pointer.version,expected_manifest_sha256:pointer.manifest_sha256,prior_pointer:null,new_pointer:pointer};
+ await writeFile(statePath,JSON.stringify(state));
+ const run=()=>spawnSync(process.execPath,[cli,'--resume-handoff',handoffPath],{encoding:'utf8',timeout:15000,env:{...process.env,DEADBYTE_STATE_ROOT:root}});
+ return {root,dir,state,statePath,body,pointer,envelope,run,publicKey:keys.publicKey};
+}
+
+test('R58 completed update cannot return PASS without its signed subject-bound completion receipt',async()=>{
+ const f=await fixture(),before=await readFile(f.statePath,'utf8'),inventory=await readdir(f.dir);
+ const observed=f.run();await writeFile(path.join(f.root,'observation.json'),JSON.stringify({code:observed.status,stdout:observed.stdout,stderr:observed.stderr}),{flag:'wx'});
+ assert.notEqual(observed.status,0,'completed journal alone must not produce RESUME_PASS');
+ assert.doesNotMatch(observed.stdout,/RESUME_PASS/);assert.equal(await readFile(f.statePath,'utf8'),before);
+ assert.deepEqual(await readdir(f.dir),inventory,'no leases, recovery or controller effects');
+});
+
+test('R58 repeated completed update verifies signed subject, not merely a signature or journal flag',async()=>{
+ const f=await fixture(),receiptPath=path.join(f.dir,'receipt.json');
+ const subject={schema:'deadbyte.r27-slot-update-receipt.v1',rollback_performed:false,update_id:'fixture',release_version:f.pointer.version,candidate_manifest_sha256:f.pointer.manifest_sha256,prior_pointer:null,active_pointer:f.pointer,
+  release_slot:{release_id:f.pointer.release_id,release_root:f.pointer.release_root,manifest_sha256:f.pointer.manifest_sha256},generation:{generation_root:f.pointer.generation_root,generation_manifest_sha256:f.pointer.generation_manifest_sha256},launcher:{sha256:f.pointer.launcher_sha256}};
+ const invoke=async(body,changes={},tamper=null)=>{
+  let receipt=f.envelope(body);assert.equal(verifySlotUpdateEnvelope(receipt,f.publicKey),true,'independent fixture signing is valid before tampering');
+  if(tamper)receipt=tamper(receipt);
+  await writeFile(receiptPath,JSON.stringify(receipt));
+  const state={...f.state,receipt_path:receiptPath,receipt_sha256:receipt.receipt_sha256,...changes};await writeFile(f.statePath,JSON.stringify(state));
+  const before=await readFile(f.statePath,'utf8'),inventory=await readdir(f.dir),observed=f.run();
+  assert.equal(await readFile(f.statePath,'utf8'),before);assert.deepEqual(await readdir(f.dir),inventory);
+  return observed;
+ };
+ const accepted=await invoke(subject);assert.equal(accepted.status,0,accepted.stderr);assert.match(accepted.stdout,/RESUME_PASS/);assert.match(accepted.stdout,/historical-signed-receipt; current-runtime-not-observed/);
+ for(const changes of [
+  {schema:'deadbyte.r31-slot-rollback-receipt.v1'},{rollback_performed:true},{rollback_performed:undefined},{update_id:'other'},
+  {release_version:'0.15.33'},{candidate_manifest_sha256:'d'.repeat(64)},
+  {active_pointer:{...f.pointer,generation_manifest_sha256:'d'.repeat(64)}},
+  {prior_pointer:f.pointer},
+  {release_slot:{...subject.release_slot,release_root:path.join(f.root,'wrong')}},
+  {generation:{...subject.generation,generation_manifest_sha256:'d'.repeat(64)}},
+  {launcher:{sha256:'d'.repeat(64)}}
+ ]){
+  const observed=await invoke({...subject,...changes});assert.notEqual(observed.status,0,JSON.stringify(changes));assert.doesNotMatch(observed.stdout,/RESUME_PASS/);
+ }
+ for(const changes of [{receipt_sha256:'d'.repeat(64)},{receipt_path:path.join(f.dir,'other.json')},{expected_version:'0.15.33'},{new_pointer:{...f.pointer,launcher_sha256:'d'.repeat(64)}}]){
+  assert.notEqual((await invoke(subject,changes)).status,0,JSON.stringify(changes));
+ }
+ const badSignature=await invoke(subject,{},receipt=>{
+  const altered={...receipt,attestation:{...receipt.attestation,signature_base64:Buffer.alloc(64).toString('base64')}};
+  const {receipt_sha256,...unsigned}=altered;return {...unsigned,receipt_sha256:sha(Buffer.from(json(unsigned)))};
+ });
+ assert.notEqual(badSignature.status,0);assert.doesNotMatch(badSignature.stdout,/RESUME_PASS/);
+});

package/test/r58-concurrent-recovery.test.mjs

@@ -0,0 +1,54 @@
+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 simultaneous stale recovery cannot both revoke the shared authority', {timeout:25000},async()=>{
+ const base='D:/Projects/deadbyte-mcp/testing/0.15.35/fixtures';await mkdir(base,{recursive:true});
+ const root=await mkdtemp(path.join(base,'concurrent-recovery-'));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');
+ await writeFile(markerPath,JSON.stringify({schema:'deadbyte.remote-session.v1',pid:2147483000,started_at_utc:'2000-01-01T00:00:00.000Z'}));
+ await writeFile(path.join(root,'bin','DEADBYTE-MCP.ps1'),`param([string]$Command)
+$ErrorActionPreference='Stop'
+for($i=0;$i -lt 40;$i++){try{[IO.File]::AppendAllText('${trace.replaceAll("'","''")}',$Command+[Environment]::NewLine);break}catch{if($i -eq 39){throw};Start-Sleep -Milliseconds 10}}
+switch($Command){
+ 'status' {Write-Output 'DEADBYTE MCP = ONLINE';Write-Output 'Bridge PID   : 1001 [verified]';Write-Output 'Cloud PID    : 1002 [verified]';Write-Output 'Local ready  : True';Write-Output 'Loop supervisor: RUNNING [verified]'}
+ 'processstatus' {Write-Output 'Process plane  : ARMED [standing-grant]'}
+ 'codingstatus' {Write-Output 'Coding plane  : ARMED [standing-grant]'}
+ 'autonomousstatus' {Write-Output 'Autonomous     : ARMED [standing-grant]'}
+ 'desktopstatus' {Write-Output 'Desktop plane : DISARMED [disarmed]'}
+ 'hoststatus' {Write-Output 'Host plane    : DISARMED [disarmed]'}
+ 'park' {
+  $first=$false
+  try{$f=[IO.File]::Open((Join-Path $env:DEADBYTE_STATE_ROOT 'park-claim'),[IO.FileMode]::CreateNew);$f.Dispose();$first=$true}catch{}
+  if(-not $first){
+   $until=[DateTime]::UtcNow.AddSeconds(6)
+   while([DateTime]::UtcNow -lt $until){
+    try{$m=[IO.File]::ReadAllText((Join-Path $env:DEADBYTE_STATE_ROOT 'runtime/remote-session.json'))|ConvertFrom-Json;if($m.schema -eq 'deadbyte.remote-session.v2'){break}}catch{}
+    Start-Sleep -Milliseconds 20
+   }
+  }
+ }
+}
+exit 0
+`);
+ const children=[],outputs=[];
+ try{
+  for(let i=0;i<2;i++){
+   const c=spawn(process.execPath,[fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url)),'remote'],{env:{...process.env,DEADBYTE_STATE_ROOT:root},stdio:['pipe','pipe','pipe'],windowsHide:true});
+   const o={stdout:'',stderr:''};c.stdout.on('data',b=>{o.stdout+=b;});c.stderr.on('data',b=>{o.stderr+=b;});o.exit=new Promise(resolve=>c.once('exit',resolve));children.push(c);outputs.push(o);
+  }
+  const until=Date.now()+12000;let commands=[];
+  while(Date.now()<until){try{commands=(await readFile(trace,'utf8')).trim().split(/\r?\n/);}catch{}if(commands.includes('hoststatus'))break;await delay(50);}
+  await writeFile(path.join(root,'observation.json'),JSON.stringify({commands,outputs:outputs.map(o=>({stdout:o.stdout,stderr:o.stderr})),simulation:'concurrent stale marker recovery with delayed second park'}),{flag:'wx'});
+  assert.ok(commands.includes('hoststatus'),'a recovered foreground must become ready');
+  for(const cmd of ['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost'])assert.equal(commands.filter(x=>x===cmd).length,1,`stale recovery must serialize ${cmd}`);
+ }finally{
+  for(const c of children)if(c.exitCode===null)c.stdin.end();
+  await Promise.race([Promise.all(outputs.map(o=>o.exit)),delay(7000)]);
+  for(const c of children)if(c.exitCode===null&&c.signalCode===null)c.kill();
+ }
+});

package/test/r58-controller-core-observation.test.mjs

@@ -0,0 +1,36 @@
+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 core observation is parent/generation bound, singular and never retries ambiguity',async()=>{
+ const source=await readFile(new URL('../controller/deadbyte-controller.ps1',import.meta.url),'utf8');
+ const start=source.indexOf('function Get-DownstreamCoreObservation('),end=source.indexOf('function Get-StructuredObservation(',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-observation-'));
+ const child={ProcessId:21,ParentProcessId:20,ExecutablePath:'C:/node.exe',CommandLine:'node.exe "C:/core/src/mcp-server.mjs"',CreationDate:'2026-10-01T00:00:00.000Z'};
+ const cases=[
+  {children:[child],reason:'verified',alive:true},
+  {children:[],reason:'startup-zero-child',alive:false},
+  {children:[child,{...child,ProcessId:22}],reason:'ambiguous-core',alive:false},
+  {children:[{...child,ParentProcessId:999}],reason:'core-identity-incomplete',alive:false},
+  {children:[{...child,CommandLine:'node.exe C:/old/src/mcp-server.mjs'}],reason:'wrong-core-generation',alive:false},
+  {children:[{...child,ExecutablePath:'C:/wrong/node.exe'}],reason:'core-image-mismatch',alive:false},
+  {children:[{...child,CommandLine:''}],reason:'verified',alive:true},
+  {children:[child],reason:'bridge-config-mismatch',alive:false,scriptDrift:true},
+  {children:[child],reason:'bridge-unavailable',alive:false,bridgeDead:true},
+  {children:[child],reason:'core-observation-failed',alive:false,queryError:true}
+ ];
+ const data=path.join(root,'cases.json');await writeFile(data,JSON.stringify(cases));
+ const script=path.join(root,'fixture.ps1');
+ await writeFile(script,`Set-StrictMode -Version 3.0\n$ErrorActionPreference='Stop'\n${source.slice(start,end)}\nfunction Get-CimInstance { param($ClassName,$Filter,$ErrorAction) $script:Queries++; if ($script:FixtureQueryError) { throw 'fixture failure' }; return $script:FixtureChildren }\n$cases=Get-Content -LiteralPath '${data.replaceAll("'","''")}' -Raw | ConvertFrom-Json\nforeach($case in $cases) {\n $script:Queries=0; $script:FixtureQueryError=($case.PSObject.Properties.Name -contains 'queryError'); $script:FixtureChildren=@($case.children)\n foreach($item in $script:FixtureChildren) { $item.CreationDate=[DateTime]::Parse($item.CreationDate).ToUniversalTime() }\n $cfg=@{CoreRoot='C:/core';Bridge=@{FilePath='C:/node.exe';ScriptPath='C:/bridge.mjs';ScriptSha256='${'a'.repeat(64)}'}}\n $ledger=[pscustomobject]@{pid=20;script_path='C:/bridge.mjs';script_sha256='${'a'.repeat(64)}'}\n if($case.PSObject.Properties.Name -contains 'scriptDrift') { $ledger.script_sha256='${'b'.repeat(64)}' }\n $bridge=[pscustomobject]@{Alive=(-not ($case.PSObject.Properties.Name -contains 'bridgeDead'));Ledger=$ledger}\n $observed=Get-DownstreamCoreObservation $cfg $bridge\n [pscustomobject]@{expected=$case.reason;observed=$observed;queries=$script:Queries} | ConvertTo-Json -Depth 5 -Compress | Write-Output\n}\n`);
+ const r=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(r.status,0,r.stderr);
+ const observed=r.stdout.trim().split(/\r?\n/).map(line=>JSON.parse(line));assert.equal(observed.length,cases.length);
+ observed.forEach((row,i)=>{assert.equal(row.observed.reason,cases[i].reason);assert.equal(row.observed.alive,cases[i].alive);assert.equal(row.queries,cases[i].scriptDrift||cases[i].bridgeDead?0:1);});
+ assert.equal(observed[6].observed.identity_basis,'verified-bridge-single-opaque-node-child');
+ assert.ok(!r.stdout.includes(child.CommandLine),'no raw command line publication');
+});