deadbyte-mcp 0.15.47 → 0.15.49

package/src/autonomous-local-supervisor.mjs

@@ -1,11 +1,15 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { startAutonomousSupervisor } from './autonomous-supervisor.mjs';
+import { windowsPowerShellEnvironment } from './windows-powershell-environment.mjs';
+import { readPinnedEpochLockSnapshot, createPinnedEpochLock, deletePinnedRemoteMarker } from './foreground-marker-cas-win32.mjs';
+import { runNativeInspect } from './native-inspector-r67.mjs';
 
 const execFileAsync=promisify(execFile);
+const TRUSTED_WINDOWS_ROOT='C:\\Windows';
 export const AUTONOMOUS_SUPERVISOR_OWNER_SCHEMA='deadbyte.autonomous-supervisor-owner.v1';
 const HEX64=/^[0-9a-f]{64}$/;
 const RECOVERY_OPERATIONS=Object.freeze(['status','resume','park','disarmautonomous','disarmcoding','disarmprocess','disarmhost']);
@@ -33,12 +37,12 @@ function validateMarker(marker){
 }
 async function powershellPath(){
   if(process.platform!=='win32') return null;
-  const systemRoot=process.env.SystemRoot || process.env.WINDIR;
-  if(systemRoot){
-    const candidate=path.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe');
-    try { await access(candidate); return candidate; } catch {}
-  }
-  return 'powershell.exe';
+  const candidate=path.join(TRUSTED_WINDOWS_ROOT,'System32','WindowsPowerShell','v1.0','powershell.exe');
+  try { await access(candidate); return candidate; } catch { return null; }
+}
+
+function trustedPowerShellEnvironment(){
+  return windowsPowerShellEnvironment({...process.env,SystemRoot:TRUSTED_WINDOWS_ROOT,WINDIR:TRUSTED_WINDOWS_ROOT});
 }
 
 export async function observeCurrentProcessIdentity(pid=process.pid){
@@ -49,7 +53,7 @@ export async function observeCurrentProcessIdentity(pid=process.pid){
   let stdout;
   try {
     ({stdout}=await execFileAsync(shell,['-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-Command',script],{
-      windowsHide:true,timeout:10_000,maxBuffer:1024*1024,encoding:'utf8'
+      windowsHide:true,timeout:10_000,maxBuffer:1024*1024,encoding:'utf8',env:trustedPowerShellEnvironment()
     }));
   } catch { return null; }
   let parsed;
@@ -64,14 +68,36 @@ export async function observeCurrentProcessIdentity(pid=process.pid){
   });
 }
 
