deadbyte-mcp 0.15.30 → 0.15.32

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

@@ -0,0 +1,76 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { doctor } from '../src/doctor-r45.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+const provenance=JSON.parse(await readFile(path.join(root,'PROVENANCE.json'),'utf8'));
+const matrix=JSON.parse(await readFile(path.join(root,'TEST-MATRIX.json'),'utf8'));
+const active=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+const manifestSha256=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+
+insist(pkg.version==='0.15.31'&&release.version===pkg.version&&release.train==='R54','R54 candidate identity mismatch');
+insist(release.parent.version==='0.15.30','R54 source parent mismatch');
+insist(release.parent.manifest_sha256==='ddf7c7338d9a371f5667d7b138695e7f9cfced553d14073ac5a44fd2fe0a0399','R54 source parent manifest mismatch');
+insist(release.parent.tarball_sha256==='72881981bf76eb45527946b310caed8387943e2ca8e37ea6e606c32189dd5a70','R54 source parent tarball mismatch');
+insist(
+  active.release_id===release.runtime_predecessor.release_id&&
+  active.manifest_sha256===release.runtime_predecessor.manifest_sha256&&
+  active.generation_manifest_sha256===release.runtime_predecessor.generation_manifest_sha256,
+  'active runtime is not exact sealed 0.15.29 predecessor'
+);
+insist(release.hotfix?.activation_ancestry_excluded===true,'R54 activation ancestry fix missing');
+insist(release.hotfix?.unrelated_stale_runtime_fail_closed===true,'R54 stale-runtime negative control missing');
+insist(provenance.operator_override?.stable_final_claim===false,'R54 must not claim stable/final');
+insist(matrix.operator_override?.four_hour_soak==='NOT_COMPLETED','R54 matrix must preserve soak bypass');
+
+const health=await doctor();
+insist(health.status==='ok'&&health.package_version===pkg.version&&health.manifest?.verified===true,'R54 doctor evidence invalid');
+
+const evidence={
+ schema:'deadbyte.r54-windows-gate.v1',
+ status:'passed',
+ exit_code:0,
+ version:pkg.version,
+ train:'R54',
+ completed_at_utc:new Date().toISOString(),
+ manifest_sha256:manifestSha256,
+ parent:release.parent,
+ runtime_predecessor:release.runtime_predecessor,
+ hotfix:release.hotfix,
+ operator_override:provenance.operator_override,
+ active_predecessor:{
+  release_id:active.release_id,
+  version:active.version,
+  manifest_sha256:active.manifest_sha256,
+  generation_manifest_sha256:active.generation_manifest_sha256
+ },
+ doctor:{verified_entries:health.manifest.verified_entries},
+ gates:{
+  r54_focused:true,
+  package_boundary:true,
+  full_regression:true,
+  manifest_final_verify:true,
+  four_hour_soak_completed:false
+ }
+};
+const bytes=Buffer.from(JSON.stringify(evidence,null,2)+'\n');
+const dir=path.join(stateRoot,'evidence','release');
+await mkdir(dir,{recursive:true});
+const target=path.join(dir,`r54-windows-gate-${manifestSha256.slice(0,16)}.json`);
+try{
+ const handle=await open(target,'wx',0o600);
+ try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+}catch(error){
+ if(error?.code!=='EEXIST')throw error;
+ const prior=JSON.parse(await readFile(target,'utf8'));
+ insist(prior.schema===evidence.schema&&prior.status==='passed'&&prior.version===evidence.version&&prior.manifest_sha256===manifestSha256,'conflicting R54 gate evidence identity');
+}
+console.log(JSON.stringify({status:'passed',path:target,sha256:sha256(bytes),manifest_sha256:manifestSha256}));

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

