deadbyte-mcp 0.11.2 → 0.12.0

package/src/remote-live-log.mjs

@@ -1,5 +1,6 @@
 import { canonicalJson } from './canonical-json.mjs';
 import { sanitizeAuditArgs } from './tool-audit.mjs';
+import { remoteDisplayText, REMOTE_DISPLAY_MODES } from './remote-console.mjs';
 
 const SAFE_ARG_KEYS=Object.freeze(['root_id','path','pattern','command_id','profile_id','session_id','goal_id','task_id','step_id','mode']);
 const LIFECYCLE=Object.freeze({
@@ -11,6 +12,15 @@ const LIFECYCLE=Object.freeze({
   ready:'✅ [READY] DEADBYTE MCP online',
   cleanup:'🔐 [AUTH] Revoking session authority...'
 });
+const LIFECYCLE_ASCII=Object.freeze({
+  device_start:'[DEVICE] Starting DEADBYTE MCP...',
+  bridge_connected:'[BRIDGE] Local bridge connected',
+  cloud_connected:'[CLOUD] Remote MCP connected',
+  session_new:'[SESSION] New foreground session',
+  session_restored:'[SESSION] Previous result stream replayed',
+  ready:'[READY] DEADBYTE MCP online',
+  cleanup:'[AUTH] Revoking session authority...'
+});
 
 function safeAtom(value){
   if(typeof value==='string'){
@@ -34,22 +44,99 @@ function summarizeArgs(args){
 }
 
 const TOOL_COLUMN_WIDTH=32;
+const DISPLAY_UTC_OFFSET_MINUTES=7*60;
+const DISPLAY_UTC_OFFSET_LABEL='+07:00';
+const HEARTBEAT_TOOLS=new Set(['machine_ping','machine_status','machine_system_status','machine_list']);
+const TOOL_ICONS=Object.freeze({read:'📖',write:'📝',edit:'✏️',run:'🏃',verify:'🧾',search:'🔍',heartbeat:'📡',desktop:'🖥️',autonomous:'🤖',process:'⚙️',generic:'•'});
+const TOOL_ICONS_ASCII=Object.freeze({read:'R',write:'W',edit:'E',run:'>',verify:'V',search:'S',heartbeat:'H',desktop:'D',autonomous:'A',process:'P',generic:'*'});
+const START_VISIBLE_PATTERNS=[/(?:^|_)file_write$/,/text_replace$/,/symbol_replace$/,/native_diff_(?:apply|preview)$/,
+  /(?:command|benchmark)_run$/,/task_run$/,/goal_run$/,/goal_submit$/,/goal_approve$/,/process_session_(?:start|action|terminate)$/,/^desktop_action$/];
 
-function eventTimestamp(event,clock){
-  for(const value of [event?.created_at_utc,event?.observed_at_utc]){
+export function truncateUtf8(value,maxBytes,{ellipsis='…'}={}){
+  if(typeof value!=='string'||!Number.isInteger(maxBytes)||maxBytes<1) return '';
+  const bytes=new TextEncoder().encode(value);
+  if(bytes.length<=maxBytes) return value;
+  const suffix=new TextEncoder().encode(ellipsis);
+  const budget=Math.max(0,maxBytes-suffix.length);
+  let end=Math.min(budget,bytes.length);
+  while(end>0&&(bytes[end]&0xc0)===0x80) end--;
+  return new TextDecoder('utf-8',{fatal:false}).decode(bytes.subarray(0,end))+(suffix.length<=maxBytes?ellipsis:'');
+}
+function clipped(value,max=72){
+  if(typeof value!=='string') return '';
+  const one=value.replace(/[\r\n\t]+/g,' ').replace(/\s{2,}/g,' ').trim();
+  return truncateUtf8(one,max);
+}
+function shortValue(value,max=12){
+  if(typeof value!=='string'||!value) return '';
+  return value.length<=max?value:value.slice(0,max)+'…';
+}
+function payloadByteCount(value){
+  return value&&typeof value==='object'&&value.redacted===true&&Number.isFinite(Number(value.byte_count))?Number(value.byte_count):null;
+}
+function rootPath(args){
+  const root=safeAtom(args?.root_id);const p=safeAtom(args?.path);
+  if(root&&p) return root+':'+p;
+  return root||p||'';
+}
+export function summarizeLiveToolArgs(tool,rawArgs){
+  const args=sanitizeAuditArgs(rawArgs??{});const where=rootPath(args);
+  if(/(?:file_read|files_read)$/.test(tool)) return where;
+  if(/file_write$/.test(tool)){const bytes=payloadByteCount(args.content);return [where,bytes!==null?'('+bytes+'B)':''].filter(Boolean).join(' ');}
+  if(/text_replace$|symbol_replace$/.test(tool)){const bytes=payloadByteCount(args.new_string);return [where,bytes!==null?'('+bytes+'B new)':''].filter(Boolean).join(' ');}
+  if(/coding_tree$/.test(tool)) return where;
+  if(/coding_(?:search|inspect)$/.test(tool)) return [where,args.pattern?'\"'+clipped(String(args.pattern),36)+'\"':'',args.op?String(args.op):''].filter(Boolean).join(' ');
+  if(/(?:command|benchmark)_run$/.test(tool)) return [safeAtom(args.root_id),safeAtom(args.command_id),safeAtom(args.script_path)].filter(Boolean).join(' ');
+  if(/^machine_(?:ping|status|system_status|list)$/.test(tool)) return safeAtom(args.nonce)?'nonce='+shortValue(String(args.nonce),24):'';
+  if(/^process_session/.test(tool)) return [safeAtom(args.profile_id),shortValue(safeAtom(args.session_id)||'',12),safeAtom(args.op)].filter(Boolean).join(' ');
+  if(/^desktop_/.test(tool)) return [shortValue(safeAtom(args.frame_id)||'',10),shortValue(safeAtom(args.target_id)||'',10),safeAtom(args.op)].filter(Boolean).join(' ');
+  if(/^autonomous_/.test(tool)) return [shortValue(safeAtom(args.goal_id)||'',12),safeAtom(args.step_id)].filter(Boolean).join(' ');
+  return summarizeArgs(args).trim();
+}
+function categoryForTool(tool){
+  if(/^desktop_/.test(tool)) return 'desktop';
+  if(/^autonomous_/.test(tool)) return 'autonomous';
+  if(HEARTBEAT_TOOLS.has(tool)) return 'heartbeat';
+  if(/(?:receipt_verify|evidence_verify|goal_verify|task_verify|audit|release_gate|native_diff_verify)/.test(tool)) return 'verify';
+  if(/(?:search|inspect|symbol_(?:definition|references|implementations|outline|diagnostics)|_stat$|_tree$)/.test(tool)) return 'search';
+  if(/(?:file_read|files_read|machine_fs_read|process_session_read)/.test(tool)) return 'read';
+  if(/(?:file_write|machine_fs_write|mkdir|move|delete)/.test(tool)) return 'write';
+  if(/(?:replace|edit_exact|native_diff_apply)/.test(tool)) return 'edit';
+  if(/(?:command_run|benchmark_run|task_run|goal_run|process_session_(?:start|action|terminate))/.test(tool)) return 'run';
+  if(/^process_/.test(tool)) return 'process';
+  return 'generic';
+}
+function iconForTool(tool,displayMode='unicode'){
+  const icons=displayMode==='ascii'?TOOL_ICONS_ASCII:TOOL_ICONS;
+  return icons[categoryForTool(tool)]??icons.generic;
+}
+function visibleStart(tool){return START_VISIBLE_PATTERNS.some(pattern=>pattern.test(tool));}
+
+function displayTimestamp(ms){
+  const shifted=new Date(ms+DISPLAY_UTC_OFFSET_MINUTES*60*1000).toISOString();
+  return `${shifted.slice(0,-1)}${DISPLAY_UTC_OFFSET_LABEL}`;
+}
+
+function eventMs(event,clock){
+  for(const value of [event?.ts,event?.created_at_utc,event?.observed_at_utc]){
     const parsed=Date.parse(value);
-    if(typeof value==='string'&&Number.isFinite(parsed)) return new Date(parsed).toISOString();
+    if(typeof value==='string'&&Number.isFinite(parsed)) return parsed;
   }
   const value=Number(clock());
-  return new Date(Number.isFinite(value)?value:Date.now()).toISOString();
+  return Number.isFinite(value)?value:Date.now();
+}
+function eventTimestamp(event,clock){return displayTimestamp(eventMs(event,clock));}
+function displayClock(ms){
+  const shifted=new Date(ms+DISPLAY_UTC_OFFSET_MINUTES*60*1000).toISOString();
+  return shifted.slice(11,23);
 }
 
-export function formatRemoteToolCall(event,{clock=()=>Date.now()}={}){
+export function formatRemoteToolCall(event,{clock=()=>Date.now(),displayMode='unicode'}={}){
   if(!event||typeof event!=='object'||Array.isArray(event)||event.event_type!=='tool.request'||
      typeof event.tool!=='string'||!event.tool) return null;
   if(typeof clock!=='function') throw new Error('remote tool-call clock must be a function');
   const args=sanitizeAuditArgs(event.args??{});
-  return `${eventTimestamp(event,clock)} | ${event.tool.padEnd(TOOL_COLUMN_WIDTH)} | Arguments: ${canonicalJson(args)}`;
+  return remoteDisplayText(`${eventTimestamp(event,clock)} | ${event.tool.padEnd(TOOL_COLUMN_WIDTH)} | Arguments: ${canonicalJson(args)}`,displayMode);
 }
 
 function formatDuration(ms){
@@ -70,9 +157,10 @@ export function formatCompactAuditEvent(event){
   return null;
 }
 
-export function formatRemoteLifecycle(kind){
+export function formatRemoteLifecycle(kind,{displayMode='unicode'}={}){
   if(typeof kind!=='string'||!Object.hasOwn(LIFECYCLE,kind)) throw new Error(`unknown remote lifecycle '${String(kind)}'`);
-  return LIFECYCLE[kind];
+  if(!REMOTE_DISPLAY_MODES.includes(displayMode)) throw new Error('remote display mode invalid');
+  return displayMode==='ascii'?LIFECYCLE_ASCII[kind]:LIFECYCLE[kind];
 }
 
 export function createLiveActivityTracker(){
@@ -102,56 +190,138 @@ function shortSpanId(requestId){
   return typeof requestId==='string'&&requestId.length?requestId.slice(0,8):'????????';
 }
 
-export function createLiveTimelineTracker({clock=()=>Date.now()}={}){
+export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode'}={}){
   if(typeof clock!=='function') throw new Error('live timeline clock must be a function');
+  if(!REMOTE_DISPLAY_MODES.includes(displayMode)) throw new Error('remote display mode invalid');
+  if(!Number.isInteger(heartbeatBurstLimit)||heartbeatBurstLimit<2||heartbeatBurstLimit>100) throw new Error('heartbeatBurstLimit invalid');
+  if(!Number.isInteger(heartbeatWindowMs)||heartbeatWindowMs<250||heartbeatWindowMs>60000) throw new Error('heartbeatWindowMs invalid');
   const pending=new Map();
   const completed=new Set();
-  return Object.freeze({
-    observe(event){
-      if(!event||typeof event!=='object'||Array.isArray(event)) return null;
-      const requestId=typeof event.request_id==='string'&&event.request_id?event.request_id:null;
-      const tool=typeof event.tool==='string'&&event.tool?event.tool:null;
-      if(event.event_type==='tool.request'&&requestId&&tool){
-        if(pending.has(requestId)||completed.has(requestId)) return null;
-        pending.set(requestId,{request_id:requestId,tool,started_at_ms:clock()});
-        return formatRemoteToolCall(event,{clock});
-      }
-      if(event.event_type==='tool.result'&&requestId&&tool){
-        if(completed.has(requestId)) return null;
-        const span=pending.get(requestId)??null;
-        pending.delete(requestId);completed.add(requestId);
-        const error=event.outcome?.is_error===true;
-        const duration=Number.isFinite(Number(event.outcome?.duration_ms))
-          ? formatDuration(event.outcome.duration_ms)
-          : span?formatDuration(Math.max(0,clock()-span.started_at_ms)):'';
-        const marker=span?(error?'✗':'✓'):'↩';
-        const status=error?'ERR':'OK ';
-        const suffix=span?'':' (request before live window)';
-        return `${marker} [${shortSpanId(requestId)}] ${status} ${tool}${duration?` ${duration}`:''}${suffix}`;
-      }
+  const toolCounts=new Map();
+  let resultCount=0,errorCount=0,totalDurationMs=0,burst=null,foldedHeartbeatLines=0;
+
+  function eventPrefix(event,sequence){
+    const seq=Number.isSafeInteger(sequence)&&sequence>0?'#'+sequence+'  ':'';
+    return iconForTool(event.tool,displayMode)+'  '+displayClock(eventMs(event,clock))+'  '+seq+'['+shortSpanId(event.request_id)+']  '+event.tool;
+  }
+  function resultLine(event,span,sequence){
+    const error=event.outcome?.is_error===true;
+    const unknown=event.outcome?.side_effect_state==='unknown';
+    const duration=Number.isFinite(Number(event.outcome?.duration_ms))
+      ?formatDuration(event.outcome.duration_ms)
+      :span?formatDuration(Math.max(0,clock()-span.started_at_ms)):'';
+    const summary=span?.summary||'';
+    const rawReason=typeof event.outcome?.reason==='string'&&event.outcome.reason?event.outcome.reason:
+      (unknown&&typeof event.outcome?.recovery?.reason==='string'?event.outcome.recovery.reason:'');
+    const reason=rawReason?clipped(rawReason,180):(unknown?'terminal result unavailable; inspect state before retry':'');
+    const marker=unknown?'OUTCOME_UNKNOWN':error?(displayMode==='ascii'?'ERR':'✗'):(displayMode==='ascii'?'OK':'✓');
+    return remoteDisplayText(eventPrefix(event,sequence)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+'  '+marker+(reason?' — '+reason:''),displayMode);
+  }
+  function burstLine(value){
+    if(!value) return null;
+    const avg=value.count?value.total_ms/value.count:0;
+    const seq=Number.isSafeInteger(value.last_sequence)&&value.last_sequence>0?'#'+value.last_sequence+'  ':'';
+    const startClock=displayClock(value.first_ms);
+    const endClock=displayClock(value.last_ms);
+    const range=value.first_ms===value.last_ms?endClock:startClock.slice(0,8)+'–'+endClock.slice(0,8);
+    if(value.count>1) foldedHeartbeatLines+=value.count-1;
+    const marker=displayMode==='ascii'?'OK':'✓';
+    return remoteDisplayText(iconForTool(value.tool,displayMode)+'  '+range+'  '+seq+value.tool+' ×'+value.count+'  avg '+formatDuration(avg)+'  '+marker,displayMode);
+  }
+  function flushBurst(){
+    const line=burstLine(burst);
+    burst=null;
+    return line;
+  }
+  function addStats(event){
+    resultCount++;
+    toolCounts.set(event.tool,(toolCounts.get(event.tool)??0)+1);
+    const duration=Number(event.outcome?.duration_ms);
+    if(Number.isFinite(duration)&&duration>=0) totalDurationMs+=duration;
+    if(event.outcome?.is_error===true) errorCount++;
+  }
+  function observe(event,{sequence=null}={}){
+    if(!event||typeof event!=='object'||Array.isArray(event)) return null;
+    const requestId=typeof event.request_id==='string'&&event.request_id?event.request_id:null;
+    const tool=typeof event.tool==='string'&&event.tool?event.tool:null;
+    if(event.event_type==='tool.request'&&requestId&&tool){
+      if(pending.has(requestId)||completed.has(requestId)) return null;
+      const summary=summarizeLiveToolArgs(tool,event.args??{});
+      pending.set(requestId,{request_id:requestId,tool,summary,started_at_ms:clock()});
+      if(verbose) return formatRemoteToolCall(event,{clock,displayMode});
+      if(visibleStart(tool)) return eventPrefix(event,sequence)+(summary?'  '+summary:'')+'  …';
       return null;
-    },
-    pending(){return [...pending.values()].map(({request_id,tool})=>({request_id,tool}));},
-    reconcileInterrupted(reason='session_end'){
-      const suffix=reason==='recovery'?'recovery ended before terminal result':
-        reason==='session_end'?'session ended before terminal result':'stream ended before terminal result';
-      const lines=[...pending.values()].map(item=>`⚠ [${shortSpanId(item.request_id)}] INTERRUPTED ${item.tool} — ${suffix}`);
-      pending.clear();
-      return lines;
     }
+    if(event.event_type==='tool.result'&&requestId&&tool){
+      if(completed.has(requestId)) return null;
+      const span=pending.get(requestId)??null;
+      pending.delete(requestId);
+      completed.add(requestId);
+      addStats(event);
+      const error=event.outcome?.is_error===true;
+      const nowMs=eventMs(event,clock);
+      if(HEARTBEAT_TOOLS.has(tool)&&!error){
+        const duration=Number(event.outcome?.duration_ms);
+        if(burst&&burst.tool===tool&&nowMs-burst.last_ms<=heartbeatWindowMs){
+          burst.count++;
+          burst.last_ms=nowMs;
+          burst.last_sequence=sequence;
+          if(Number.isFinite(duration)&&duration>=0) burst.total_ms+=duration;
+        }else{
+          const prior=flushBurst();
+          burst={tool,count:1,total_ms:Number.isFinite(duration)&&duration>=0?duration:0,
+            first_ms:nowMs,last_ms:nowMs,first_sequence:sequence,last_sequence:sequence};
+          return prior;
+        }
+        if(burst.count>=heartbeatBurstLimit) return flushBurst();
+        return null;
+      }
+      const lines=[];
+      const prior=flushBurst();
+      if(prior) lines.push(prior);
+      lines.push(resultLine(event,span,sequence));
+      return lines.length===1?lines[0]:lines;
+    }
+    return null;
+  }
+  function reconcileInterrupted(reason='session_end'){
+    const suffix=reason==='recovery'?'recovery ended before terminal result':
+      reason==='session_end'?'session ended before terminal result':'stream ended before terminal result';
+    const lines=[];
+    const folded=flushBurst();
+    if(folded) lines.push(folded);
+    for(const item of pending.values()) lines.push(remoteDisplayText((displayMode==='ascii'?'[WARN]':'⚠')+' ['+shortSpanId(item.request_id)+'] OUTCOME_UNKNOWN '+item.tool+' — '+suffix+'; inspect state before retry',displayMode));
+    pending.clear();
+    return lines;
+  }
+  function summary(){
+    const top=[...toolCounts.entries()].sort((a,b)=>b[1]-a[1]||a[0].localeCompare(b[0])).slice(0,3)
+      .map(([tool,count])=>tool+'×'+count).join(', ');
+    return remoteDisplayText((displayMode==='ascii'?'[SUMMARY]':'📊 [SUMMARY]')+' '+resultCount+' calls | '+errorCount+' error'+(errorCount===1?'':'s')+
+      ' | tool time '+(formatDuration(totalDurationMs)||'0ms')+
+      (foldedHeartbeatLines?' | folded '+foldedHeartbeatLines+' heartbeat lines':'')+
+      (top?' | top: '+top:''),displayMode);
+  }
+  return Object.freeze({
+    observe,
+    pending(){return [...pending.values()].map(({request_id,tool})=>({request_id,tool}));},
+    reconcileInterrupted,
+    summary
   });
 }
 
-
-export function formatRuntimeDiagnosticLine(file,line){
+export function formatRuntimeDiagnosticLine(file,line,{verbose=false,displayMode='unicode'}={}){
   if(typeof file!=='string'||typeof line!=='string'||!line) return null;
   const label=file.split(/[\\/]/).at(-1).replace(/\.log$/i,'').toUpperCase();
   const input=line.match(/\[TOOL IN \]\s+\S+\s+#\d+\s+([A-Za-z0-9_.-]+)/);
-  if(input) return `[${label}] IN  ${input[1]}`;
+  if(input) return verbose?remoteDisplayText('['+label+'.DEBUG] IN  '+input[1],displayMode):null;
   const output=line.match(/\[TOOL OUT\]\s+\S+\s+#\d+\s+([A-Za-z0-9_.-]+)/);
   if(output){
-    if(/"is_error"\s*:\s*true/.test(line)) return `[${label}] ERR ${output[1]}`;
-    return `[${label}] OUT ${output[1]}`;
+    if(!verbose) return null;
+    if(/"is_error"\s*:\s*true/.test(line)) return remoteDisplayText('['+label+'.DEBUG] ERR '+output[1],displayMode);
+    return remoteDisplayText('['+label+'.DEBUG] OUT '+output[1],displayMode);
   }
+  const compact=line.match(/^\[TOOL\]\s+(\S+)\s+#(\d+)\s+(✓|✗|OK|ERR)\s+([A-Za-z0-9_.-]+)\s+([^\s]+)(?:\s+—\s+(.+))?$/u);
+  if(compact) return verbose?remoteDisplayText('['+label+'.DEBUG] #'+compact[2]+' '+compact[3]+' '+compact[4]+' '+compact[5]+(compact[6]?' — '+compact[6]:''),displayMode):null;
   return null;
 }

package/src/remote-mcp-desktop-r40-smoke-client.mjs

@@ -0,0 +1,70 @@
+import { randomBytes } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client,StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { loadDesktopPolicy } from './desktop-policy-r40.mjs';
+import { verifyDesktopReceiptObject } from './desktop-runtime-r40.mjs';
+import { loadPublicVerifyKey } from './trust.mjs';
+
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+function gateway(result,label){
+  if(result.isError)throw new Error(label+' returned error: '+JSON.stringify(result.structuredContent??result.content));
+  const value=result.structuredContent;
+  if(!value||value.status!=='ok'||!value.result)throw new Error(label+' malformed');
+  return value.result;
+}
+function predispatchForegroundChanged(result){
+  if(result?.isError!==true)return false;
+  const value=result.structuredContent;
+  return value?.status==='denied'&&value?.op==='action'&&value?.error==='desktop foreground window changed before action';
+}
+async function verify(policy,key,id,sha,kind){
+  const receipt=JSON.parse(await readFile(path.join(policy.evidence_dir,id+'.json'),'utf8'));
+  const proof=verifyDesktopReceiptObject(receipt,{policySha256:policy.policy_sha256,publicKey:key.publicKey,keyId:key.keyId});
+  if(!proof.ok||proof.receipt_sha256!==sha||proof.kind!==kind)throw new Error('desktop smoke receipt mismatch '+kind);
+}
+export async function runR40DesktopGuardedSmoke(endpointText){
+  const endpoint=new URL(endpointText);if(endpoint.protocol!=='https:')throw new Error('R40 Desktop smoke requires HTTPS');
+  const pointer=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  const policy=await loadDesktopPolicy(path.join(pointer.generation_root,'desktop-policy.json'));
+  const key=await loadPublicVerifyKey(path.join(stateRoot,'trust','ed25519-public.pem'));
+  const client=new Client({name:'deadbyte-r40-desktop-guarded-smoke',version:'0.12.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StreamableHTTPClientTransport(endpoint);
+  try{
+    await client.connect(transport);
+    const status=gateway(await client.callTool({name:'desktop_control',arguments:{op:'status'}}),'desktop status');
+    if(status.armed!==true||!status.action_kinds?.includes('key_chord'))throw new Error('Desktop smoke requires separately armed key_chord authority');
+    const maxPredispatchAttempts=3;
+    let action=null;
+    let observationReceiptsVerified=0;
+    let predispatchRetryCount=0;
+    for(let attempt=1;attempt<=maxPredispatchAttempts;attempt+=1){
+      const observed=gateway(await client.callTool({name:'desktop_control',arguments:{op:'observe',preview:false}}),'desktop observe');
+      await verify(policy,key,observed.receipt_id,observed.receipt_sha256,'desktop_observation');
+      observationReceiptsVerified+=1;
+      const actionResult=await client.callTool({name:'desktop_control',arguments:{
+        op:'action',intent_id:randomBytes(32).toString('hex'),kind:'key_chord',expected_frame_id:observed.frame.frame_id,
+        target_id:null,point:null,scroll_delta:null,key_chord:['SHIFT'],text:null
+      }});
+      if(predispatchForegroundChanged(actionResult)){
+        if(attempt===maxPredispatchAttempts)throw new Error('Desktop guarded smoke foreground remained unstable before dispatch');
+        predispatchRetryCount+=1;
+        continue;
+      }
+      action=gateway(actionResult,'desktop key_chord');
+      break;
+    }
+    if(!action||action.injected!==true||action.side_effect_state!=='confirmed_injected'||action.action_summary?.kind!=='key_chord')throw new Error('Desktop guarded smoke input not confirmed');
+    await verify(policy,key,action.started_receipt_id,action.started_receipt_sha256,'desktop_action_started');
+    await verify(policy,key,action.post_receipt_id,action.post_receipt_sha256,'desktop_post_observation');
+    await verify(policy,key,action.receipt_id,action.receipt_sha256,'desktop_action_completed');
+    return {status:'passed',kind:'key_chord',keys:['SHIFT'],native_injected:true,replay_performed:false,
+      predispatch_retry_count:predispatchRetryCount,observation_receipts_verified:observationReceiptsVerified,
+      observation_receipt_verified:true,action_receipts_verified:3,action_chain_sha256:action.action_chain?.chain_sha256??null,
+      effect_id:action.effect_id,receipt_id:action.receipt_id,receipt_sha256:action.receipt_sha256};
+  }finally{await client.close().catch(()=>{});}
+}
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){const endpoint=process.argv[2];if(!endpoint)throw new Error('usage: node src/remote-mcp-desktop-r40-smoke-client.mjs https://host/mcp/path');
+runR40DesktopGuardedSmoke(endpoint).then(v=>console.log(JSON.stringify(v,null,2))).catch(e=>{console.error(e instanceof Error?e.stack:String(e));process.exitCode=1;});}

package/src/remote-mcp-r40-parity-client.mjs

@@ -0,0 +1,200 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { R34_EXPECTED_TOOLS } from './remote-mcp-r34-parity-client.mjs';
+import { loadCodingPolicy } from './coding-plane.mjs';
+import { verifyMachineFsReceiptFile } from './machine-fs.mjs';
+import { verifyObservationReceiptFile } from './observation-runtime.mjs';
+import { loadDesktopPolicy } from './desktop-policy-r40.mjs';
+import { verifyDesktopReceiptObject } from './desktop-runtime-r40.mjs';
+import { loadPublicVerifyKey } from './trust.mjs';
+
+export const R40_EXPECTED_TOOLS=Object.freeze([...new Set([
+  ...R34_EXPECTED_TOOLS,
+  'coding_symbol_diagnostics','coding_symbol_implementations','coding_symbol_rename_preview',
+  'desktop_status','desktop_observe','desktop_target','desktop_action'
+])].sort());
+if(R40_EXPECTED_TOOLS.length !== 80) throw new Error(`R40 full catalog identity mismatch: ${R40_EXPECTED_TOOLS.length}`);
+export const R40_COMPACT_GATEWAYS=Object.freeze(['capability_manifest','coding_inspect','machine_fs','machine_observe','process_session','desktop_control'].sort());
+export const R40_COMPACT_TOOL_LIMIT=42;
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const verifyKeyPath=path.join(stateRoot,'trust','ed25519-public.pem');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+
+function structured(result,label){
+  if(result.isError) throw new Error(`${label} returned error: ${JSON.stringify(result.structuredContent??result.content)}`);
+  if(!result.structuredContent||typeof result.structuredContent!=='object') throw new Error(`${label} missing structured output`);
+  return result.structuredContent;
+}
+function gateway(result,label){
+  const value=structured(result,label);
+  if(value.status!=='ok'||!value.result||typeof value.result!=='object') throw new Error(`${label} gateway status=${String(value.status)} error=${String(value.error??'')}`);
+  return value.result;
+}
+async function fileSha(relative){return sha256(await readFile(path.join(repoRoot,...relative.split('/'))));}
+async function verifyMachineReceipt(policy,receiptId,operation){
+  const checked=await verifyMachineFsReceiptFile({policy,verifyKeyPath,receiptId});
+  if(!checked.ok||checked.signature_valid!==true||checked.operation!==operation) throw new Error(`machine-fs receipt verification failed for ${operation}`);
+  return checked;
+}
+async function verifyObservationReceipt(policy,receiptId){
+  const checked=await verifyObservationReceiptFile({policy,verifyKeyPath,receiptId});
+  if(!checked.ok||checked.signature_valid!==true) throw new Error('observation receipt verification failed');
+  return checked;
+}
+async function verifyDesktopReceipt(policy,verifyKey,receiptId,receiptSha256,kind){
+  const file=path.join(policy.evidence_dir,`${receiptId}.json`);
+  const receipt=JSON.parse(await readFile(file,'utf8'));
+  const checked=verifyDesktopReceiptObject(receipt,{policySha256:policy.policy_sha256,publicKey:verifyKey.publicKey,keyId:verifyKey.keyId});
+  if(!checked.ok||checked.receipt_sha256!==receiptSha256||checked.kind!==kind) throw new Error(`desktop receipt verification failed for ${kind}`);
+  return checked;
+}
+async function waitSearch(client,searchId){
+  for(let attempt=0;attempt<200;attempt+=1){
+    const status=gateway(await client.callTool({name:'machine_observe',arguments:{op:'search_status',search_id:searchId}}),'search_status');
+    if(['completed','cancelled','failed'].includes(status.state)) return status;
+    await sleep(25);
+  }
+  throw new Error('R40 compact search timeout');
+}
+async function waitProcessOutput(client,sessionId){
+  for(let attempt=0;attempt<100;attempt+=1){
+    const page=gateway(await client.callTool({name:'process_session',arguments:{op:'read',session_id:sessionId,offset:0,max_bytes:65536}}),'process read');
+    if(Buffer.from(page.data_base64??'','base64').toString('utf8').includes('DEADBYTE_ACTION_PING')) return page;
+    await sleep(50);
+  }
+  throw new Error('R40 compact process output timeout');
+}
+
+export async function runR40CompactParity(endpointText){
+  const endpoint=new URL(endpointText);
+  if(endpoint.protocol!=='https:') throw new Error('R40 compact parity requires HTTPS');
+  const pointer=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  const policy=await loadCodingPolicy(path.join(pointer.generation_root,'coding-policy.json'));
+  const desktopPolicy=await loadDesktopPolicy(path.join(pointer.generation_root,'desktop-policy.json'));
+  const desktopVerifyKey=await loadPublicVerifyKey(verifyKeyPath);
+  const client=new Client({name:'deadbyte-r40-compact-parity',version:'0.12.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StreamableHTTPClientTransport(endpoint);
+  const tag=randomBytes(8).toString('hex');
+  const scratchRoot='parity_scratch';
+  const target=`.deadbyte-r40-parity-${tag}.txt`;
+  let processSession=null,targetPresent=false;
+  const machineReceipts=[],observationReceipts=[];
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(tool=>tool.name).sort();
+    if(names.length>R40_COMPACT_TOOL_LIMIT) throw new Error(`R40 compact catalog exceeds ${R40_COMPACT_TOOL_LIMIT}: ${names.length}`);
+    if(names.length!==R40_COMPACT_TOOL_LIMIT) throw new Error(`R40 compact catalog must be exactly ${R40_COMPACT_TOOL_LIMIT}, got ${names.length}`);
+    for(const name of R40_COMPACT_GATEWAYS) if(!names.includes(name)) throw new Error(`R40 compact gateway missing ${name}`);
+    for(const tool of listed.tools){
+      if(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false||!tool.outputSchema?.properties) throw new Error(`tool ${tool.name} missing strict output schema`);
+    }
+    const manifest=gateway(await client.callTool({name:'capability_manifest',arguments:{}}),'capability_manifest');
+    if(manifest.schema!=='deadbyte.capability-manifest.v2'||manifest.profile!=='compact'||!Array.isArray(manifest.capabilities)||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R40 compact capability manifest malformed');
+    if(manifest.tool_count!==names.length||JSON.stringify(manifest.tool_catalog)!==JSON.stringify(names)||
+      manifest.catalog_sha256!==sha256(Buffer.from(JSON.stringify(names),'utf8'))) throw new Error('R40 compact manifest catalog binding mismatch');
+    const required=manifest.capabilities.filter(item=>item?.production===true&&item?.host_only!==true);
+    for(const item of required){
+      if(typeof item.compact_tool!=='string'||!names.includes(item.compact_tool)) throw new Error(`compact capability route missing: ${String(item.id)}`);
+    }
+    const coding=structured(await client.callTool({name:'coding_session_status',arguments:{}}),'coding_session_status');
+    const autonomous=structured(await client.callTool({name:'autonomous_session_status',arguments:{}}),'autonomous_session_status');
+    if(coding.armed!==true||autonomous.coding_armed!==true||autonomous.autonomous_armed!==true) throw new Error('R40 compact parity requires coding and autonomous standing grants');
+    const desktopStatus=gateway(await client.callTool({name:'desktop_control',arguments:{op:'status'}}),'desktop status');
+    if(desktopStatus.configured!==true||desktopStatus.armed!==false) throw new Error('R40 compact parity requires Desktop configured and DISARMED');
+    const desktopObserved=gateway(await client.callTool({name:'desktop_control',arguments:{op:'observe',preview:false}}),'desktop observe');
+    await verifyDesktopReceipt(desktopPolicy,desktopVerifyKey,desktopObserved.receipt_id,desktopObserved.receipt_sha256,'desktop_observation');
+    const desktopTarget=gateway(await client.callTool({name:'desktop_control',arguments:{op:'target',frame_id:desktopObserved.frame.frame_id,uia_query:{kind:'root',value:'',max_results:1,ordinal:0}}}),'desktop target');
+    await verifyDesktopReceipt(desktopPolicy,desktopVerifyKey,desktopTarget.grounding.receipt_id,desktopTarget.grounding.receipt_sha256,'desktop_grounding');
+    if(desktopTarget.target?.source!=='uia') throw new Error('R40 compact UIA root grounding missing');
+    const tree=structured(await client.callTool({name:'coding_tree',arguments:{root_id:'core',path:'workspaces/demo',max_depth:2,max_entries:128}}),'coding_tree');
+    if(tree.status!=='ok'||!Array.isArray(tree.entries)) throw new Error('coding_tree malformed');
+    const stat=gateway(await client.callTool({name:'coding_inspect',arguments:{op:'stat',root_id:'core',path:'package.json',hash:true}}),'coding stat');
+    if(stat.type!=='file'||!/^[0-9a-f]{64}$/.test(String(stat.sha256??''))||!/^[0-9a-f]{64}$/.test(String(stat.observation_sha256??''))) throw new Error('coding stat identity missing');
+    const search=gateway(await client.callTool({name:'coding_inspect',arguments:{op:'search',root_id:'core',path:'src',pattern:'R36_CAPABILITY_LEDGER',target:'content',mode:'literal',case_sensitive:true,max_results:20,max_file_bytes:262144,max_scan_bytes:4194304,page_size:20,cursor:null}}),'coding search');
+    if(!Array.isArray(search.matches)||search.matches.length<1) throw new Error('coding search returned no canonical ledger match');
+
+    const buildScript='scripts/autonomous-build.ps1';
+    const testScript='scripts/release-parity-tests-r40.ps1';
+    const build=structured(await client.callTool({name:'coding_command_run',arguments:{root_id:'core',command_id:'powershell_script',script_path:buildScript,script_sha256:await fileSha(buildScript),args:[],cwd:'.',timeout_ms:120000}},{timeout:180000,maxTotalTimeout:180000}),'coding build');
+    if(build.status!=='passed'||build.exit_code!==0) throw new Error('R40 coding build failed');
+    const buildVerify=structured(await client.callTool({name:'coding_receipt_verify',arguments:{receipt_id:build.receipt_id}}),'coding build receipt');
+    if(buildVerify.ok!==true||buildVerify.signature_valid!==true) throw new Error('R40 coding build receipt invalid');
+    const tests=structured(await client.callTool({name:'coding_command_run',arguments:{root_id:'core',command_id:'powershell_script',script_path:testScript,script_sha256:await fileSha(testScript),args:[],cwd:'.',timeout_ms:300000}},{timeout:360000,maxTotalTimeout:360000}),'coding tests');
+    if(tests.status!=='passed'||tests.exit_code!==0) throw new Error('R40 coding tests failed');
+    const testVerify=structured(await client.callTool({name:'coding_receipt_verify',arguments:{receipt_id:tests.receipt_id}}),'coding test receipt');
+    if(testVerify.ok!==true||testVerify.signature_valid!==true) throw new Error('R40 coding test receipt invalid');
+
+    const initial=`needle-${tag}\n`;
+    const write=gateway(await client.callTool({name:'machine_fs',arguments:{op:'write',root_id:scratchRoot,path:target,content:initial,encoding:'utf8',expected_sha256:'absent'}}),'machine_fs write');
+    targetPresent=true;machineReceipts.push(write.receipt_id);await verifyMachineReceipt(policy,write.receipt_id,'machine_fs_write');
+    const bounded=gateway(await client.callTool({name:'machine_fs',arguments:{op:'read',root_id:scratchRoot,path:target,offset:0,max_bytes:128,hash_file:true}}),'machine_fs read');
+    if(Buffer.from(bounded.data_base64,'base64').toString('utf8')!==initial||bounded.file_sha256!==write.sha256) throw new Error('R40 bounded machine read mismatch');
+    const edit=gateway(await client.callTool({name:'machine_fs',arguments:{op:'edit_exact',root_id:scratchRoot,path:target,expected_sha256:write.sha256,old_string:'needle',new_string:'beta',expected_replacements:1}}),'machine_fs edit');
+    machineReceipts.push(edit.receipt_id);await verifyMachineReceipt(policy,edit.receipt_id,'machine_fs_edit_exact');
+    const stale=await client.callTool({name:'machine_fs',arguments:{op:'edit_exact',root_id:scratchRoot,path:target,expected_sha256:write.sha256,old_string:'beta',new_string:'bad',expected_replacements:1}});
+    const staleValue=stale.structuredContent;
+    if(!staleValue||typeof staleValue!=='object') throw new Error('R40 stale machine-fs denial missing structured output');
+    if(stale.isError!==true||staleValue.status!=='denied'||!/precondition mismatch/i.test(String(staleValue.error??''))) {
+      throw new Error(`R40 stale machine-fs precondition was not denied: ${JSON.stringify(staleValue)}`);
+    }
+
+    const searchStart=gateway(await client.callTool({name:'machine_observe',arguments:{op:'search_start',root_id:scratchRoot,path:'.',pattern:tag,case_sensitive:true,max_results:20,max_files:200,max_bytes:262144,max_file_bytes:16384}}),'observe search start');
+    const searchStatus=await waitSearch(client,searchStart.search_id);
+    if(searchStatus.state!=='completed'||!searchStatus.receipt_id) throw new Error('R40 compact observation search failed');
+    observationReceipts.push(searchStatus.receipt_id);await verifyObservationReceipt(policy,searchStatus.receipt_id);
+    const page=gateway(await client.callTool({name:'machine_observe',arguments:{op:'search_page',search_id:searchStart.search_id,limit:20,cursor:null}}),'observe search page');
+    if(!page.results.some(item=>item.path===target)) throw new Error('R40 compact search did not return parity file');
+    const system=gateway(await client.callTool({name:'machine_observe',arguments:{op:'system_status'}}),'system status');
+    observationReceipts.push(system.receipt_id);await verifyObservationReceipt(policy,system.receipt_id);
+    const machineStatus=gateway(await client.callTool({name:'machine_observe',arguments:{op:'machine_status'}}),'machine status');
+    if(machineStatus.release_id!==pointer.release_id||machineStatus.release_manifest_sha256!==pointer.manifest_sha256) throw new Error('R40 compact machine status release mismatch');
+
+    const started=gateway(await client.callTool({name:'process_session',arguments:{op:'start',profile_id:'ping_hold',root_id:'core',cwd:'.',args:[]}}),'process start');
+    processSession=started.session_id??started.session?.session_id;
+    if(!/^[0-9a-f]{64}$/.test(String(processSession??''))) throw new Error('R40 compact process session id missing');
+    const action=gateway(await client.callTool({name:'process_session',arguments:{op:'action',session_id:processSession,action_id:'ping'}}),'process action');
+    const processRead=await waitProcessOutput(client,processSession);
+    const terminated=gateway(await client.callTool({name:'process_session',arguments:{op:'terminate',session_id:processSession}}),'process terminate');
+    const terminalState=terminated.state??terminated.session?.state;
+    if(action.action_id!=='ping'||terminalState!=='terminated') throw new Error('R40 compact process lifecycle failed');
+
+    const fsStat=gateway(await client.callTool({name:'machine_fs',arguments:{op:'stat',root_id:scratchRoot,path:target,hash:true}}),'machine_fs stat');
+    const deleted=gateway(await client.callTool({name:'machine_fs',arguments:{op:'delete',root_id:scratchRoot,path:target,expected_source_identity:fsStat.identity_sha256}}),'machine_fs delete');
+    machineReceipts.push(deleted.receipt_id);await verifyMachineReceipt(policy,deleted.receipt_id,'machine_fs_delete');targetPresent=false;
+
+    return {status:'passed',protocol_revision:client.getNegotiatedProtocolVersion(),profile:'compact',tool_count:names.length,tools:names,
+      catalog_sha256:sha256(Buffer.from(JSON.stringify(names),'utf8')),strict_output_schemas:true,ledger_sha256:manifest.ledger_sha256,
+      capability_count:manifest.capabilities.length,production_non_host_capabilities:required.length,capability_closure:true,
+      gateway_count:R40_COMPACT_GATEWAYS.length,tree_entries:tree.entries.length,coding_stat_verified:true,coding_search_result_count:search.matches.length,
+      desktop_armed:false,desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true,
+      desktop_frame_id:desktopObserved.frame.frame_id,desktop_target_id:desktopTarget.target.target_id,
+      machine_fs_receipts_verified:machineReceipts.length,observation_receipts_verified:observationReceipts.length,
+      observation_search_result_count:page.results.length,process_session_id:processSession,process_output_bytes:processRead.stream_head,
+      process_journal_head_sha256:terminated.journal_head_sha256??terminated.session?.journal_head_sha256,
+      build_receipt_id:build.receipt_id,test_receipt_id:tests.receipt_id,coding_receipts_verified:2,
+      execution_provider:'deadbyte_mcp',rdc_operation_count:0};
+  } finally {
+    if(processSession) await client.callTool({name:'process_session',arguments:{op:'terminate',session_id:processSession}}).catch(()=>{});
+    if(targetPresent){
+      try{const fsStat=gateway(await client.callTool({name:'machine_fs',arguments:{op:'stat',root_id:scratchRoot,path:target,hash:false}}),'cleanup stat');
+        if(fsStat.identity_sha256) await client.callTool({name:'machine_fs',arguments:{op:'delete',root_id:scratchRoot,path:target,expected_source_identity:fsStat.identity_sha256}}).catch(()=>{});
+      }catch{}
+    }
+    await client.close().catch(()=>{});
+  }
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  const endpoint=process.argv[2];
+  if(!endpoint) throw new Error('usage: node src/remote-mcp-r40-parity-client.mjs https://host/mcp/path');
+  runR40CompactParity(endpoint).then(result=>console.log(JSON.stringify(result,null,2))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}