+async function confirmProcessAbsent(pid){
+  const shell=await powershellPath();
+  if(!shell) return false;
+  const script=`$ErrorActionPreference='Stop'; $p=Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' -ErrorAction Stop; if($null -eq $p){[Console]::Out.WriteLine('ABSENT')}else{[Console]::Out.WriteLine('PRESENT')}`;
+  try {
+    const {stdout}=await execFileAsync(shell,['-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-Command',script],{
+      windowsHide:true,timeout:10_000,maxBuffer:1024*1024,encoding:'utf8',env:trustedPowerShellEnvironment()
+    });
+    if(String(stdout).trim()!=='ABSENT') return false;
+    const native=await runNativeInspect(['identity',String(pid)]);
+    return native.status==='failed'&&native.error_code==='INVALID_PARAMETER'&&
+      native.win32_error===87&&native.error==='OpenProcess identity win32=87';
+  } catch { return false; }
+}
+
 async function readMarker(markerPath){
-  let raw;
-  try { raw=await readFile(markerPath); }
-  catch(error){ if(error?.code==='ENOENT') return {exists:false}; throw error; }
+  let raw, fileId=null;
+  if(process.platform==='win32'){
+    const snapshot=readPinnedEpochLockSnapshot(markerPath);
+    if(!snapshot) return {exists:false};
+    raw=snapshot.bytes;
+    fileId=snapshot.fileId;
+  } else {
+    try { raw=await readFile(markerPath); }
+    catch(error){ if(error?.code==='ENOENT') return {exists:false}; throw error; }
+  }
   let marker;
   try { marker=JSON.parse(raw.toString('utf8')); }
-  catch { return {exists:true,raw,raw_sha256:sha256Bytes(raw),valid:false,marker:null}; }
-  return {exists:true,raw,raw_sha256:sha256Bytes(raw),valid:validateMarker(marker),marker};
+  catch { return {exists:true,raw,raw_sha256:sha256Bytes(raw),file_id:fileId,valid:false,marker:null}; }
+  return {exists:true,raw,raw_sha256:sha256Bytes(raw),file_id:fileId,valid:validateMarker(marker),marker};
 }
 function markerFor(identity){
   return {
@@ -91,28 +117,28 @@ export async function observeSupervisor(options={}){
   const markerPath=assertOptions(options);
   const stored=await readMarker(markerPath);
   if(!stored.exists) return {status:'absent',live:false,reason:'no_owner',marker:null,marker_sha256:null};
-  if(!stored.valid) return {status:'unverified',live:false,reason:'marker_invalid',marker:stored.marker,marker_sha256:stored.raw_sha256};
+  const binding={marker_sha256:stored.raw_sha256,marker_file_id:stored.file_id};
+  if(!stored.valid) return {status:'unverified',live:false,reason:'marker_invalid',marker:stored.marker,...binding};
   const observed=await observeCurrentProcessIdentity(stored.marker.pid);
-  if(!observed) return {status:'stale',live:false,reason:'process_unobservable',marker:stored.marker,marker_sha256:stored.raw_sha256};
+  if(!observed){
+    if(await confirmProcessAbsent(stored.marker.pid))
+      return {status:'stale',live:false,reason:'process_absent',marker:stored.marker,...binding};
+    return {status:'unverified',live:false,reason:'process_unobservable',marker:stored.marker,...binding};
+  }
   if(observed.creation_time_utc!==new Date(stored.marker.creation_time_utc).toISOString()) {
-    return {status:'stale',live:false,reason:'pid_reused',marker:stored.marker,observation:observed,marker_sha256:stored.raw_sha256};
+    return {status:'stale',live:false,reason:'pid_reused',marker:stored.marker,observation:observed,...binding};
   }
   if(!samePath(observed.image_path,stored.marker.image_path)||observed.image_sha256!==stored.marker.image_sha256) {
-    return {status:'stale',live:false,reason:'identity_mismatch',marker:stored.marker,observation:observed,marker_sha256:stored.raw_sha256};
+    return {status:'unverified',live:false,reason:'identity_mismatch',marker:stored.marker,observation:observed,...binding};
   }
-  return {status:'owned',live:true,reason:'live_verified_owner',marker:stored.marker,observation:observed,marker_sha256:stored.raw_sha256};
+  return {status:'owned',live:true,reason:'live_verified_owner',marker:stored.marker,observation:observed,...binding};
 }
 
 export async function claimSupervisor(options={}){
   const markerPath=assertOptions(options);
   const marker=await currentMarker();
-  await mkdir(path.dirname(markerPath),{recursive:true});
-  try {
-    await writeFile(markerPath,`${JSON.stringify(marker)}\n`,{flag:'wx',mode:0o600});
-  } catch(error){
-    if(error?.code==='EEXIST') throw new Error('supervisor owner marker already exists; takeover required');
-    throw error;
-  }
+  const created=createPinnedEpochLock(markerPath,Buffer.from(`${JSON.stringify(marker)}\n`));
+  if(!created) throw new Error('supervisor owner marker already exists; takeover required');
   return {status:'claimed',instance_nonce:marker.instance_nonce,marker};
 }
 
@@ -121,17 +147,13 @@ export async function takeoverSupervisor(options={}){
   const prior=await observeSupervisor({markerPath});
   if(prior.live&&prior.reason==='live_verified_owner') throw new Error('supervisor takeover refused: live verified owner');
   if(prior.reason==='no_owner') return claimSupervisor({markerPath});
-  const marker=await currentMarker();
-  const before=await readMarker(markerPath);
-  if(!before.exists||before.raw_sha256!==prior.marker_sha256) throw new Error('supervisor ownership changed during takeover');
-  const temp=path.join(path.dirname(markerPath),`.${path.basename(markerPath)}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`);
-  try {
-    await writeFile(temp,`${JSON.stringify(marker)}\n`,{flag:'wx',mode:0o600});
-    const check=await readMarker(markerPath);
-    if(!check.exists||check.raw_sha256!==prior.marker_sha256) throw new Error('supervisor ownership changed during takeover');
-    await rename(temp,markerPath);
-  } finally { await rm(temp,{force:true}).catch(()=>{}); }
-  return {status:'claimed',instance_nonce:marker.instance_nonce,marker,taken_over_reason:prior.reason};
+  if(!['process_absent','pid_reused'].includes(prior.reason))
+    throw new Error(`supervisor takeover refused: ownership unverified (${prior.reason})`);
+  if(!prior.marker_file_id) throw new Error('supervisor ownership file identity unavailable for takeover');
+  const removed=deletePinnedRemoteMarker(markerPath,prior.marker_sha256,{expectedFileId:prior.marker_file_id});
+  if(removed!=='REMOVED') throw new Error(`supervisor ownership changed during takeover: ${removed}`);
+  const claimed=await claimSupervisor({markerPath});
+  return {...claimed,taken_over_reason:prior.reason};
 }
 
 export async function releaseSupervisor(options={}){
@@ -147,9 +169,9 @@ export async function releaseSupervisor(options={}){
     !samePath(current.image_path,observed.observation.image_path)||current.image_sha256!==observed.observation.image_sha256) {
     throw new Error('supervisor ownership current process identity mismatch');
   }
-  const check=await readMarker(markerPath);
-  if(!check.exists||check.raw_sha256!==observed.marker_sha256) throw new Error('supervisor ownership changed before release');
-  await rm(markerPath,{force:false});
+  if(!observed.marker_file_id) throw new Error('supervisor ownership file identity unavailable for release');
+  const removed=deletePinnedRemoteMarker(markerPath,observed.marker_sha256,{expectedFileId:observed.marker_file_id});
+  if(removed!=='REMOVED') throw new Error(`supervisor ownership changed before release: ${removed}`);
   return {status:'released'};
 }
 
@@ -180,7 +202,7 @@ export async function runPinnedControllerOperation(options={}){
   if(!shell) throw new Error('supervisor controller requires Windows PowerShell');
   try {
     const {stdout,stderr}=await execFileAsync(shell,['-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-File',controllerPath,operation],{
-      windowsHide:true,timeout:120_000,maxBuffer:4*1024*1024,encoding:'utf8'
+      windowsHide:true,timeout:120_000,maxBuffer:4*1024*1024,encoding:'utf8',env:trustedPowerShellEnvironment()
     });
     return {exit_code:0,stdout:String(stdout??''),stderr:String(stderr??'')};
   } catch(error) {
@@ -228,20 +250,28 @@ export async function startLocalSupervisorHost({runtime,policy=runtime?.policy,m
   try {
     supervisor=startAutonomousSupervisor({runtime,policy,idleDelayMs,maxCycles,logger,continuous});
   } catch(error) {
-    await releaseSupervisor({markerPath,instanceNonce:claim.instance_nonce}).catch(()=>{});
+    try { await releaseSupervisor({markerPath,instanceNonce:claim.instance_nonce}); }
+    catch(cleanupError) {
+      throw new AggregateError([error,cleanupError],
+        'supervisor startup and ownership cleanup both failed',{cause:error});
+    }
     throw error;
   }
   let stopped=false;
+  let stopPromise=null;
   return Object.freeze({
     marker_path:path.resolve(markerPath),instance_nonce:claim.instance_nonce,supervisor,
-    get running(){ return !stopped&&supervisor.running; },
-    async scanNow(){ if(stopped) throw new Error('local supervisor host stopped'); return supervisor.scanNow(); },
+    get running(){ return !stopPromise&&supervisor.running; },
+    async scanNow(){ if(stopPromise) throw new Error('local supervisor host stopping or stopped'); return supervisor.scanNow(); },
     async stop(){
       if(stopped) return {status:'stopped'};
-      stopped=true;
-      await supervisor.stop();
-      await releaseSupervisor({markerPath,instanceNonce:claim.instance_nonce});
-      return {status:'stopped'};
+      if(!stopPromise) stopPromise=(async()=>{
+        await supervisor.stop();
+        await releaseSupervisor({markerPath,instanceNonce:claim.instance_nonce});
+        stopped=true;
+        return {status:'stopped'};
+      })();
+      return stopPromise;
     }
   });
 }

package/src/deadbyte-cli.mjs

@@ -1,6 +1,6 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { closeSync, openSync } from 'node:fs';
-import { lstat, mkdir, open, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, open, readFile, readdir, stat, writeFile } from 'node:fs/promises';
 import { spawn, spawnSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import os from 'node:os';
@@ -22,9 +22,10 @@ import { ensureRuntimeCoherence } from './runtime-coherence.mjs';
 import { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
 import {foregroundIdentityMatches,queryForegroundIdentity,validForegroundIdentity} from './foreground-process-identity.mjs';
+import {readRemoteMarkerSnapshot,deletePinnedRemoteMarker} from './foreground-marker-cas-win32.mjs';
 import {acquireForegroundSessionLock} from './foreground-session-lock.mjs';
 import { AUTHORITY_PLANES, authorityVector, authorityRestorePlan, parseAuthorityObservation, assertAuthorityVector, assertRuntimeReadyObservation, authorityBanner } from './remote-authority.mjs';
-import { decodeRemoteLogBytes, boundedRemoteDiagnostic, safeRemoteLogPrefixLength } from './remote-log-decode-r60.mjs';
+import { decodeRemoteLogBytes, boundedRemoteDiagnostic, readRemoteLogAppend } from './remote-log-decode-r60.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
@@ -42,6 +43,7 @@ const CURRENT_PACKAGE_ROOT=path.resolve(fileURLToPath(new URL('..',import.meta.u
 const CURRENT_DEPLOY_SCRIPT=path.join(CURRENT_PACKAGE_ROOT,'scripts','deploy-r48.mjs');
 const REMOTE_UPDATE_TIMEOUT_MS=900000;
 const LIVE_LOG_DISCOVERY_INTERVAL_MS=1000;
+const TRUSTED_WINDOWS_ROOT='C:\\Windows';
 
 function stateRoot(){return resolveStateRoot();}
 async function requireRegular(file,label){const info=await lstat(file);if(!info.isFile()||info.isSymbolicLink()) throw new Error(`${label} must be a regular non-symlink file`);return file;}
@@ -78,8 +80,7 @@ async function remoteContext(){
   if(process.platform!=='win32') throw new Error('remote controller is currently Windows-only');
   const root=stateRoot();
   const launcher=await requireRegular(path.join(root,'bin','DEADBYTE-MCP.ps1'),'stable DEADBYTE launcher');
-  const systemRoot=process.env.SystemRoot||process.env.WINDIR;if(!systemRoot) throw new Error('SystemRoot/WINDIR missing');
-  const powershell=await requireRegular(path.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe'),'Windows PowerShell');
+  const powershell=await requireRegular(path.join(TRUSTED_WINDOWS_ROOT,'System32','WindowsPowerShell','v1.0','powershell.exe'),'Windows PowerShell');
   return {root,launcher,powershell};
 }
 function boundedSingleLine(value,maxChars=2048){
@@ -202,7 +203,8 @@ function invokeController(ctx,command,{capture=false,allowFailure=false,echoCapt
       stdio=['ignore',stdoutFd,stderrFd];
     }else stdio=capture?['ignore','pipe','pipe']:'inherit';
     const options={stdio,encoding:capture?'utf8':undefined,windowsHide:false,shell:false,
-      env:windowsPowerShellEnvironment(probeMode?{...process.env,DEADBYTE_REMOTE_PROBE_MODE:probeMode}:process.env)};
+      env:windowsPowerShellEnvironment({...process.env,SystemRoot:TRUSTED_WINDOWS_ROOT,WINDIR:TRUSTED_WINDOWS_ROOT,
+        ...(probeMode?{DEADBYTE_REMOTE_PROBE_MODE:probeMode}:{})})};
     if(Number.isInteger(timeoutMs)&&timeoutMs>0) options.timeout=timeoutMs;
     result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command,...(json?['-Json']:[])],options);
   }finally{
@@ -308,32 +310,15 @@ async function replayRemoteResults(root,cursor,{displayMode='unicode'}={}){
     if(!page.has_more) return next;
   }
 }
-async function readAppend(file,offset){
-  let info;try{info=await stat(file);}catch(error){if(error?.code==='ENOENT') return {offset:0,text:''};throw error;}
-  let start=offset;
-  const reset=info.size<start;
-  if(reset) start=0;
-  if(info.size===start) return {offset:start,text:''};
-  const handle=await open(file,'r');
-  let encoding=null,buffer,bytesRead=0;
-  try{
-    const header=Buffer.alloc(2);await handle.read(header,0,2,0);
-    if(header[0]===0xff&&header[1]===0xfe&&/\.log$/i.test(file)){
-      encoding='utf16le';if(start%2!==0)start=Math.max(0,start-1);
-    }
-    const length=Math.min(1024*1024,info.size-start);
-    if(length===0)return {offset:start,text:''};
-    buffer=Buffer.alloc(length);
-    ({bytesRead}=await handle.read(buffer,0,length,start));
-  }finally{await handle.close();}
-  const complete=safeRemoteLogPrefixLength(buffer.subarray(0,bytesRead),encoding??'utf8');
-  return {offset:start+complete,text:decodeRemoteLogBytes(file,buffer.subarray(0,complete),{encoding}),reset};
+async function readAppend(file,cursor){
+  return readRemoteLogAppend(file,cursor);
 }
 async function snapshotRemoteLogOffsets(root){
   const offsets=new Map();
   const files=await listLogFiles(root);
   for(const file of files){
-    try{offsets.set(file,(await stat(file)).size);}catch{}
+    const snapshot=await readRemoteLogAppend(file,null,{startAtEnd:true});
+    if(snapshot.cursor)offsets.set(file,snapshot.cursor);
   }
   return offsets;
 }
@@ -345,6 +330,7 @@ function timelineFilterEvent(timeline){
   return {
     event_type:'tool.result',request_id:timeline.request_id,tool:timeline.tool,
     outcome:{
+      status:timeline.side_effect_state==='unknown'?'interrupted':timeline.status,
       is_error:timeline.status==='error',
       ...(Number.isFinite(Number(timeline.duration_ms))?{duration_ms:Number(timeline.duration_ms)}:{}),
       ...(timeline.side_effect_state?{side_effect_state:timeline.side_effect_state}:{}),
@@ -367,10 +353,13 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
       nextDiscoveryAt=now+LIVE_LOG_DISCOVERY_INTERVAL_MS;
     }
     for(const file of liveFiles){
-      const prior=activeOffsets.has(file)?activeOffsets.get(file):0;
+      const prior=activeOffsets.has(file)?activeOffsets.get(file):null;
       const next=await readAppend(file,prior);
-      activeOffsets.set(file,next.offset);
-      if(next.reset)partialLines.delete(file);
+      activeOffsets.set(file,next.cursor);
+      if(next.reset){
+        partialLines.delete(file);
+        process.stderr.write('[LIVELOG] STREAM_RESET '+path.basename(file)+' — '+next.resetReason+'; check audit continuity before trusting coverage\n');
+      }
       if(!next.text)continue;
       const lines=((partialLines.get(file)??'')+next.text).split(/\r?\n/);
       partialLines.set(file,lines.pop()??'');
@@ -378,6 +367,8 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
       for(const line of lines){
         if(Buffer.byteLength(line,'utf8')>1024*1024) throw new Error(`remote log line exceeds bounded decode limit: ${path.basename(file)}`);
         const auditEvent=parseAuditLogLine(file,line);
+        if(/^segment-\d{8}\.jsonl$/.test(path.basename(file))&&!auditEvent)
+          throw new Error('LIVELOG_AUDIT_RECORD_INVALID '+path.basename(file)+'; refusing to silently skip audit bytes');
         const timeline=auditTimelineRecord(file,line,auditEvent);
         let recorded=null;
         if(timeline&&journal) recorded=timeline.event_type==='tool.call'
@@ -456,8 +447,9 @@ async function recoverRemoteSession(ctx,{displayMode='unicode'}={}){
   const ownerPid=remoteOwnerPid(prior);
   if(pidAlive(ownerPid)){
     if(!prior.owner_identity)throw new Error(`remote session ownership unverified for legacy pid=${ownerPid}; marker retained`);
-    if(prior.owner_identity.pid!==ownerPid)throw new Error('remote session owner identity PID binding mismatch');
-    if(foregroundIdentityMatches(prior.owner_identity,queryForegroundIdentity(ownerPid)))throw new Error(`remote session already active pid=${ownerPid}`);
+    if(prior.owner_identity.pid!==ownerPid)throw new Error('remote session owner identity PID binding mismatch; marker retained');
+    if(!foregroundIdentityMatches(prior.owner_identity,queryForegroundIdentity(ownerPid)))throw new Error('remote session owner identity mismatch; marker retained');
+    throw new Error(`remote session already active pid=${ownerPid}`);
   }
   let guardianAlive=prior.schema==='deadbyte.remote-session.v2'&&pidAlive(prior.guardian_pid);
   if(guardianAlive){
@@ -475,9 +467,7 @@ async function recoverRemoteSession(ctx,{displayMode='unicode'}={}){
     }
     throw new Error(`remote session guardian cleanup still active pid=${prior.guardian_pid}`);
   }
-  writeRemote(process.stdout,`${remoteTag('recovery',displayMode)} Stale remote session pid=${ownerPid}; revoking authority before restart.\n`,displayMode);
-  await cleanupRemoteSession(ctx,{displayMode});
-  await rm(remoteSessionMarker(ctx.root),{force:true});
+  throw new Error(`remote session ownership unverified for stale pid=${ownerPid}; marker retained`);
 }
 async function claimRemoteSession(ctx){
   const dir=path.join(ctx.root,'runtime');await mkdir(dir,{recursive:true});
@@ -505,14 +495,28 @@ async function claimRemoteSession(ctx){
     return marker;
   }catch(error){
     try{guardian?.kill();}catch{}
-    await rm(markerPath,{force:true});
+    try{
+      const snapshot=await readRemoteMarkerSnapshot(markerPath);
+      if(!snapshot||snapshot.marker?.owner_pid!==marker.owner_pid||snapshot.marker?.session_nonce!==marker.session_nonce)
+        throw new Error('claim marker ownership changed or missing');
+      if(deletePinnedRemoteMarker(markerPath,snapshot.sha256)!=='REMOVED')
+        throw new Error('claim marker changed before native deletion');
+    }catch(cleanupError){
+      throw new AggregateError([error,cleanupError],
+        'remote session claim failed; marker cleanup unverified and marker retained');
+    }
     throw error;
   }
 }
 async function releaseRemoteSession(ctx,marker,{displayMode='unicode'}={}){
-  let current=null;try{current=await readRemoteSessionMarker(ctx.root);}catch(error){writeRemote(process.stderr,`${remoteTag('warn',displayMode)} remote session marker cleanup: ${String(error?.message||error)}\n`,displayMode);return;}
+  let snapshot;
+  try{snapshot=await readRemoteMarkerSnapshot(remoteSessionMarker(ctx.root));}
+  catch(error){writeRemote(process.stderr,`${remoteTag('warn',displayMode)} remote session marker cleanup: ${String(error?.message||error)}\n`,displayMode);throw new Error(`remote session ownership marker retained: ${String(error?.message||error)}`);}
+  const current=snapshot?.marker;
   const same=current?.schema==='deadbyte.remote-session.v2'&&current.owner_pid===marker.owner_pid&&current.session_nonce===marker.session_nonce;
-  if(same) await rm(remoteSessionMarker(ctx.root),{force:true});
+  if(!same)throw new Error('remote session ownership marker changed or missing; marker retained');
+  if(deletePinnedRemoteMarker(remoteSessionMarker(ctx.root),snapshot.sha256)!=='REMOVED')
+    throw new Error('remote session ownership marker replaced before native deletion; marker retained');
 }
 async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,filterExpression='',mode='default'}={}){
   const display=prepareRemoteConsole();
@@ -531,10 +535,21 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   }finally{await startupLock.release();}
   try{
     await synchronizeForegroundRuntime(ctx,{displayMode});
-  }catch(error){
-    await cleanupRemoteSession(ctx,{displayMode});
-    await releaseRemoteSession(ctx,marker,{displayMode});
-    throw error;
+  }catch(primaryError){
+    let cleanupError=null;
+    try{await cleanupRemoteSession(ctx,{displayMode});}
+    catch(error){cleanupError=error;}
+    if(!cleanupError){
+      try{await releaseRemoteSession(ctx,marker,{displayMode});}
+      catch(error){cleanupError=error;}
+    }
+    if(cleanupError){
+      const primaryDetail=String(primaryError?.message||primaryError);
+      const cleanupDetail=String(cleanupError?.message||cleanupError);
+      throw new AggregateError([primaryError,cleanupError],
+        `remote activation failed: ${primaryDetail}; cleanup failed, ownership marker retained: ${cleanupDetail}`);
+    }
+    throw primaryError;
   }
   const resultJournal=await openRemoteResultJournal({
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
@@ -550,6 +565,7 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   if(watchStdin){process.stdin.once('end',abort);process.stdin.once('close',abort);process.stdin.resume();}
   let ready=false;
   let logTask=null;
+  let sessionError=null;
   try{
     process.stdout.write('DEADBYTE MCP\n');
     process.stdout.write(`${formatRemoteLifecycle('device_start',{displayMode})}\n`);
@@ -609,8 +625,9 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     process.stdout.write('[OK] ONLINE\n');
     process.stdout.write(`${formatRemoteLifecycle('ready',{displayMode})}\n`);
     if(url) writeRemote(process.stdout,`URL: ${url}\n`,displayMode);
-    await logTask;
-  }finally{
+    await logTask;
+  }catch(error){sessionError=error;throw error;}
+  finally{
     const wasAborted=aborter.signal.aborted;
     aborter.abort();
     if(logTask) await logTask.catch(()=>{});
@@ -623,8 +640,18 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     if(watchStdin){process.stdin.removeListener('end',abort);process.stdin.removeListener('close',abort);process.stdin.pause();}
     process.stdout.write(`${formatRemoteLifecycle('cleanup',{displayMode})}\n`);
     if(ready||!wasAborted) process.stdout.write('[INFO] Disconnecting; revoking authority...\n');
-    await cleanupRemoteSession(ctx,{displayMode});
-    await releaseRemoteSession(ctx,marker,{displayMode});
+    try{await cleanupRemoteSession(ctx,{displayMode});}
+    catch(cleanupError){
+      if(sessionError) throw new AggregateError([sessionError,cleanupError],
+        `remote activation failed: ${String(sessionError?.message||sessionError)}; cleanup failed, ownership marker retained: ${String(cleanupError?.message||cleanupError)}`);
+      throw cleanupError;
+    }
+    try{await releaseRemoteSession(ctx,marker,{displayMode});}
+    catch(markerError){
+      if(sessionError)throw new AggregateError([sessionError,markerError],
+        `remote activation failed: ${String(sessionError?.message||sessionError)}; marker cleanup failed: ${String(markerError?.message||markerError)}`);
+      throw markerError;
+    }
   }
 }
 async function runRemote(args){

package/src/epoch-lock-r85.mjs

@@ -0,0 +1,48 @@
+import {createHash, randomBytes} from 'node:crypto';
+import {lstat,readFile} from 'node:fs/promises';
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {inspectTrustedInstallation,privilegedEpochInstallFiles} from './privileged-install-trust-r89.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const binary=path.join(root,'bin','deadbyte-epoch-lock-r85.node');
+const metadata=path.join(root,'docs','R85-EPOCH-LOCK-BINARY.json');
+const require=createRequire(import.meta.url);
+const hex64=/^[0-9a-f]{64}$/;
+let addon=null;
+
+async function loadVerifiedAddon(){
+  if(process.platform!=='win32'||process.arch!=='x64')throw new Error('epoch held-handle lock requires Windows x64');
+  await inspectTrustedInstallation(privilegedEpochInstallFiles(root,process.execPath));
+  const meta=JSON.parse(await readFile(metadata,'utf8'));
+  if(meta.schema!=='deadbyte.r85-epoch-lock-binary.v1'||meta.platform!=='win32-x64'||
+    meta.addon!=='bin/deadbyte-epoch-lock-r85.node'||meta.source!=='native/deadbyte-epoch-lock-r85.cpp'||
+    meta.node_api_version>Number(process.versions.napi)||!hex64.test(meta.addon_sha256)||!hex64.test(meta.source_sha256))
+    throw new Error('epoch held-handle binary metadata invalid');
+  const [st,bytes,sourceBytes]=await Promise.all([lstat(binary),readFile(binary),readFile(path.join(root,meta.source))]);
+  if(!st.isFile()||st.isSymbolicLink()||
+    createHash('sha256').update(bytes).digest('hex')!==meta.addon_sha256||
+    createHash('sha256').update(sourceBytes).digest('hex')!==meta.source_sha256)
+    throw new Error('epoch held-handle binary/source hash mismatch');
+  addon??=require(binary);
+  if(typeof addon.acquire!=='function'||typeof addon.release!=='function')
+    throw new Error('epoch held-handle exports invalid');
+  return addon;
+}
+
+export async function acquireHeldEpochLock(file,bytes){
+  if(!Buffer.isBuffer(bytes)||bytes.length<2||bytes.length>16384||typeof file!=='string'||!path.isAbsolute(file))
+    throw new Error('epoch held-handle lock arguments invalid');
+  const native=await loadVerifiedAddon();
+  const handle=native.acquire(file,bytes,randomBytes(16).toString('hex'));
+  if(handle===null)return null;
+  let released=false;
+  return Object.freeze({
+    async release(){
+      if(released)throw new Error('epoch held-handle lock already released');
+      native.release(handle);
+      released=true;
+    }
+  });
+}