deadbyte-mcp 0.15.33 → 0.15.35

package/src/doctor-installation-r58.mjs

@@ -0,0 +1,63 @@
+import { lstat, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parseActivePointer, parseManifest, sha256Bytes, verifyManifestTree } from './release-slot.mjs';
+import { verifyGenerationBundle } from './release-generation.mjs';
+import { resolveStateRoot } from './state-root.mjs';
+
+async function regularPath(state, target, directory=false) {
+  const relative=path.relative(state,target);
+  if(!relative||relative.startsWith('..'+path.sep)||relative==='..'||path.isAbsolute(relative))throw new Error('containment');
+  let cursor=state;
+  const parts=relative.split(path.sep);
+  for(let i=-1;i<parts.length;i++){
+    if(i>=0)cursor=path.join(cursor,parts[i]);
+    const info=await lstat(cursor);
+    if(info.isSymbolicLink()||((i<parts.length-1||directory)?!info.isDirectory():!info.isFile()))throw new Error('regular path');
+  }
+}
+
+export async function inspectDoctorInstallation(rawPointer, explicitRoot){
+  const state=resolveStateRoot(explicitRoot);
+  const pointer=parseActivePointer(JSON.stringify(rawPointer));
+  const findings=[];
+  const check=async(id,what,nextAction,operation)=>{
+    try{const evidence=await operation();findings.push({id,level:'PASS',what,evidence,next_action:null});}
+    catch(error){findings.push({id,level:'FAIL',what,evidence:{check:id,error_code:error?.code??'VALIDATION_FAILED'},next_action:nextAction});}
+  };
+  const next='Do not activate or arm authority; inspect the signed update receipt and use supported recovery for this state root.';
+  const expectedRelease=path.join(state,'releases',pointer.release_id);
+  const generation=path.resolve(pointer.generation_root);
+  const expectedGenerationParent=path.join(state,'generations');
+  await check('active_paths','Active release/generation/config paths match the state store.',next,async()=>{
+    if(!path.isAbsolute(pointer.release_root)||path.resolve(pointer.release_root)!==expectedRelease)throw new Error('release path');
+    if(!path.isAbsolute(pointer.generation_root)||path.dirname(generation)!==expectedGenerationParent)throw new Error('generation path');
+    if(!path.isAbsolute(pointer.config_path)||path.resolve(pointer.config_path)!==path.join(generation,'controller-config.psd1'))throw new Error('config path');
+    await regularPath(state,expectedRelease,true);await regularPath(state,generation,true);
+    return {release_id:pointer.release_id,generation_id:path.basename(generation)};
+  });
+  // Never follow unverified pointer paths, even just for diagnostics.
+  if(findings[0].level==='FAIL')return {status:'FAIL',findings};
+  await check('active_release','Installed release bytes match the pointer manifest and package identity.',next,async()=>{
+    const file=path.join(expectedRelease,'MANIFEST.SHA256');await regularPath(state,file);
+    const bytes=await readFile(file);if(sha256Bytes(bytes)!==pointer.manifest_sha256)throw new Error('manifest digest');
+    const manifest=parseManifest(bytes.toString('utf8'));if(!manifest.size||!manifest.has('package.json'))throw new Error('manifest package missing');
+    await verifyManifestTree(expectedRelease,manifest);
+    const pkg=JSON.parse(await readFile(path.join(expectedRelease,'package.json'),'utf8'));
+    if(pkg.name!=='deadbyte-mcp'||pkg.version!==pointer.version)throw new Error('package identity');
+    return {manifest_sha256:pointer.manifest_sha256,verified_files:manifest.size,version:pkg.version};
+  });
+  await check('active_generation','Generation bytes and config are bound to the active pointer.',next,async()=>{
+    await regularPath(state,path.join(generation,'GENERATION.SHA256'));await regularPath(state,pointer.config_path);
+    const bytes=await readFile(path.join(generation,'GENERATION.SHA256'));
+    const entries=parseManifest(bytes.toString('utf8'));
+    if(!entries.has('controller-config.psd1'))throw new Error('unbound config');
+    for(const relative of entries.keys())await regularPath(state,path.resolve(generation,...relative.split('/')));
+    return await verifyGenerationBundle(generation,pointer.generation_manifest_sha256);
+  });
+  await check('active_launcher','Stable launcher bytes match the active pointer.',next,async()=>{
+    const file=path.join(state,'bin','DEADBYTE-MCP.ps1');await regularPath(state,file);
+    const actual=sha256Bytes(await readFile(file));if(actual!==pointer.launcher_sha256)throw new Error('launcher digest');
+    return {sha256:actual};
+  });
+  return {status:findings.some(item=>item.level==='FAIL')?'FAIL':'PASS',findings};
+}