@@ -0,0 +1,79 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { doctor } from '../src/doctor-r45.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const pkg=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+const provenance=JSON.parse(await readFile(path.join(root,'PROVENANCE.json'),'utf8'));
+const matrix=JSON.parse(await readFile(path.join(root,'TEST-MATRIX.json'),'utf8'));
+const active=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+const manifestSha256=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+
+insist(pkg.version==='0.15.32'&&release.version===pkg.version&&release.train==='R55','R55 candidate identity mismatch');
+insist(release.parent.version==='0.15.31','R55 source parent mismatch');
+insist(release.parent.manifest_sha256==='16854fe5b3eb0fa1c6dd2b96e3c5d6f792c5adbc91dd2a71e7fc2771472bbdd4','R55 source parent manifest mismatch');
+insist(release.parent.tarball_sha256==='ff6eba3036cb00ac639ac8907ad6063e6ea8169cf32aca8721f75b1e403e501a','R55 source parent tarball mismatch');
+insist(
+  active.release_id===release.runtime_predecessor.release_id&&
+  active.manifest_sha256===release.runtime_predecessor.manifest_sha256&&
+  active.generation_manifest_sha256===release.runtime_predecessor.generation_manifest_sha256,
+  'active runtime is not exact sealed 0.15.29 predecessor'
+);
+insist(release.hotfix?.foreground_guardian_owner_parent_binding===true,'R55 guardian owner/parent binding missing');
+insist(release.hotfix?.foreground_guardian_session_nonce_contract===true,'R55 guardian nonce contract missing');
+insist(release.hotfix?.unrelated_stale_runtime_fail_closed===true,'R55 stale-runtime negative control missing');
+insist(release.hotfix?.full_regression==='PASS','R55 full regression metadata is not PASS');
+insist(matrix.observed_pre_release_evidence?.full_regression?.status==='PASS','R55 full regression evidence is not PASS');
+insist(provenance.operator_override?.stable_final_claim===false,'R55 must not claim stable/final');
+insist(matrix.operator_override?.four_hour_soak==='NOT_COMPLETED','R55 matrix must preserve soak bypass');
+
+const health=await doctor();
+insist(health.status==='ok'&&health.package_version===pkg.version&&health.manifest?.verified===true,'R55 doctor evidence invalid');
+
+const evidence={
+ schema:'deadbyte.r55-windows-gate.v1',
+ status:'passed',
+ exit_code:0,
+ version:pkg.version,
+ train:'R55',
+ completed_at_utc:new Date().toISOString(),
+ manifest_sha256:manifestSha256,
+ parent:release.parent,
+ runtime_predecessor:release.runtime_predecessor,
+ hotfix:release.hotfix,
+ operator_override:provenance.operator_override,
+ active_predecessor:{
+  release_id:active.release_id,
+  version:active.version,
+  manifest_sha256:active.manifest_sha256,
+  generation_manifest_sha256:active.generation_manifest_sha256
+ },
+ doctor:{verified_entries:health.manifest.verified_entries},
+ gates:{
+  r55_focused:true,
+  package_boundary:true,
+  full_regression:true,
+  manifest_final_verify:true,
+  four_hour_soak_completed:false
+ }
+};
+const bytes=Buffer.from(JSON.stringify(evidence,null,2)+'\n');
+const dir=path.join(stateRoot,'evidence','release');
+await mkdir(dir,{recursive:true});
+const target=path.join(dir,`r55-windows-gate-${manifestSha256.slice(0,16)}.json`);
+try{
+ const handle=await open(target,'wx',0o600);
+ try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+}catch(error){
+ if(error?.code!=='EEXIST')throw error;
+ const prior=JSON.parse(await readFile(target,'utf8'));
+ insist(prior.schema===evidence.schema&&prior.status==='passed'&&prior.version===evidence.version&&prior.manifest_sha256===manifestSha256,'conflicting R55 gate evidence identity');
+}
+console.log(JSON.stringify({status:'passed',path:target,sha256:sha256(bytes),manifest_sha256:manifestSha256}));

package/src/runtime-update.mjs

