deadbyte-mcp 0.15.36 → 0.15.37

package/bridge/src/bridge-health-r59.mjs

@@ -6,8 +6,8 @@ function bounded(value,max=512){
     .replace(/(?:Bearer\s+\S+|token|secret|password|[A-Za-z]:\\[^ ]+)/gi,'<redacted>').slice(0,max);
 }
 
-export function createBridgeHealth({clock=Date.now,maxCapabilityAgeMs=15000}={}){
-  if(typeof clock!=='function'||!Number.isInteger(maxCapabilityAgeMs)||maxCapabilityAgeMs<5000||maxCapabilityAgeMs>60000) throw new Error('bridge health options invalid');
+export function createBridgeHealth({clock=Date.now,elapsedClock=clock===Date.now?()=>performance.now():clock,maxCapabilityAgeMs=15000}={}){
+  if(typeof clock!=='function'||typeof elapsedClock!=='function'||!Number.isInteger(maxCapabilityAgeMs)||maxCapabilityAgeMs<5000||maxCapabilityAgeMs>60000) throw new Error('bridge health options invalid');
   let phase='STARTING';
   let diagnostic='downstream initialization pending';
   let core=null;
@@ -24,6 +24,7 @@ export function createBridgeHealth({clock=Date.now,maxCapabilityAgeMs=15000}={})
     const observed=Date.parse(manifest.observed_at_utc),validUntil=Date.parse(manifest.valid_until_utc);
     if(!Number.isFinite(observed)||!Number.isFinite(validUntil)||validUntil<observed) throw new Error('bridge capability timestamps invalid');
     capability=Object.freeze({snapshot_id:manifest.snapshot_id,state_epoch:manifest.state_epoch,observed_at_ms:observed,
+      received_elapsed_ms:Number(elapsedClock()),age_at_receive_ms:Math.max(0,Number(clock())-observed),
       valid_until_ms:validUntil,release_manifest_sha256:HEX64.test(String(manifest.bindings?.release_manifest_sha256))?manifest.bindings.release_manifest_sha256:null,
       generation_manifest_sha256:HEX64.test(String(manifest.bindings?.generation_manifest_sha256))?manifest.bindings.generation_manifest_sha256:null});
     const unavailable=Object.entries(manifest.planes??{}).filter(([,value])=>value?.state==='DEGRADED'||value?.state==='UNAVAILABLE');
@@ -38,7 +39,7 @@ export function createBridgeHealth({clock=Date.now,maxCapabilityAgeMs=15000}={})
   function snapshot(){
     const now=Number(clock());
     let state=phase,reason=diagnostic;
-    const stale=capability&&(now-capability.observed_at_ms>maxCapabilityAgeMs||now>capability.valid_until_ms);
+    const stale=capability&&(capability.age_at_receive_ms+Math.max(0,Number(elapsedClock())-capability.received_elapsed_ms)>maxCapabilityAgeMs||now>capability.valid_until_ms);
     if(phase==='READY'&&(!core||!capability||stale)){state='DEGRADED';reason=stale?'capability snapshot stale':'downstream attestation incomplete';}
     if(!PHASES.has(state)) throw new Error('bridge health phase invalid');
     const ready=state==='READY'&&Boolean(core)&&Boolean(capability);

package/bridge/src/bridge.mjs

@@ -1,4 +1,5 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { createServer } from 'node:http';
 import { readFileSync } from 'node:fs';
 import os from 'node:os';
@@ -10,8 +11,23 @@ import {preparePublicToolDefinitions} from './public-tool-definitions.mjs';
 import {createDeadbyteNodeHandler} from './node-http-adapter.mjs';
 import { bridgeCatalogSha256, bridgeDeadlineForTool, createBridgeGovernor, enforceDesktopBridgeResult, verifyCompactCatalogAttestation } from './r40-governor.mjs';
 import { createBridgeHealth } from './bridge-health-r59.mjs';
+import { reconnectDelayMs, waitForReconnect, RECONNECT_ATTEMPT_BUDGET, classifyReconnectFailure } from './reconnect-delay-r60.mjs';
+import {openRemoteCallClaims} from './remote-call-claims-r60.mjs';
+import {dispatchBridgeCall,classifyRemoteOperation} from './remote-dispatch-r60.mjs';
+import {canonicalJson} from './canonical-json-r60.mjs';
 
 const coreRoot = path.resolve(process.env.DEADBYTE_CORE_ROOT ?? 'C:/Users/DEADBYTE/Downloads/deadbyte-mcp-v0.6.0');
+const configuredStateRoot=process.env.DEADBYTE_STATE_ROOT;
+if(configuredStateRoot&&(!path.isAbsolute(configuredStateRoot)||configuredStateRoot.trim()===''))throw new Error('bridge state root must be absolute');
+const stateRoot=path.resolve(configuredStateRoot||path.join(os.homedir(),'.deadbyte-mcp'));
+const remoteClaims=openRemoteCallClaims({root:path.join(stateRoot,'runtime','remote-call-claims')});
+let recoveryCursor=null,recoveredClaims=0;
+do{
+  const batch=await remoteClaims.recover({after:recoveryCursor,limit:100});
+  recoveredClaims+=batch.records.length;
+  if(recoveredClaims>100000)throw new Error('remote claim recovery exceeds bounded startup inventory');
+  recoveryCursor=batch.next_cursor;
+}while(recoveryCursor!==null);
 const coreServer = path.join(coreRoot, 'src', 'mcp-server.mjs');
 const workspaceRoot = path.resolve(process.env.DEADBYTE_WORKSPACE_ROOT ?? path.join(coreRoot, 'workspaces'));
 const port = Number(process.env.DEADBYTE_BRIDGE_PORT ?? '8787');
@@ -285,17 +301,23 @@ capabilityRefreshTimer.unref?.();
 let shuttingDown=false;
 let reconnecting=false;
 let downstreamGeneration=1;
-const reconnectDelays=[250,500,1000,2000,4000];
-const wait=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+const reconnectAbort=new AbortController();
 
 async function attestReplacement(client){
-  if(client.getProtocolEra()!=='modern') throw new Error('replacement core protocol is not modern');
+  if(client.getProtocolEra()!=='modern') throw Object.assign(new Error('replacement core protocol is not modern'),{kind:'terminal',code:'DEADBYTE_SCHEMA_INVALID'});
   const replacement=(await client.listTools()).tools.map(tool=>tool.name).sort();
-  if(JSON.stringify(replacement)!==JSON.stringify(actualNames)) throw new Error('replacement core catalog drift');
+  if(JSON.stringify(replacement)!==JSON.stringify(actualNames)) throw Object.assign(new Error('replacement core catalog drift'),{kind:'terminal',code:'DEADBYTE_SCHEMA_INVALID'});
   const result=await client.callTool({name:'capability_manifest',arguments:{}},bridgeDeadlineForTool('capability_manifest'));
   verifyCompactCatalogAttestation(actualNames,result);
-  if(result?.structuredContent?.result?.schema!=='deadbyte.capability-manifest.v3') throw new Error('replacement core capability manifest v3 missing');
-  return result.structuredContent.result;
+  const manifest=result?.structuredContent?.result;
+  if(manifest?.schema!=='deadbyte.capability-manifest.v3') throw Object.assign(new Error('replacement core capability manifest v3 missing'),{kind:'terminal',code:'DEADBYTE_SCHEMA_INVALID'});
+  const status=(await client.callTool({name:'machine_status',arguments:{}},bridgeDeadlineForTool('machine_status')))?.structuredContent;
+  if(status?.status!=='ok'||!HEX64.test(String(status.machine_id??''))||!HEX64.test(String(status.online_epoch??'')))
+    throw Object.assign(new Error('replacement core execution probe failed'),{kind:'transient',code:'DEADBYTE_EXECUTION_PROBE_FAILED'});
+  if(status.release_manifest_sha256!==manifest.bindings?.release_manifest_sha256||
+    status.generation_manifest_sha256!==manifest.bindings?.generation_manifest_sha256)
+    throw Object.assign(new Error('replacement core execution binding mismatch'),{kind:'terminal',code:'DEADBYTE_GENERATION_MISMATCH'});
+  return manifest;
 }
 function bindDownstreamClose(transport){
   const sdkClose=transport.onclose;
@@ -311,8 +333,8 @@ async function reconcileDownstream(){
   if(reconnecting||shuttingDown)return;
   reconnecting=true;
   try{
-    for(let attempt=0;attempt<reconnectDelays.length&&!shuttingDown;attempt++){
-      await wait(reconnectDelays[attempt]);
+    for(let attempt=0;attempt<RECONNECT_ATTEMPT_BUDGET&&!shuttingDown;attempt++){
+      if(!(await waitForReconnect(reconnectDelayMs(attempt),reconnectAbort.signal))||shuttingDown)return;
       const nextClient=newDownstreamClient(),nextTransport=newDownstreamTransport();
       pipeCoreStderr(nextTransport);
       try{
@@ -326,7 +348,11 @@ async function reconcileDownstream(){
         return;
       }catch(error){
         await nextClient.close().catch(()=>{});
-        bridgeHealth.reconciling(`core reconnect ${attempt+1}/${reconnectDelays.length} failed: ${error?.message??String(error)}`);
+        bridgeHealth.reconciling(`core reconnect ${attempt+1}/${RECONNECT_ATTEMPT_BUDGET} failed: ${error?.message??String(error)}`);
+        if(classifyReconnectFailure(error)==='TERMINAL'){
+          bridgeHealth.degraded(`core reconnect terminal failure: ${error?.message??String(error)}`);
+          return;
+        }
       }
     }
     bridgeHealth.degraded('core restart budget exhausted; bridge quarantined');
@@ -345,6 +371,36 @@ function plannerTextFromInput(ctx) {
 
 const publicToolDefinitions=preparePublicToolDefinitions(listed.tools);
 
+const remoteDeviceId=createHash('sha256').update(endpointPath,'utf8').digest('hex');
+const ingressDelivery=new AsyncLocalStorage();
+const HEX64=/^[0-9a-f]{64}$/;
+async function dispatchDownstream(tool,args,ctx,budget){
+  if(ctx.mcpReq.signal?.aborted)throw new Error('remote request cancelled before claim');
+  const observed=(await downstream.callTool({name:'machine_status',arguments:{}},bridgeDeadlineForTool('machine_status')))?.structuredContent;
+  const capability=bridgeHealth.snapshot().capability;
+  if(observed?.status!=='ok'||!HEX64.test(String(observed.machine_id??''))||!HEX64.test(String(observed.online_epoch??''))||
+    !HEX64.test(String(observed.generation_manifest_sha256??''))||typeof observed.release_id!=='string'||
+    observed.generation_manifest_sha256!==capability?.generation_manifest_sha256||
+    observed.release_manifest_sha256!==capability?.release_manifest_sha256)
+    throw new Error('remote claim machine/release/generation observation invalid');
+  const requestId=createHash('sha256').update(canonicalJson(ctx.mcpReq.id),'utf8').digest('hex');
+  const metadata=ctx.mcpReq._meta;
+  const idempotencyKey=metadata?.idempotency_key;
+  if(idempotencyKey!==undefined&&typeof idempotencyKey!=='string')throw new Error('remote idempotency_key invalid');
+  const classification=classifyRemoteOperation(tool,args);
+  // A stateless HTTP delivery is not a durable logical session. Only an
+  // explicit idempotency key may identify a mutation across deliveries.
+  const deliveryId=ingressDelivery.getStore()?.delivery_id;
+  if(!deliveryId)throw new Error('remote ingress delivery identity missing');
+  const binding={device_id:remoteDeviceId,session_id:deliveryId,request_id:requestId,
+    ...(idempotencyKey===undefined?{}:{idempotency_key:idempotencyKey}),tool:tool.name,arguments:args,
+    expires_at_utc:new Date(Date.now()+budget.maxTotalTimeout).toISOString(),
+    machine_id:observed.machine_id,online_epoch:observed.online_epoch,release_id:observed.release_id,
+    generation_manifest_sha256:observed.generation_manifest_sha256,classification};
+  return dispatchBridgeCall({claims:remoteClaims,binding,classification,signal:ctx.mcpReq.signal,
+    invoke:()=>downstream.callTool({name:tool.name,arguments:args},budget)});
+}
+
 function buildFrontServer() {
   const front = new McpServer(
     { name: 'deadbyte-chatgpt-bridge', version: '0.2.0' },
@@ -366,13 +422,13 @@ function buildFrontServer() {
         const ticket = await bridgeGovernor.acquire(tool.name,{signal:ctx.mcpReq.signal});
         try {
           const budget = bridgeDeadlineForTool(tool.name);
-          const result = await downstream.callTool({ name: tool.name, arguments: args }, budget);
+          const result = await dispatchDownstream(tool,args,ctx,budget);
           enforceDesktopBridgeResult(tool.name, result);
           auditToolFinish(audit, result);
           return result;
         } catch (error) {
           auditToolFail(audit, error);
-          if(tool.annotations?.readOnlyHint!==true&&['RECONCILING','DEGRADED'].includes(bridgeHealth.snapshot().state)) throw new Error(`bridge correlation call=${audit.id} generation=${downstreamGeneration}; mutation outcome unknown; reconcile before retry`,{cause:error});
+          if(classifyRemoteOperation(tool,args)!=='read_only'&&['RECONCILING','DEGRADED'].includes(bridgeHealth.snapshot().state)) throw new Error(`bridge correlation call=${audit.id} generation=${downstreamGeneration}; mutation outcome unknown; reconcile before retry`,{cause:error});
           throw error;
         } finally {
           ticket.release();
@@ -390,7 +446,7 @@ function buildFrontServer() {
       let result;
       try {
         const budget = bridgeDeadlineForTool(tool.name);
-        result = await downstream.callTool({ name: tool.name, arguments: callArgs }, budget);
+        result = await dispatchDownstream(tool,callArgs,ctx,budget);
         auditToolFinish(audit, result);
       } catch (error) {
         auditToolFail(audit, error);
@@ -451,7 +507,7 @@ const httpServer = createServer(async (req, res) => {
       res.writeHead(413, { 'content-type': 'text/plain; charset=utf-8' });
       return res.end('request too large');
     }
-    await nodeMcpHandler(req, res);
+    await ingressDelivery.run({delivery_id:randomUUID()},()=>nodeMcpHandler(req, res));
   } catch (error) {
     if (!res.headersSent) res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' });
     if (!res.writableEnded) res.end('bridge error');
@@ -474,6 +530,7 @@ console.log(`BRIDGE_AUTONOMOUS_RUNTIME ${autonomousConfigured ? 'ENABLED' : 'DIS
 
 async function shutdown() {
   shuttingDown=true;
+  reconnectAbort.abort();
   bridgeHealth.stopping();
   clearInterval(capabilityRefreshTimer);
   httpServer.close();

package/bridge/src/canonical-json-r60.mjs

@@ -0,0 +1,13 @@
+// Keep byte-for-byte canonicalization compatible with src/canonical-json.mjs.
+// Bridge dependencies are pinned inside bridge/, so this local copy is tested
+// against the Core primitive rather than reaching outside the Bridge root.
+function canonicalize(value){
+  if(Array.isArray(value))return value.map(canonicalize);
+  if(value!==null&&typeof value==='object'){
+    const out={};
+    for(const key of Object.keys(value).sort())out[key]=canonicalize(value[key]);
+    return out;
+  }
+  return value;
+}
+export function canonicalJson(value){return JSON.stringify(canonicalize(value));}

package/bridge/src/reconnect-delay-r60.mjs

@@ -0,0 +1,31 @@
+import { setTimeout as delay } from 'node:timers/promises';
+
+const BASE_DELAYS_MS=Object.freeze([250,500,1000,2000,4000]);
+
+export function reconnectDelayMs(attempt,random=Math.random){
+  if(!Number.isInteger(attempt)||attempt<0||attempt>=BASE_DELAYS_MS.length) throw new Error('reconnect attempt outside budget');
+  const sample=Number(random());
+  if(!Number.isFinite(sample)||sample<0||sample>1) throw new Error('reconnect jitter source invalid');
+  return Math.round(BASE_DELAYS_MS[attempt]*(0.75+sample*0.5));
+}
+
+export const RECONNECT_ATTEMPT_BUDGET=BASE_DELAYS_MS.length;
+
+export async function waitForReconnect(milliseconds,signal){
+  if(signal?.aborted)return false;
+  try{await delay(milliseconds,undefined,{signal});return !signal?.aborted;}
+  catch(error){if(error?.name==='AbortError')return false;throw error;}
+}
+
+export function classifyReconnectFailure(error){
+  const code=String(error?.code??'').toUpperCase();
+  if(error?.kind==='terminal')return 'TERMINAL';
+  if(error?.kind==='transient')return 'TRANSIENT';
+  if(new Set(['DEADBYTE_AUTHORITY_REVOKED','DEADBYTE_POLICY_DENIED','DEADBYTE_SCHEMA_INVALID',
+    'DEADBYTE_RELEASE_MISMATCH','DEADBYTE_GENERATION_MISMATCH','DEADBYTE_IDEMPOTENCY_CONFLICT',
+    'DEADBYTE_CLAIM_CORRUPT','DEADBYTE_CREDENTIAL_EXPIRED']).has(code))return 'TERMINAL';
+  const message=String(error?.message??error??'').toLowerCase();
+  if(['EACCES','EPERM','ENOENT'].includes(code)||/identity drift|catalog drift|protocol is not modern|attestation invalid|generation mismatch|policy mismatch/.test(message))return 'TERMINAL';
+  if(['ECONNRESET','ECONNREFUSED','EPIPE','ETIMEDOUT','EHOSTUNREACH'].includes(code)||/connection reset|transport closed|timed out|temporarily unavailable/.test(message))return 'TRANSIENT';
+  return 'TERMINAL';
+}

package/bridge/src/remote-call-claims-r60.mjs

@@ -0,0 +1,157 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { link, lstat, mkdir, open, readFile, readdir, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { canonicalJson } from './canonical-json-r60.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._:-]{1,160}$/;
+const sha=value=>createHash('sha256').update(canonicalJson(value),'utf8').digest('hex');
+
+async function publishOnce(target,value){
+  const temp=`${target}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
+  const handle=await open(temp,'wx');
+  const record={...value,record_sha256:sha(value)};
+  try{await handle.writeFile(`${canonicalJson(record)}\n`,'utf8');await handle.sync();}
+  finally{await handle.close();}
+  try{await link(temp,target);return true;}
+  catch(error){if(error?.code==='EEXIST')return false;throw error;}
+  finally{await rm(temp,{force:true});}
+}
+async function readExact(file){
+  try{
+    const info=await lstat(file);
+    if(!info.isFile()||info.isSymbolicLink()||info.size>2*1024*1024)throw new Error('remote claim record type or size corrupt');
+    const record=JSON.parse(await readFile(file,'utf8'));
+    if(!record||typeof record!=='object'||Array.isArray(record))throw new Error('remote claim record corrupt');
+    const {record_sha256,...body}=record;
+    if(!HEX64.test(String(record_sha256??''))||record_sha256!==sha(body))throw new Error('remote claim record hash corrupt');
+    return body;
+  }
+  catch(error){if(error?.code==='ENOENT')return null;throw new Error(`remote claim state unreadable: ${String(error?.message||error)}`);}
+}
+function validate(binding,now){
+  if(!binding||typeof binding!=='object'||Array.isArray(binding))throw new Error('remote claim binding invalid');
+  for(const key of ['device_id','session_id','request_id','tool','release_id'])if(!ID.test(String(binding[key]??'')))throw new Error(`remote claim ${key} invalid`);
+  if(binding.idempotency_key!==undefined&&!ID.test(String(binding.idempotency_key)))throw new Error('remote claim idempotency_key invalid');
+  if(!HEX64.test(String(binding.machine_id??'')))throw new Error('remote claim machine_id invalid');
+  if(!HEX64.test(String(binding.generation_manifest_sha256??'')))throw new Error('remote claim generation binding invalid');
+  if(!HEX64.test(String(binding.online_epoch??'')))throw new Error('remote claim online epoch invalid');
+  if(!['read_only','mutating','unknown'].includes(binding.classification))throw new Error('remote claim classification invalid');
+  if(!binding.arguments||typeof binding.arguments!=='object'||Array.isArray(binding.arguments))throw new Error('remote claim arguments invalid');
+  const expires=Date.parse(binding.expires_at_utc);
+  if(!Number.isFinite(expires))throw new Error('remote claim deadline invalid');
+  if(expires<=now)throw new Error('remote request expired');
+  return Object.freeze({schema:'deadbyte.remote-call-claim.v1',device_id:binding.device_id,session_id:binding.session_id,
+    idempotency_key:binding.idempotency_key??null,
+    request_id:String(binding.request_id),tool:binding.tool,payload_sha256:sha(binding.arguments),
+    received_at_utc:new Date(now).toISOString(),expires_at_utc:new Date(expires).toISOString(),
+    release_id:binding.release_id,generation_manifest_sha256:binding.generation_manifest_sha256,
+    machine_id:binding.machine_id,online_epoch:binding.online_epoch,classification:binding.classification});
+}
+
+export function openRemoteCallClaims({root,clock=Date.now}={}){
+  if(typeof root!=='string'||!path.isAbsolute(root)||typeof clock!=='function')throw new Error('remote claim store options invalid');
+  const directory=path.resolve(root);
+  function files(id){
+    if(!HEX64.test(String(id)))throw new Error('remote claim identity invalid');
+    const base=path.join(directory,id.slice(0,2),id);
+    return {base,claim:`${base}.claim.json`,claimed:`${base}.claimed.json`,dispatch:`${base}.dispatch.json`,interrupted:`${base}.interrupted.json`,terminal:`${base}.terminal.json`};
+  }
+  async function state(claimId){
+    const f=files(claimId);
+    const claim=await readExact(f.claim);
+    if(!claim||claim.schema!=='deadbyte.remote-call-claim.v1')throw new Error('remote claim missing or invalid');
+    const terminal=await readExact(f.terminal);
+    if(terminal){
+      if(terminal.schema!=='deadbyte.remote-call-terminal.v1'||terminal.claim_id!==claimId||
+        !HEX64.test(String(terminal.result_sha256??''))||terminal.result_sha256!==sha(terminal.result))
+        throw new Error('remote claim terminal hash corrupt');
+      return Object.freeze({claim_id:claimId,owner:false,state:'TERMINAL',side_effect_state:claim.classification==='read_only'?'none':'unknown',result:terminal.result});
+    }
+    const interrupted=await readExact(f.interrupted);
+    if(interrupted){
+      if(interrupted.schema!=='deadbyte.remote-call-interrupted.v1'||interrupted.claim_id!==claimId)throw new Error('remote claim interruption corrupt');
+      return Object.freeze({claim_id:claimId,owner:false,state:'INTERRUPTED',side_effect_state:claim.classification==='read_only'?'none':'unknown'});
+    }
+    const dispatched=await readExact(f.dispatch);
+    if(dispatched)return Object.freeze({claim_id:claimId,owner:false,state:'EXECUTING',side_effect_state:claim.classification==='read_only'?'none':'may_have_started'});
+    const claimed=await readExact(f.claimed);
+    return Object.freeze({claim_id:claimId,owner:false,state:claimed?'CLAIMED':'RECEIVED',side_effect_state:'not_started'});
+  }
+  async function claim(binding){
+    const record=validate(binding,Number(clock()));
+    const claimId=record.idempotency_key===null
+      ?sha({device_id:record.device_id,session_id:record.session_id,request_id:record.request_id})
+      :sha({device_id:record.device_id,idempotency_key:record.idempotency_key});
+    const f=files(claimId);
+    await mkdir(path.dirname(f.base),{recursive:true});
+    if(await publishOnce(f.claim,record)){
+      const owner=await publishOnce(f.claimed,{schema:'deadbyte.remote-call-claimed.v1',claim_id:claimId,execution_state:'CLAIMED',side_effect_state:'not_started'});
+      return owner?Object.freeze({claim_id:claimId,owner:true,state:'CLAIMED',side_effect_state:'not_started'}):state(claimId);
+    }
+    const prior=await readExact(f.claim);
+    if(!prior||prior.schema!==record.schema)throw new Error('remote claim identity corrupt');
+    if(Date.parse(prior.expires_at_utc)<=Number(clock()))throw new Error('remote request expired');
+    if(prior.tool!==record.tool||prior.payload_sha256!==record.payload_sha256)throw new Error(record.idempotency_key===null?'request_id_conflict':'idempotency_key_conflict');
+    if(prior.device_id!==record.device_id||prior.idempotency_key!==record.idempotency_key||
+      (record.idempotency_key===null&&(prior.session_id!==record.session_id||prior.request_id!==record.request_id)))throw new Error('remote claim identity drift');
+    if(prior.release_id!==record.release_id||prior.generation_manifest_sha256!==record.generation_manifest_sha256)throw new Error('remote claim release identity drift');
+    if(prior.machine_id!==record.machine_id||prior.online_epoch!==record.online_epoch||prior.classification!==record.classification)throw new Error('remote claim machine/epoch/classification drift');
+    const current=await state(claimId);
+    if(current.state==='RECEIVED'&&await publishOnce(f.claimed,{schema:'deadbyte.remote-call-claimed.v1',claim_id:claimId,execution_state:'CLAIMED',side_effect_state:'not_started'}))
+      return Object.freeze({claim_id:claimId,owner:true,state:'CLAIMED',side_effect_state:'not_started'});
+    return state(claimId);
+  }
+  async function dispatch(claimId){
+    const f=files(claimId);
+    if(!(await readExact(f.claimed)))throw new Error('remote claim not claimed before dispatch');
+    if(!(await publishOnce(f.dispatch,{schema:'deadbyte.remote-call-dispatch.v1',claim_id:claimId,at_utc:new Date(Number(clock())).toISOString(),execution_state:'EXECUTING',side_effect_state:'may_have_started'})))
+      throw new Error('remote claim already dispatched; outcome unknown');
+    return Object.freeze({claim_id:claimId,state:'EXECUTING',side_effect_state:'may_have_started'});
+  }
+  async function terminal(claimId,result){
+    const f=files(claimId);
+    if(!(await readExact(f.dispatch)))throw new Error('remote claim not dispatched');
+    const bytes=Buffer.byteLength(canonicalJson(result),'utf8');
+    if(bytes>1048576)throw new Error('remote claim terminal result exceeds bound');
+    if(!(await publishOnce(f.terminal,{schema:'deadbyte.remote-call-terminal.v1',claim_id:claimId,
+      at_utc:new Date(Number(clock())).toISOString(),result_sha256:sha(result),result})))throw new Error('remote claim already terminal');
+    return state(claimId);
+  }
+  async function recover({after=null,limit=100}={}){
+    if(after!==null&&!HEX64.test(String(after)))throw new Error('remote recovery cursor invalid');
+    if(!Number.isInteger(limit)||limit<1||limit>100)throw new Error('remote recovery batch limit invalid');
+    const records=[];let more=false;
+    for(let shard=0;shard<256;shard++){
+      const prefix=shard.toString(16).padStart(2,'0');
+      if(after&&prefix<after.slice(0,2))continue;
+      const folder=path.join(directory,prefix);
+      let names;
+      try{
+        const info=await lstat(folder);
+        if(!info.isDirectory()||info.isSymbolicLink())throw new Error('remote recovery shard corrupt');
+        names=await readdir(folder);
+      }catch(error){if(error?.code==='ENOENT')continue;throw error;}
+      if(names.length>4096)throw new Error('remote recovery shard exceeds bounded inventory');
+      for(const name of names.filter(item=>/^[0-9a-f]{64}\.claim\.json$/.test(item)).sort()){
+        const id=name.slice(0,64);
+        if(after&&id<=after)continue;
+        if(records.length>=limit){more=true;break;}
+        const claimRecord=await readExact(files(id).claim);
+        if(!claimRecord||claimRecord.schema!=='deadbyte.remote-call-claim.v1')throw new Error('remote recovery claim corrupt');
+        if(Date.parse(claimRecord.expires_at_utc)<=Number(clock()))continue;
+        let current=await state(id);
+        if(current.state==='TERMINAL')continue;
+        if(current.state==='EXECUTING'){
+          await publishOnce(files(id).interrupted,{schema:'deadbyte.remote-call-interrupted.v1',claim_id:id,
+            at_utc:new Date(Number(clock())).toISOString(),execution_state:'INTERRUPTED',side_effect_state:current.side_effect_state==='none'?'none':'unknown'});
+          current=await state(id);
+        }
+        records.push(current);
+      }
+      if(more)break;
+    }
+    return Object.freeze({records,next_cursor:more?records.at(-1)?.claim_id??after:null});
+  }
+  return Object.freeze({claim,dispatch,terminal,state,recover});
+}

package/bridge/src/remote-dispatch-r60.mjs

@@ -0,0 +1,75 @@
+// This function is the one downstream-dispatch boundary used by the Bridge.
+// A published dispatch marker precedes every call that might mutate Core.
+const READ_ONLY_TOOLS=new Set([
+  'agent_task_events','agent_task_status','agent_task_verify',
+  'autonomous_goal_events','autonomous_goal_status','autonomous_goal_verify','autonomous_session_status',
+  'capability_manifest','coding_file_read','coding_files_read','coding_receipt_verify','coding_search',
+  'coding_session_status','coding_stat','coding_symbol_definition','coding_symbol_outline','coding_symbol_references',
+  'coding_task_events','coding_task_status','coding_task_verify','coding_tree','evidence_verify','file_read',
+  'host_file_read','machine_fs_list','machine_fs_read','machine_fs_stat','machine_list','machine_ping',
+  'machine_process_list','machine_search_page','machine_search_status','machine_status','machine_system_status',
+  'native_diff_preview','native_diff_verify','process_session_list','process_session_read','process_session_status'
+]);
+const MUTATING_TOOLS=new Set([
+  'agent_task_approve','agent_task_cancel','agent_task_run','agent_task_submit',
+  'autonomous_goal_approve','autonomous_goal_cancel','autonomous_goal_run','autonomous_goal_submit','autonomous_release_gate',
+  'coding_benchmark_run','coding_command_run','coding_file_write','coding_symbol_replace','coding_task_approve',
+  'coding_task_cancel','coding_task_run','coding_task_submit','coding_text_replace','contained_transform',
+  'host_exec','host_file_write','machine_fs_delete','machine_fs_edit_exact','machine_fs_mkdir','machine_fs_move',
+  'machine_fs_write','machine_revoke','machine_search_cancel','machine_search_start','native_diff_apply',
+  'process_session_action','process_session_start','process_session_terminate','proof_execute','workspace_open'
+]);
+const COMPACT_READ_ONLY={
+  machine_fs:new Set(['stat','list','read']),
+  process_session:new Set(['read','status','list']),
+  machine_observe:new Set(['machine_list','machine_status','machine_ping','search_page','search_status',
+    'process_list','system_status','hardware_query','registry_query','service_list','driver_list',
+    'socket_list','volume_list','usb_list','wsl_list']),
+  coding_inspect:new Set(['stat','search','files_read','symbol_outline','symbol_definition','symbol_references',
+    'symbol_diagnostics','symbol_implementations','symbol_rename_preview']),
+  desktop_control:new Set(['observe','status'])
+};
+const COMPACT_MUTATING={
+  machine_fs:new Set(['write','edit_exact','mkdir','move','delete']),
+  process_session:new Set(['start','write','action','terminate']),
+  machine_observe:new Set(['search_start','search_cancel']),
+  desktop_control:new Set(['target','action'])
+};
+
+export function classifyRemoteOperation(tool,args){
+  const name=tool?.name;
+  if(typeof name!=='string')return 'unknown';
+  if(Object.hasOwn(COMPACT_READ_ONLY,name)||Object.hasOwn(COMPACT_MUTATING,name)){
+    if(COMPACT_READ_ONLY[name]?.has(args?.op))return 'read_only';
+    if(COMPACT_MUTATING[name]?.has(args?.op))return 'mutating';
+    return 'unknown';
+  }
+  if(MUTATING_TOOLS.has(name))return 'mutating';
+  if(READ_ONLY_TOOLS.has(name))return 'read_only';
+  return 'unknown';
+}
+
+export async function dispatchBridgeCall({claims,binding,classification,signal,invoke}){
+  if(!claims||typeof claims.claim!=='function'||typeof invoke!=='function')throw new Error('remote dispatch dependencies invalid');
+  if(!['read_only','mutating','unknown'].includes(classification))throw new Error('remote dispatch classification invalid');
+  const claim=await claims.claim(binding);
+  if(claim.state==='TERMINAL')return claim.result;
+  const recoveredRead=claim.state==='INTERRUPTED'&&classification==='read_only'&&claim.side_effect_state==='none';
+  if((claim.state==='EXECUTING'||claim.state==='INTERRUPTED')&&!recoveredRead)throw new Error(`remote claim ${claim.claim_id} outcome unknown; reconcile before retry`);
+  if(claim.state!=='CLAIMED'&&!recoveredRead)throw new Error(`remote claim ${claim.claim_id} is ${claim.state}; no dispatch`);
+  if(signal?.aborted)throw new Error(`remote claim ${claim.claim_id} cancelled before dispatch`);
+  if(!recoveredRead){
+    try{await claims.dispatch(claim.claim_id);}
+    catch(error){throw new Error(`remote claim ${claim.claim_id} already in flight; no replay`,{cause:error});}
+  }
+  let result;
+  try{result=await invoke();}
+  catch(error){throw new Error(`remote claim ${claim.claim_id} outcome unknown after dispatch; no replay`,{cause:error});}
+  try{await claims.terminal(claim.claim_id,result);}
+  catch(error){
+    const existing=await claims.state(claim.claim_id);
+    if(recoveredRead&&existing.state==='TERMINAL')return existing.result;
+    throw new Error(`remote claim ${claim.claim_id} terminal publication failed; outcome unknown`,{cause:error});
+  }
+  return result;
+}

package/controller/deadbyte-controller.ps1

@@ -1432,7 +1432,12 @@ function Invoke-MachineSmoke($Cfg) {
     $url = Get-CurrentUrl $Cfg
     if (-not $url) { Fail 'public MCP URL unavailable' }
     Wait-PublicDnsReady $Cfg $url
-    Invoke-CoreGate $Cfg 'remote-mcp-machine-smoke-client.mjs' @($url)
+    $probeArgs = @($url)
+    if (-not [string]::IsNullOrWhiteSpace([string]$env:DEADBYTE_REMOTE_PROBE_MODE)) {
+        if ([string]$env:DEADBYTE_REMOTE_PROBE_MODE -notin @('default','desktop','host','full','revoked')) { Fail 'invalid remote enforcement probe mode' }
+        $probeArgs += [string]$env:DEADBYTE_REMOTE_PROBE_MODE
+    }
+    Invoke-CoreGate $Cfg 'remote-mcp-machine-smoke-client.mjs' $probeArgs
     Write-Host 'MACHINE IDENTITY LIVE GATE PASS: public status/list + SPKI identity + signed Ed25519 ping verified.'
 }
 

package/controller/deadbyte-process-policy.json

@@ -1,15 +1,15 @@
 {
   "schema": "deadbyte.process-policy.v1",
   "enabled": true,
-  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.36-r59\\controller\\runtime\\process-grant.json",
-  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.36-r59\\controller\\runtime\\process-state",
+  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\controller\\runtime\\process-grant.json",
+  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\controller\\runtime\\process-state",
   "native_host": {
-    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.36-r59\\bin\\deadbyte-process-host.exe",
+    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60\\bin\\deadbyte-process-host.exe",
     "sha256": "daf9cfb371bee88cafbf5597eaa507fec504dbe0b0ddd40d0c3c2e02817f49e4"
   },
   "roots": {
     "core": {
-      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.36-r59",
+      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.37-r60",
       "deny_paths": [
         "node_modules",
         "controller/runtime",

package/docs/R59-PROVENANCE.json

@@ -0,0 +1,87 @@
+{
+    "schema":  "deadbyte.provenance.v1",
+    "version":  "0.15.36",
+    "source_model":  "exact published and production-accepted 0.15.35 artifact -\u003e isolated R59 candidate -\u003e optional-plane degraded availability -\u003e runtime capability snapshot v3 -\u003e bounded Bridge Core reconciliation with no mutation replay -\u003e controller root preflight -\u003e fresh full regression/package/public frontdoor gates -\u003e operator-authorized publication with four-hour soak and clean-machine explicitly not completed -\u003e production activation/rollback/restore",
+    "signing":  "ed25519",
+    "parent_tarball_sha256":  "8259e30946d28dd138c1e2ce2f483fe1370d1658544f2adbfebafa4db8875bba",
+    "parent_activation_status":  "PRODUCTION_ACCEPTED_WITH_SIGNED_ROLLBACK_AND_RESTORE",
+    "parent_rollback_receipt_sha256":  "2f8aa5784fe6629c25af776b247b22b8e84d1a51c3420339ddd7a7445cf6ff9b",
+    "runtime_predecessor":  {
+                                "release_id":  "v0.15.35-1b5715b276facbc0",
+                                "manifest_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4",
+                                "generation_manifest_sha256":  "047e73b62d7b7819b84201a221a09b7e647cacf21f82101ebed4fbd7e23fc430"
+                            },
+    "source_predecessor_tarball_sha256":  "8259e30946d28dd138c1e2ce2f483fe1370d1658544f2adbfebafa4db8875bba",
+    "source_predecessor_manifest_file_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4",
+    "reproducibility":  "0.15.35 remains immutable production authority while R59 is developed in D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.36-r59. Publication is operator-authorized with four-hour soak and clean-machine truth preserved as NOT_COMPLETED; no stable/final claim is permitted.",
+    "public_surface_evidence":  {
+                                    "status":  "PASS",
+                                    "baseline_release":  "v0.15.35-1b5715b276facbc0",
+                                    "tool_count":  43,
+                                    "unchanged":  43,
+                                    "added":  0,
+                                    "removed":  0,
+                                    "schema_changed":  0,
+                                    "surface_sha256":  "8e98978b720633acb0c7d4d65c36a945243c47f6dbccfa64ab877329f2956fe3",
+                                    "evidence_receipt_sha256":  "2d3adcc33d010c4977974971222e6b13d613ff268097fff0eec0113e4f82f281"
+                                },
+    "fresh_full_regression":  {
+                                  "status":  "PENDING_R59_AFTER_RELEASE_IDENTITY_CUT",
+                                  "proof_path":  "proof/r59-full-regression-current.json"
+                              },
+    "inherited_r58_consolidation":  {
+                                        "frontend_status_vocabulary":  true,
+                                        "read_only_structured_status":  true,
+                                        "doctor_read_only_installation_runtime_transaction_checks":  true,
+                                        "stale_foreground_identity_hardening":  true,
+                                        "bridge_bundled_inside_release":  true,
+                                        "bridge_recursive_local_dependency_binding":  true,
+                                        "bridge_dynamic_relative_import_fail_closed":  true,
+                                        "bridge_path_escape_fail_closed":  true,
+                                        "isolated_controller_bridge_core_lifecycle":  "PASS",
+                                        "performance_acceptance":  "PASS_BOUNDED_PREPUBLISH",
+                                        "fresh_full_regression":  "PASS",
+                                        "package_acceptance":  "PENDING",
+                                        "registry_round_trip":  "PENDING",
+                                        "production_activation_rollback_restore":  "PENDING",
+                                        "stable_final_claim":  false,
+                                        "cross_plane_acceptance":  "PASS",
+                                        "public_surface_compatibility":  "PASS_43_TOOLS_NO_SCHEMA_DRIFT"
+                                    },
+    "r59_runtime_hardening":  {
+                                  "optional_plane_degradation":  true,
+                                  "stable_tool_registration_on_optional_failure":  true,
+                                  "capability_manifest_v3":  true,
+                                  "live_overlay_authority_ceiling":  true,
+                                  "bridge_bounded_reconciliation":  true,
+                                  "bridge_health_requires_fresh_child_catalog_capability_attestation":  true,
+                                  "mutation_unknown_outcome_no_replay":  true,
+                                  "read_only_retry_only_before_dispatch":  true,
+                                  "cancellation_aware_governor":  true,
+                                  "controller_policy_root_preflight":  true,
+                                  "public_surface_compatibility":  "PASS_43_TOOLS_NO_SCHEMA_DRIFT",
+                                  "frontdoor_signed_ping":  "PASS",
+                                  "four_hour_soak":  "NOT_COMPLETED",
+                                  "clean_machine":  "NOT_COMPLETED",
+                                  "stable_final_claim":  false
+                              },
+    "inherited_parent_performance_evidence":  {
+                                                  "summary_path":  "D:\\Projects\\deadbyte-mcp\\testing\\0.15.35\\performance-summary.json",
+                                                  "summary_sha256":  "4586d8462ce1ae643d255315d4b4febfdd3f731dd8728e4b37b5636b622b756c",
+                                                  "bridge_candidate_first_p95_reduction_pct":  63.632445348471286,
+                                                  "bridge_baseline_first_p95_reduction_pct":  43.06594367803213,
+                                                  "stdio_aggregate_p95_delta_pct":  1.984392678457768,
+                                                  "limitations_preserved":  true
+                                              },
+    "builder":  "deadbyte-r59-resilient-runtime",
+    "parent_release_id":  "v0.15.35-1b5715b276facbc0",
+    "parent_manifest_sha256":  "1b5715b276facbc00f8e341a554472cb4829e5af60e221c357c41b66053af9d4",
+    "parent_generation_manifest_sha256":  "047e73b62d7b7819b84201a221a09b7e647cacf21f82101ebed4fbd7e23fc430",
+    "source_predecessor_version":  "0.15.35",
+    "operator_override":  {
+                              "four_hour_soak":  "WAIVED_BY_OPERATOR",
+                              "clean_machine":  "WAIVED_BY_OPERATOR",
+                              "reason":  "Operator explicitly requested immediate deployment without further testing.",
+                              "stable_final_claim":  false
+                          }
+}