package/src/doctor-r45.mjs

@@ -5,12 +5,22 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { DEADBYTE_VERSION, MCP_PROTOCOL_VERSION } from './version.mjs';
 import { resolveStateRoot } from './state-root.mjs';
+import { parseActivePointer } from './release-slot.mjs';
+import { inspectDoctorRuntime } from './doctor-runtime-r58.mjs';
+import { inspectDoctorForeground } from './doctor-foreground-r58.mjs';
+import { inspectDoctorTransactions } from './doctor-transactions-r58.mjs';
 
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
-const stateRoot=()=>resolveStateRoot();
 const sha256=b=>createHash('sha256').update(b).digest('hex');
 async function jsonOrNull(file){try{return JSON.parse((await readFile(file,'utf8')).replace(/^\uFEFF/,''));}catch(e){if(e?.code==='ENOENT')return null;throw e;}}
 async function fileHash(file){return sha256(await readFile(file));}
+export async function readDoctorActivePointer(explicitRoot){
+ const pointerPath=path.join(resolveStateRoot(explicitRoot),'active-release.json');
+ let text;
+ try {text=await readFile(pointerPath,'utf8');}
+ catch(error){if(error?.code==='ENOENT')return null;throw error;}
+ return parseActivePointer(text.replace(/^\uFEFF/,''));
+}
 function parseManifest(text){
  const rows=[];
  for(const [index,line] of text.split(/\r?\n/).entries()){
@@ -48,11 +58,18 @@ export async function doctor(){
  const hardwareStat=await lstat(hardware);
  if(!hardwareStat.isFile()||hardwareStat.isSymbolicLink()) throw new Error('hardware observer must be a regular file');
  const hardwareSha256=await fileHash(hardware);
- const active=await jsonOrNull(path.join(stateRoot(),'active-release.json'));
+ const active=await readDoctorActivePointer();
+ const installation=active?await inspectDoctorRuntime(active):{status:'PASS',findings:[{id:'active_pointer',level:'PASS',what:'No active installation in this state root.',evidence:{pointer_present:false},next_action:null}]};
+ const foreground=await inspectDoctorForeground();
+ const transactions=await inspectDoctorTransactions();
+ const findings=[...installation.findings,...foreground.findings,...transactions.findings];
+ const assessment=findings.some(item=>item.level==='FAIL')?'FAIL':findings.some(item=>item.level==='WARN')?'WARN':'PASS';
  const hostPolicy=await jsonOrNull(path.join(root,'controller','deadbyte-host-policy.json'));
  if(hostPolicy&&release?.train==='R45'&&process.platform==='win32'&&hostPolicy.schema!=='deadbyte.host-policy.v2') throw new Error('R45 doctor rejects non-v2 generated host policy');
  return {
-  schema:'deadbyte.doctor.v1',status:'ok',package_version:DEADBYTE_VERSION,protocol_revision:MCP_PROTOCOL_VERSION,
+  schema:'deadbyte.doctor.v1',status:assessment==='FAIL'?'fail':assessment==='WARN'?'warn':'ok',package_version:DEADBYTE_VERSION,protocol_revision:MCP_PROTOCOL_VERSION,
+  assessment,findings,
+  runtime_availability:installation.availability??null,
   platform:{current:process.platform,architecture:process.arch,primary:'win32',supported:process.platform==='win32'},
   manifest:{sha256:manifestSha256,entries:rows.length,verified_entries:verified,verified:true},
   release_metadata:metadata,
@@ -63,4 +80,4 @@ export async function doctor(){
   known_unsupported:process.platform==='win32'?[]:['native_hardware_observation','windows_controller','desktop_native']
  };
 }
-export async function printDoctor(){const value=await doctor();process.stdout.write(JSON.stringify(value,null,2)+'\n');return value;}
+export async function printDoctor(){const value=await doctor();process.stdout.write(JSON.stringify(value,null,2)+'\n');if(value.assessment==='FAIL')process.exitCode=1;return value;}

package/src/doctor-runtime-r58.mjs

@@ -0,0 +1,82 @@
+import {readFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {resolveStateRoot} from './state-root.mjs';
+import {inspectDoctorInstallation} from './doctor-installation-r58.mjs';
+import {parseActivePointer,parseManifest,sha256Bytes} from './release-slot.mjs';
+import {windowsPowerShellEnvironment} from './runtime-update.mjs';
+
+function object(value,keys){
+ if(!value||typeof value!=='object'||Array.isArray(value)||Object.keys(value).length!==keys.length||keys.some(k=>!Object.hasOwn(value,k)))throw new Error('controller observation fields invalid');
+}
+const reason=value=>typeof value==='string'&&/^[a-z][a-z0-9-]{0,63}$/.test(value);
+const date=value=>typeof value==='string'&&/^\d{4}-\d\d-\d\dT.*Z$/.test(value)&&Number.isFinite(Date.parse(value));
+const pid=value=>Number.isSafeInteger(value)&&value>0;
+export function validateDoctorControllerObservation(value,expectedCoreRoot){
+ object(value,['schema','observed_at_utc','state','core_root','local_ready','bridge','core','cloud','supervisor','authority']);
+ if(value.schema!=='deadbyte.controller-observation.v1'||!date(value.observed_at_utc)||!['OFFLINE','PARKED','ONLINE','STARTING','FAILED','DEGRADED'].includes(value.state)||typeof value.local_ready!=='boolean'||typeof value.core_root!=='string'||!path.isAbsolute(value.core_root)||path.resolve(value.core_root)!==path.resolve(expectedCoreRoot))throw new Error('controller observation identity invalid');
+ for(const key of ['bridge','cloud']){
+  const item=value[key];object(item,['alive','reason','pid','creation_time_utc']);
+  if(typeof item.alive!=='boolean'||!reason(item.reason)||(item.alive?(!pid(item.pid)||!date(item.creation_time_utc)||item.reason!=='verified'):(item.pid!==null||item.creation_time_utc!==null)))throw new Error('controller component observation invalid');
+ }
+ const core=value.core;object(core,['alive','reason','pid','parent_pid','creation_time_utc','identity_basis']);
+ if(typeof core.alive!=='boolean'||!reason(core.reason))throw new Error('core observation invalid');
+ if(core.alive){
+  if(!value.bridge.alive||!pid(core.pid)||core.parent_pid!==value.bridge.pid||!date(core.creation_time_utc)||core.reason!=='verified'||!['command-line','verified-bridge-single-opaque-node-child'].includes(core.identity_basis))throw new Error('core topology binding invalid');
+ }else if(core.pid!==null||core.parent_pid!==null||core.creation_time_utc!==null||core.identity_basis!==null)throw new Error('failed core observation carries live identity');
+ object(value.supervisor,['configured','running','reason']);
+ if(typeof value.supervisor.configured!=='boolean'||typeof value.supervisor.running!=='boolean'||!reason(value.supervisor.reason)||(!value.supervisor.configured&&value.supervisor.running))throw new Error('supervisor observation invalid');
+ object(value.authority,['process','coding','autonomous','desktop','host']);
+ for(const item of Object.values(value.authority)){
+  object(item,['configured','armed','reason']);
+  if(typeof item.configured!=='boolean'||typeof item.armed!=='boolean'||!reason(item.reason)||(!item.configured&&item.armed)||(item.armed&&item.reason!=='standing-grant'))throw new Error('authority observation invalid');
+ }
+ return value;
+}
+
+export function classifyDoctorControllerObservation(raw,expectedCoreRoot){
+ const value=validateDoctorControllerObservation(raw,expectedCoreRoot),findings=[];
+ const add=(id,level,what,evidence,next_action=null)=>findings.push({id,level,what,evidence,next_action});
+ const inspect='Retain evidence and inspect exact controller/config/runtime bindings; use supported lifecycle recovery only after reconciling ownership.';
+ for(const name of ['bridge','cloud']){
+  const component=value[name];
+  const level=component.alive||component.reason==='no-ledger'?'PASS':component.reason==='process-missing'?'WARN':'FAIL';
+  add('runtime_'+name,level,`${name} ownership observation: ${component.reason}.`,{alive:component.alive,pid:component.pid,reason:component.reason},level==='PASS'?null:inspect);
+ }
+ const core=value.core;
+ const coreLevel=core.alive||(!value.bridge.alive&&core.reason==='bridge-unavailable')?'PASS':core.reason==='startup-zero-child'?'WARN':'FAIL';
+ add('runtime_core',coreLevel,`Downstream core observation: ${core.reason}.`,{alive:core.alive,pid:core.pid,parent_pid:core.parent_pid,identity_basis:core.identity_basis},coreLevel==='PASS'?null:inspect);
+ const localHealthy=value.bridge.alive&&core.alive&&value.local_ready;
+ const state=localHealthy&&value.cloud.alive?'ONLINE':!value.bridge.alive&&!value.cloud.alive?'OFFLINE':!value.bridge.alive&&value.cloud.alive?'PARKED':core.reason==='startup-zero-child'?'STARTING':'FAILED';
+ const contradiction=value.state==='ONLINE'&&state!=='ONLINE';
+ const availabilityLevel=contradiction?(state==='STARTING'?'WARN':'FAIL'):state==='ONLINE'||state==='OFFLINE'?'PASS':'WARN';
+ add('runtime_availability',availabilityLevel,`Observed availability is ${state}; local and remote availability are separate.`,{state,controller_state:value.state,local_healthy:localHealthy,remote_connected:value.cloud.alive,local_ready:value.local_ready},availabilityLevel==='PASS'?null:inspect);
+ if(value.supervisor.configured&&!value.supervisor.running)add('runtime_supervisor','WARN','Configured supervisor is not verified running.',{reason:value.supervisor.reason},inspect);
+ else add('runtime_supervisor','PASS','Supervisor observation is consistent.',{configured:value.supervisor.configured,running:value.supervisor.running});
+ for(const [plane,authority]of Object.entries(value.authority)){
+  const valid=authority.armed||['no-policy','disabled','disarmed','coding-disarmed'].includes(authority.reason);
+  const level=!valid?'FAIL':authority.armed&&(['host','desktop'].includes(plane)||state==='OFFLINE')?'WARN':'PASS';
+  add('authority_'+plane,level,`${plane} authority observation: ${authority.armed?'ARMED':'DISARMED'} (${authority.reason}).`,{configured:authority.configured,armed:authority.armed,reason:authority.reason},level==='PASS'?null:'Inspect the pinned policy/grant and revoke through the supported launcher if unintended; doctor never changes authority.');
+ }
+ if(value.authority.autonomous.armed&&!value.authority.coding.armed)add('authority_dependency','FAIL','Autonomous is armed while coding is not.',{autonomous_armed:true,coding_armed:false},inspect);
+ return {status:findings.some(f=>f.level==='FAIL')?'FAIL':findings.some(f=>f.level==='WARN')?'WARN':'PASS',findings,availability:{state,local_healthy:localHealthy,remote_connected:value.cloud.alive}};
+}
+
+export async function inspectDoctorRuntime(rawPointer,explicitRoot){
+ const pointer=parseActivePointer(JSON.stringify(rawPointer)),state=resolveStateRoot(explicitRoot);
+ const installation=await inspectDoctorInstallation(pointer,state);
+ if(installation.status==='FAIL')return installation;
+ const controller=path.join(pointer.release_root,'controller','deadbyte-controller.ps1');
+ const sourceBytes=await readFile(controller),manifestBytes=await readFile(path.join(pointer.release_root,'MANIFEST.SHA256'));
+ if(sha256Bytes(manifestBytes)!==pointer.manifest_sha256||parseManifest(manifestBytes.toString('utf8')).get('controller/deadbyte-controller.ps1')!==sha256Bytes(sourceBytes))throw new Error('doctor controller is not manifest-bound');
+ const source=sourceBytes.toString('utf8');
+ if(!source.includes('[switch]$Json'))return {status:'WARN',findings:[...installation.findings,{id:'runtime_observation',level:'WARN',what:'Installed predecessor does not support read-only structured observation.',evidence:{release_id:pointer.release_id,structured_observation_supported:false},next_action:'Use the accepted predecessor evidence and supported status command; do not bypass controller root binding or rewrite the sealed parent.'}]};
+ const nativeRoot=process.env.SystemRoot||process.env.WINDIR;
+ const result=spawnSync(path.join(nativeRoot,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoLogo','-NoProfile','-File',controller,'status','-Json'],{cwd:pointer.release_root,encoding:'utf8',windowsHide:true,timeout:20000,maxBuffer:262144,env:windowsPowerShellEnvironment({...process.env,DEADBYTE_STATE_ROOT:state,DEADBYTE_CONTROLLER_CONFIG:pointer.config_path,DEADBYTE_CONTROLLER_RUNTIME_ROOT:path.join(state,'runtime')})});
+ let runtime;
+ try{
+  if(result.error||result.status!==0)throw new Error('controller observation failed');
+  runtime=classifyDoctorControllerObservation(JSON.parse(result.stdout),pointer.release_root);
+ }catch{runtime={status:'FAIL',findings:[{id:'runtime_observation',level:'FAIL',what:'Read-only controller observation failed or its structured contract/binding is invalid.',evidence:{exit_code:result.status??null,error_code:result.error?.code??'OBSERVATION_FAILED'},next_action:'Inspect the exact release/generation and supported controller status; do not auto-repair or retry effects.'}]};}
+ return {...runtime,findings:[...installation.findings,...runtime.findings]};
+}

package/src/doctor-transactions-r58.mjs

@@ -0,0 +1,40 @@
+import {lstat,opendir,readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {resolveStateRoot} from './state-root.mjs';
+
+export async function inspectDoctorTransactions(explicitRoot,{maxEntries=256}={}){
+ if(!Number.isSafeInteger(maxEntries)||maxEntries<1||maxEntries>256)throw new Error('doctor transaction budget invalid');
+ const state=resolveStateRoot(explicitRoot),root=path.join(state,'evidence','updates'),findings=[];
+ const next='Retain transaction evidence; inspect the exact signed receipt/handoff and current pointer before any supported recovery. Doctor never launches recovery.';
+ const add=(level,what,evidence)=>findings.push({id:'transaction_residue',level,what,evidence,next_action:level==='PASS'?null:next});
+ let directory;
+ try{
+  for(const dir of [state,path.join(state,'evidence'),root]){const st=await lstat(dir);if(!st.isDirectory()||st.isSymbolicLink())throw new Error('unsafe evidence parent');}
+  directory=await opendir(root);
+ }catch(error){
+  if(error?.code==='ENOENT')add('PASS','No update evidence directory in this state root.',{present:false,states_checked:0});
+  else add('FAIL','Update evidence directory cannot be safely inspected.',{error_code:error?.code??'VALIDATION_FAILED'});
+  return {status:findings[0].level,findings};
+ }
+ let entries=0,checked=0,terminal=0;
+ try{
+  for await(const entry of directory){
+   if(++entries>maxEntries){add('WARN','Transaction inventory budget reached; unobserved entries remain.',{max_entries:maxEntries,states_checked:checked,inventory_complete:false});break;}
+   if(entry.isSymbolicLink()){add('FAIL','Transaction evidence contains a link; it was not followed.',{entry_name_sha256:createHash('sha256').update(entry.name).digest('hex')});continue;}
+   if(!entry.isDirectory())continue;
+   const file=path.join(root,entry.name,'state.json');let bytes;
+   try{
+    const info=await lstat(file);if(!info.isFile()||info.isSymbolicLink()||info.size>1048576)throw new Error('unsafe transaction state');
+    bytes=await readFile(file);if(bytes.length>1048576)throw new Error('transaction state budget');
+    const body=JSON.parse(bytes.toString('utf8').replace(/^\uFEFF/,''));checked++;
+    const digest=createHash('sha256').update(bytes).digest('hex');
+    if(!['deadbyte.r27-slot-update-state.v1','deadbyte.r31-slot-rollback-state.v1'].includes(body?.schema)||typeof body.phase!=='string'||!/^[a-z_]{1,64}$/.test(body.phase)){add('FAIL','Transaction state schema or phase is invalid.',{state_sha256:digest,check:'transaction_schema'});continue;}
+    if(['completed','superseded','failed_receipted'].includes(body.phase)){terminal++;continue;}
+    add('WARN','Nonterminal or unresolved transaction record remains; liveness/outcome is not inferred from its age or PID.',{state_sha256:digest,schema:body.schema,recorded_phase:body.phase});
+   }catch(error){if(error?.code==='ENOENT')continue;add('FAIL','Transaction state cannot be safely parsed or inspected.',{error_code:error?.code??'VALIDATION_FAILED'});}
+  }
+ }catch(error){add('FAIL','Transaction inventory observation failed.',{error_code:error?.code??'OBSERVATION_FAILED'});}
+ add('PASS','Recorded terminal transaction phases counted; signatures and desired outcomes are not established by this inventory.',{states_checked:checked,recorded_terminal_states:terminal,receipt_verification_performed:false});
+ return {status:findings.some(f=>f.level==='FAIL')?'FAIL':findings.some(f=>f.level==='WARN')?'WARN':'PASS',findings};
+}

package/src/foreground-process-identity.mjs

@@ -0,0 +1,27 @@
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {windowsPowerShellEnvironment} from './runtime-update.mjs';
+
+export function validForegroundIdentity(value){
+ return value?.schema==='deadbyte.foreground-process.v1'&&Number.isSafeInteger(value.pid)&&value.pid>0&&Number.isSafeInteger(value.parent_pid)&&value.parent_pid>=0&&typeof value.creation_utc==='string'&&/^\d{4}-\d\d-\d\dT.*Z$/.test(value.creation_utc)&&Number.isFinite(Date.parse(value.creation_utc))&&typeof value.executable_path==='string'&&path.isAbsolute(value.executable_path)&&/^[0-9a-f]{64}$/.test(value.command_line_sha256??'');
+}
+export function foregroundIdentityMatches(expected,observed){
+ if(!validForegroundIdentity(expected))throw new Error('foreground ownership identity unverified');
+ if(observed===null)return false;
+ if(!validForegroundIdentity(observed))throw new Error('observed foreground identity incomplete');
+ return expected.pid===observed.pid&&expected.parent_pid===observed.parent_pid&&expected.creation_utc===observed.creation_utc&&path.resolve(expected.executable_path).toLowerCase()===path.resolve(observed.executable_path).toLowerCase()&&expected.command_line_sha256===observed.command_line_sha256;
+}
+export function queryForegroundIdentity(pid){
+ if(process.platform!=='win32'||!Number.isSafeInteger(pid)||pid<1)throw new Error('foreground identity requires a positive Windows PID');
+ const root=process.env.SystemRoot||process.env.WINDIR;if(!root)throw new Error('Windows system root missing');
+ const command=`$p=Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; if ($null -eq $p) {Write-Output 'null';exit 0}; [pscustomobject]@{pid=$p.ProcessId;parent_pid=$p.ParentProcessId;creation_utc=$p.CreationDate.ToUniversalTime().ToString('o');executable_path=$p.ExecutablePath;command_line=$p.CommandLine} | ConvertTo-Json -Compress`;
+ const result=spawnSync(path.join(root,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoLogo','-NoProfile','-Command',command],{encoding:'utf8',windowsHide:true,env:windowsPowerShellEnvironment(process.env),timeout:15000,maxBuffer:1024*1024});
+ if(result.error||result.status!==0)throw new Error('foreground process identity query failed');
+ let raw;try{raw=JSON.parse(result.stdout);}catch{throw new Error('foreground process identity query malformed');}
+ if(raw===null)return null;
+ if(typeof raw.command_line!=='string'||!raw.command_line)throw new Error('foreground process command identity unavailable');
+ const identity={schema:'deadbyte.foreground-process.v1',pid:raw.pid,parent_pid:raw.parent_pid,creation_utc:raw.creation_utc,executable_path:raw.executable_path,command_line_sha256:createHash('sha256').update(raw.command_line).digest('hex')};
+ if(!validForegroundIdentity(identity)||identity.pid!==pid)throw new Error('foreground process identity incomplete');
+ return identity;
+}

package/src/foreground-session-lock.mjs

@@ -0,0 +1,20 @@
+import {spawn} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+import {windowsPowerShellEnvironment} from './runtime-update.mjs';
+
+export async function acquireForegroundSessionLock({root,powershell}){
+ const hash=createHash('sha256').update(path.resolve(root).toLowerCase()).digest('hex');
+ const child=spawn(powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',fileURLToPath(new URL('./foreground-session-lock.ps1',import.meta.url)),'-LockName',`Local\\DEADBYTE-foreground-${hash}`],{windowsHide:true,stdio:['pipe','pipe','pipe'],env:windowsPowerShellEnvironment(process.env)});
+ let text='',errorText='';child.stderr.on('data',b=>{errorText=(errorText+b).slice(-2048);});
+ let settled=false;
+ const exited=new Promise(resolve=>{child.once('exit',(code,signal)=>resolve({code,signal}));child.once('error',error=>resolve({error}));});
+ const ready=new Promise((resolve,reject)=>{
+  const timer=setTimeout(()=>{if(!settled){settled=true;child.kill();reject(new Error('foreground session lock acquisition timed out'));}},15000);
+  child.stdout.on('data',b=>{text+=b.toString();if(!settled&&text.includes('DEADBYTE_FOREGROUND_LOCK_READY')){settled=true;clearTimeout(timer);resolve();}});
+  exited.then(result=>{if(!settled){settled=true;clearTimeout(timer);reject(new Error(result.code===73?'remote session already claimed (startup/recovery lock)':`foreground session lock failed: ${errorText||result.error?.message||result.code}`));}});
+ });
+ try{await ready;}catch(error){child.stdin.end();await exited;throw error;}
+ return {assertHeld(){if(child.exitCode!==null||child.signalCode!==null)throw new Error('foreground session lock ownership lost');},async release(){child.stdin.end();const result=await exited;if(result.code!==0)throw new Error('foreground session lock release failed');}};
+}

package/src/foreground-session-lock.ps1

@@ -0,0 +1,15 @@
+param([Parameter(Mandatory=$true)][ValidatePattern('^Local\\DEADBYTE-foreground-[0-9a-f]{64}$')][string]$LockName)
+$ErrorActionPreference='Stop'
+$mutex=New-Object System.Threading.Mutex($false,$LockName)
+$owned=$false
+try {
+    try { $owned=$mutex.WaitOne(0) } catch [System.Threading.AbandonedMutexException] { $owned=$true }
+    if(-not $owned){exit 73}
+    [Console]::Out.WriteLine('DEADBYTE_FOREGROUND_LOCK_READY')
+    [Console]::Out.Flush()
+    # Owner death closes the inherited stdin pipe. No persisted PID lockfile.
+    [void][Console]::In.ReadLine()
+} finally {
+    if($owned){$mutex.ReleaseMutex()}
+    $mutex.Dispose()
+}

package/src/release-generation.mjs

@@ -200,6 +200,7 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     `        WorkingDirectory = ${psQuote(bridge.WorkingDirectory)}`,
     `        ScriptPath = ${psQuote(bridge.ScriptPath)}`,
     `        ScriptSha256 = ${psQuote(bridge.ScriptSha256)}`,
+    ...renderPsDependencies(bridge.Dependencies),
     '    }','    Cloud = @{',
     `        FilePath = ${psQuote(cloud.FilePath)}`,
     `        FileSha256 = ${psQuote(cloud.FileSha256)}`,

package/src/release-slot.mjs

@@ -289,7 +289,8 @@ export function renderStableLauncherPs1(){
     '$env:DEADBYTE_STATE_ROOT = $StateRoot',
     '$env:DEADBYTE_CONTROLLER_CONFIG = $configPath',
     "$env:DEADBYTE_CONTROLLER_RUNTIME_ROOT = Join-Path $StateRoot 'runtime'",
-    "$powershell = Join-Path $PSHOME 'powershell.exe'",
+    "$powershell = Join-Path ([Environment]::GetFolderPath('Windows')) 'System32\\WindowsPowerShell\\v1.0\\powershell.exe'",
+    "if (-not (Test-Path -LiteralPath $powershell -PathType Leaf)) { Fail 'native Windows PowerShell missing' }",
     '& $powershell -NoLogo -NoProfile -ExecutionPolicy Bypass -File $controller @ControllerArgs',
     '$exitCode = (Get-Variable -Name LASTEXITCODE -ValueOnly -ErrorAction SilentlyContinue)',
     'if ($null -eq $exitCode) { $exitCode = 0 }',

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;
 }
 
@@ -743,6 +807,37 @@ export function selectCoreProcess(processes,coreRoot,bridgePid,verifiedBridge=nu
 function coreProcess(coreRoot,bridge){
   return selectCoreProcess(nodeProcesses(),coreRoot,bridge.pid,bridge);
 }
+export async function waitForCoreProcess(coreRoot,bridge,{
+  timeoutMs=10000,
+  pollMs=100,
+  processProvider=nodeProcesses,
+  sleepFn=sleep,
+  nowFn=Date.now
+}={}){
+  const bridgePid=Number(bridge?.pid);
+  if(!Number.isInteger(bridgePid)||bridgePid<1) throw new Error('downstream core wait requires verified bridge PID');
+  if(!Number.isFinite(timeoutMs)||timeoutMs<0) throw new Error('downstream core wait timeout invalid');
+  if(!Number.isFinite(pollMs)||pollMs<1) throw new Error('downstream core wait poll invalid');
+  if(typeof processProvider!=='function'||typeof sleepFn!=='function'||typeof nowFn!=='function') throw new Error('downstream core wait hooks invalid');
+  const started=Number(nowFn());
+  let lastError=null;
+  while(true){
+    try {
+      const processes=await processProvider();
+      return selectCoreProcess(processes,coreRoot,bridgePid,bridge);
+    } catch(error){
+      const message=String(error?.message??error);
+      const transient=`expected one unambiguous downstream core for bridge ${bridgePid}, found children=0 visible_matches=0`;
+      if(message!==transient) throw error;
+      lastError=error;
+    }
+    const elapsed=Math.max(0,Number(nowFn())-started);
+    if(elapsed>=timeoutMs){
+      throw new Error(`downstream core did not appear for bridge ${bridgePid} within ${timeoutMs}ms: ${String(lastError?.message??lastError)}`);
+    }
+    await sleepFn(Math.min(pollMs,Math.max(1,timeoutMs-elapsed)));
+  }
+}
 async function captureRuntime(ctx){
   const statusText=controllerCaptured(ctx,'status',15000); const status=parseControllerStatus(statusText);
   if(!status.online||!status.bridge_pid||!status.cloud_pid||!status.local_ready) throw new Error(`slot update requires ONLINE runtime: ${statusText}`);
@@ -826,7 +921,7 @@ async function startAndVerify(ctx,oldRuntime){
     catch {} await sleep(500);
   }
   if(!status?.online||!status.bridge_pid||!status.cloud_pid||!status.local_ready) throw new Error(`new runtime failed ONLINE gate: ${statusText}`);
-  const bridge=await readLedger(ctx,'bridge'); const cloud=await readLedger(ctx,'cloud'); const core=coreProcess(ctx.core_root,bridge);
+  const bridge=await readLedger(ctx,'bridge'); const cloud=await readLedger(ctx,'cloud'); const core=await waitForCoreProcess(ctx.core_root,bridge);
   if(oldRuntime?.bridge&&sameGeneration(oldRuntime.bridge,bridge)) throw new Error('fresh bridge generation gate failed');
   if(oldRuntime?.cloud&&sameGeneration(oldRuntime.cloud,cloud)) throw new Error('fresh cloud generation gate failed');
   if(oldRuntime?.core&&oldRuntime.core.pid===core.pid&&oldRuntime.core.creation_date===core.creation_date) throw new Error('fresh downstream core generation gate failed');
@@ -1303,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))))));
@@ -1311,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);
@@ -1704,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.33';
+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};
+}