@@ -647,6 +647,48 @@ async function readLedger(ctx,name){
 function sameGeneration(a,b){
   return a.pid===b.pid&&a.instance_nonce===b.instance_nonce&&a.creation_time_utc===b.creation_time_utc&&a.image_sha256===b.image_sha256;
 }
+function activationGuardianOwnedByLineage(item,selfLineage){
+  const name=String(item?.Name??'').toLowerCase();
+  if(name!=='node.exe') return false;
+  const commandLine=String(item?.CommandLine??'');
+  if(!commandLine.toLowerCase().includes('remote-session-guardian.mjs')) return false;
+  const ownerMatch=/(?:^|\s)--owner-pid(?:=|\s+)(\d+)(?=\s|$)/i.exec(commandLine);
+  const nonceMatch=/(?:^|\s)--session-nonce(?:=|\s+)([0-9a-f]{64})(?=\s|$)/i.exec(commandLine);
+  if(!ownerMatch||!nonceMatch) return false;
+  const ownerPid=Number(ownerMatch[1]);
+  const parentPid=Number(item?.ParentProcessId);
+  return Number.isInteger(ownerPid)&&ownerPid>0&&parentPid===ownerPid&&selfLineage.has(ownerPid);
+}
+export function selectOfflineRecoveryBlockers(processes,currentPid=process.pid){
+  const list=(Array.isArray(processes)?processes:[processes]).filter(Boolean);
+  const byPid=new Map();
+  for(const item of list){
+    const pid=Number(item?.ProcessId);
+    if(Number.isInteger(pid)&&pid>0) byPid.set(pid,item);
+  }
+  const selfLineage=new Set();
+  let cursor=Number(currentPid);
+  while(Number.isInteger(cursor)&&cursor>0&&!selfLineage.has(cursor)){
+    selfLineage.add(cursor);
+    const item=byPid.get(cursor);
+    if(!item) break;
+    const parent=Number(item?.ParentProcessId);
+    if(!Number.isInteger(parent)||parent<1||parent===cursor) break;
+    cursor=parent;
+  }
+  const runtimeNames=new Set(['node.exe','cloudflared.exe','deadbyte-tunnel-host.exe']);
+  return list.filter(item=>{
+    const pid=Number(item?.ProcessId);
+    if(selfLineage.has(pid)) return false;
+    if(activationGuardianOwnedByLineage(item,selfLineage)) return false;
+    const name=String(item?.Name??'').toLowerCase();
+    if(!runtimeNames.has(name)) return false;
+    const commandLine=String(item?.CommandLine??'').toLowerCase();
+    return commandLine.includes('deadbyte-mcp')||commandLine.includes('mcp-server.mjs')||
+      commandLine.includes('runtime-self-update.mjs')||commandLine.includes('remote-session-guardian.mjs')||
+      commandLine.includes('deadbyte-tunnel-host.exe');
+  });
+}
 function cleanOfflinePredecessor(ctx){
   const runtimeRoot=path.resolve(ctx.runtime_root);
   const blockers=[
@@ -656,19 +698,13 @@ function cleanOfflinePredecessor(ctx){
   ].filter(name=>existsSync(path.join(runtimeRoot,name)));
   if(blockers.length) throw new Error('offline predecessor recovery blocked by runtime state: '+blockers.join(','));
 
-  const command="Get-CimInstance Win32_Process | Where-Object { \$_.Name -in @('node.exe','cloudflared.exe','deadbyte-tunnel-host.exe') } | Select-Object ProcessId,Name,ExecutablePath,CommandLine | ConvertTo-Json -Compress";
+  const command="Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,ExecutablePath,CommandLine | ConvertTo-Json -Compress";
   const result=runCaptured(powershellPath(),['-NoLogo','-NoProfile','-Command',command],{timeoutMs:15000});
   const text=assertRun(result,'runtime process query').trim();
   if(text){
     let parsed;
     try { parsed=JSON.parse(text); } catch(error){ throw new Error('runtime process query JSON invalid: '+error.message); }
-    const processes=(Array.isArray(parsed)?parsed:[parsed]).filter(item=>Number(item?.ProcessId)!==process.pid);
-    const relevant=processes.filter(item=>{
-      const commandLine=String(item?.CommandLine??'').toLowerCase();
-      return commandLine.includes('deadbyte-mcp')||commandLine.includes('mcp-server.mjs')||
-        commandLine.includes('runtime-self-update.mjs')||commandLine.includes('remote-session-guardian.mjs')||
-        commandLine.includes('deadbyte-tunnel-host.exe');
-    });
+    const relevant=selectOfflineRecoveryBlockers(Array.isArray(parsed)?parsed:[parsed],process.pid);
     if(relevant.length) throw new Error('offline predecessor recovery blocked by DEADBYTE runtime processes: '+relevant.map(item=>String(item?.Name??'unknown')+'#'+String(item?.ProcessId??'?')).join(','));
   }
   return {

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.30';
+export const DEADBYTE_VERSION = '0.15.32';
 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/r49-windows-gate.test.mjs

@@ -2,11 +2,15 @@ import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import test from 'node:test';
 
-const read = path => readFile(new URL(`../${path}`, import.meta.url), 'utf8');
+const read=path=>readFile(new URL(`../${path}`,import.meta.url),'utf8');
 
-test('R53 canonical Windows gate is successor-bound and preserves R52/R51/R50/R49 historical gates', async () => {
-  const [pkgText, gate, evidence, historicalR52, historicalEvidenceR52, historicalR51, historicalEvidenceR51, historicalR50, historicalR49, deferred] = await Promise.all([
+test('R55 canonical Windows gate is successor-bound and preserves R54/R53/R52/R51/R50/R49 historical gates',async()=>{
+  const [pkgText,gate,evidence,historicalR54,historicalEvidenceR54,historicalR53,historicalEvidenceR53,historicalR52,historicalEvidenceR52,historicalR51,historicalEvidenceR51,historicalR50,historicalR49,deferred]=await Promise.all([
     read('package.json'),
+    read('scripts/gate-windows-r55.ps1'),
+    read('scripts/windows-gate-evidence-r55.mjs'),
+    read('scripts/gate-windows-r54.ps1'),
+    read('scripts/windows-gate-evidence-r54.mjs'),
     read('scripts/gate-windows-r53.ps1'),
     read('scripts/windows-gate-evidence-r53.mjs'),
     read('scripts/gate-windows-r52.ps1'),
@@ -17,31 +21,35 @@ test('R53 canonical Windows gate is successor-bound and preserves R52/R51/R50/R4
     read('scripts/gate-windows-r49.ps1'),
     read('scripts/deferred-slot-operation-r46.mjs')
   ]);
-  const pkg = JSON.parse(pkgText);
-  assert.match(pkg.scripts['gate:windows'], /gate-windows-r53\.ps1$/);
-  assert.match(gate, /DEADBYTE 0\.15\.30 \/ R53 WINDOWS GATE: PASS/);
-  assert.match(gate, /r53-package-boundary/);
-  assert.match(gate, /r53-focused-contracts/);
-  assert.match(gate, /r49-remote-control-donors\.test\.mjs/);
-  assert.match(gate, /desktop-runtime-r40\.test\.mjs/);
-  assert.match(gate, /manifest-final-verify/);
-  assert.match(evidence, /deadbyte\.r53-windows-gate\.v1/);
-  assert.match(evidence, /pkg\.version === '0\.15\.30'/);
-  assert.match(evidence, /release\.train === 'R53'/);
-  assert.match(evidence, /release\.parent\.version === '0\.15\.29'/);
-  assert.match(evidence, /four_hour_soak_completed: false/);
-  assert.match(historicalR52, /DEADBYTE 0\.15\.29 \/ R52 WINDOWS GATE: PASS/);
-  assert.match(historicalEvidenceR52, /deadbyte\.r52-windows-gate\.v1/);
-  assert.match(historicalR51, /DEADBYTE 0\.15\.28 \/ R51 WINDOWS GATE: PASS/);
-  assert.match(historicalEvidenceR51, /deadbyte\.r51-windows-gate\.v1/);
-  assert.match(historicalR50, /DEADBYTE 0\.15\.27 \/ R50 WINDOWS GATE: PASS/);
-  assert.match(historicalR49, /DEADBYTE 0\.15\.26 \/ R49 WINDOWS GATE: PASS/);
-  assert.match(deferred, /const expectedVersion=packageIdentity\.version/);
-  assert.match(deferred, /'--expected-version',expectedVersion/);
-  assert.match(deferred, /async function awaitHandoffCompletion/);
-  assert.match(deferred, /verifySlotUpdateEnvelope\(envelope,publicKey\)/);
-  assert.match(deferred, /active pointer does not match signed activation receipt/);
-  assert.match(deferred, /failure-receipt\.json/);
-  assert.match(deferred, /await awaitHandoffCompletion\(await runSlotUpdateCli/);
-  assert.doesNotMatch(deferred, /'--expected-version','0\.15\.5'/);
+  const pkg=JSON.parse(pkgText);
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r55\.ps1$/);
+  assert.match(gate,/DEADBYTE 0\.15\.32 \/ R55 WINDOWS GATE: PASS/);
+  assert.match(gate,/r55-package-boundary/);
+  assert.match(gate,/r55-focused-contracts/);
+  assert.match(gate,/full-regression/);
+  assert.match(gate,/manifest-verify/);
+  assert.match(gate,/doctor/);
+  assert.match(evidence,/deadbyte\.r55-windows-gate\.v1/);
+  assert.match(evidence,/pkg\.version==='0\.15\.32'/);
+  assert.match(evidence,/release\.train==='R55'/);
+  assert.match(evidence,/release\.parent\.version==='0\.15\.31'/);
+  assert.match(evidence,/four_hour_soak_completed:false/);
+  assert.match(historicalR54,/DEADBYTE 0\.15\.31 \/ R54 WINDOWS GATE: PASS/);
+  assert.match(historicalEvidenceR54,/deadbyte\.r54-windows-gate\.v1/);
+  assert.match(historicalR53,/DEADBYTE 0\.15\.30 \/ R53 WINDOWS GATE: PASS/);
+  assert.match(historicalEvidenceR53,/deadbyte\.r53-windows-gate\.v1/);
+  assert.match(historicalR52,/DEADBYTE 0\.15\.29 \/ R52 WINDOWS GATE: PASS/);
+  assert.match(historicalEvidenceR52,/deadbyte\.r52-windows-gate\.v1/);
+  assert.match(historicalR51,/DEADBYTE 0\.15\.28 \/ R51 WINDOWS GATE: PASS/);
+  assert.match(historicalEvidenceR51,/deadbyte\.r51-windows-gate\.v1/);
+  assert.match(historicalR50,/DEADBYTE 0\.15\.27 \/ R50 WINDOWS GATE: PASS/);
+  assert.match(historicalR49,/DEADBYTE 0\.15\.26 \/ R49 WINDOWS GATE: PASS/);
+  assert.match(deferred,/const expectedVersion=packageIdentity\.version/);
+  assert.match(deferred,/'--expected-version',expectedVersion/);
+  assert.match(deferred,/async function awaitHandoffCompletion/);
+  assert.match(deferred,/verifySlotUpdateEnvelope\(envelope,publicKey\)/);
+  assert.match(deferred,/active pointer does not match signed activation receipt/);
+  assert.match(deferred,/failure-receipt\.json/);
+  assert.match(deferred,/await awaitHandoffCompletion\(await runSlotUpdateCli/);
+  assert.doesNotMatch(deferred,/'--expected-version','0\.15\.5'/);
 });

package/test/r53-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 r53test=currentPackage.version==='0.15.30'?test:test.skip;
 
-test('R53 current release identity is coherent across package lock source metadata SBOM and gate',async()=>{
+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')
   ]);
@@ -25,7 +27,7 @@ test('R53 current release identity is coherent across package lock source metada
   assert.match(pkg.scripts['r53:focused:test'],/stabilization-semver\.test\.mjs/);
 });
 
-test('R53 lineage binds exact published 0.15.29 as parent and runtime predecessor',async()=>{
+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',
@@ -49,7 +51,7 @@ test('R53 lineage binds exact published 0.15.29 as parent and runtime predecesso
   assert.deepEqual(provenance.runtime_predecessor,parent);
 });
 
-test('R53 records stabilization evidence and explicit soak bypass without STABLE/FINAL claim',async()=>{
+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);

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,61 @@
+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 r54test=currentPackage.version==='0.15.31'?test:test.skip;
+
+r54test('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/);
+});
+
+r54test('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);
+});
+
+r54test('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/r55-offline-predecessor-guardian-family.test.mjs

@@ -0,0 +1,51 @@
+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.R55_RUNTIME_UPDATE_PATH
+  ? path.resolve(process.env.R55_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+'?r55='+Date.now());
+const nonce='a'.repeat(64);
+
+test('R55 excludes the verified foreground remote guardian sibling owned by an activation ancestor',()=>{
+  const processes=[
+    {ProcessId:100,ParentProcessId:50,Name:'node.exe',CommandLine:'node npx-cli.js --yes deadbyte-mcp@0.15.32 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:350,ParentProcessId:300,Name:'node.exe',CommandLine:'node C:\\cache\\deadbyte-mcp\\scripts\\deploy-r48.mjs'},
+    {ProcessId:400,ParentProcessId:350,Name:'node.exe',CommandLine:'node C:\\slot\\deadbyte-mcp\\scripts\\runtime-self-update.mjs --resume-handoff x'},
+    {ProcessId:500,ParentProcessId:300,Name:'node.exe',CommandLine:`node C:\\cache\\deadbyte-mcp\\src\\remote-session-guardian.mjs --state-root C:\\Users\\DEADBYTE\\.deadbyte-mcp --owner-pid 300 --session-nonce ${nonce}`},
+    {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('R55 does not exempt a guardian whose parent does not equal its declared ancestor owner',()=>{
+  const processes=[
+    {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:510,ParentProcessId:999,Name:'node.exe',CommandLine:`node C:\\cache\\deadbyte-mcp\\src\\remote-session-guardian.mjs --owner-pid 300 --session-nonce ${nonce}`}
+  ];
+  assert.deepEqual(runtimeUpdate.selectOfflineRecoveryBlockers(processes,400).map(item=>item.ProcessId),[510]);
+});
+
+test('R55 does not exempt a guardian whose owner is outside the activation lineage',()=>{
+  const processes=[
+    {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:520,ParentProcessId:777,Name:'node.exe',CommandLine:`node C:\\cache\\deadbyte-mcp\\src\\remote-session-guardian.mjs --owner-pid 777 --session-nonce ${nonce}`}
+  ];
+  assert.deepEqual(runtimeUpdate.selectOfflineRecoveryBlockers(processes,400).map(item=>item.ProcessId),[520]);
+});
+
+test('R55 does not exempt a guardian without the signed-session-shaped nonce contract',()=>{
+  const processes=[
+    {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:530,ParentProcessId:300,Name:'node.exe',CommandLine:'node C:\\cache\\deadbyte-mcp\\src\\remote-session-guardian.mjs --owner-pid 300 --session-nonce short'}
+  ];
+  assert.deepEqual(runtimeUpdate.selectOfflineRecoveryBlockers(processes,400).map(item=>item.ProcessId),[530]);
+});

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

@@ -0,0 +1,61 @@
+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('R55 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.32');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.32'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R55');
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R55');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r55:0.15.32');
+  assert.match(pkg.scripts['gate:windows'],/gate-windows-r55\.ps1/);
+  assert.match(pkg.scripts['r55:focused:test'],/r55-offline-predecessor-guardian-family\.test\.mjs/);
+});
+
+test('R55 source predecessor is exact immutable published 0.15.31 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.31');
+  assert.equal(release.parent.release_id,'v0.15.31-16854fe5b3eb0fa1');
+  assert.equal(release.parent.manifest_sha256,'16854fe5b3eb0fa1c6dd2b96e3c5d6f792c5adbc91dd2a71e7fc2771472bbdd4');
+  assert.equal(release.parent.tarball_sha256,'ff6eba3036cb00ac639ac8907ad6063e6ea8169cf32aca8721f75b1e403e501a');
+  assert.equal(release.parent.activation_status,'PUBLISHED_NOT_ACTIVATED');
+  assert.equal(release.source_predecessor.version,'0.15.31');
+  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('R55 records the guardian sibling RED to GREEN and preserves fail-closed negative controls',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.foreground_guardian_owner_parent_binding,true);
+  assert.equal(release.hotfix.foreground_guardian_session_nonce_contract,true);
+  assert.equal(release.hotfix.unrelated_stale_runtime_fail_closed,true);
+  assert.equal(release.hotfix.red_parent_0_15_31,'FAIL_1_OF_4');
+  assert.equal(release.hotfix.green_r55_candidate,'PASS_4_OF_4');
+  assert.equal(release.hotfix.stable_final_claim,false);
+  assert.equal(matrix.observed_pre_release_evidence.red_parent_0_15_31.receipt_sha256,'07ba973aa9224fbb1dde572af35640a1e07ca47273f1e50958d787bfe2aaf429');
+  assert.equal(matrix.observed_pre_release_evidence.green_r55_candidate.receipt_sha256,'a217f72cce51a9daf56136f9075ba487adb2a899c291a63af835ea15f8c632f0');
+  assert.equal(provenance.operator_override.four_hour_soak,'NOT_COMPLETED');
+  assert.equal(provenance.operator_override.stable_final_claim,false);
+  assert.equal(matrix.operator_override.stable_final_claim,false);
+});