deadbyte-mcp 0.15.21 → 0.15.23

package/src/remote-live-log.mjs

@@ -1,8 +1,9 @@
+import path from 'node:path';
 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 SAFE_ARG_KEYS=Object.freeze(['root_id','path','pattern','command_id','profile_id','session_id','goal_id','task_id','step_id','mode','op']);
 const LIFECYCLE=Object.freeze({
   device_start:'🚀 [DEVICE] Starting DEADBYTE MCP...',
   bridge_connected:'🔌 [BRIDGE] Local bridge connected',
@@ -74,19 +75,47 @@ function shortValue(value,max=12){
 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(' ');
+function safePathAtom(value){
+  if(typeof value!=='string'||value.length<1||value.length>2048||/[\r\n\0]/.test(value)) return null;
+  return value;
+}
+function rootedPath(args,key='path',rootPaths={}){
+  const root=safeAtom(args?.root_id);const p=safePathAtom(args?.[key]);
+  if(root&&p){
+    const base=safePathAtom(rootPaths?.[root]);
+    if(base){
+      const flavor=/^(?:[A-Za-z]:[\\/]|\\\\)/.test(base)?path.win32:path.posix;
+      const absolute=p==='.'?flavor.resolve(base):flavor.resolve(base,p);
+      return absolute+' [root='+root+']';
+    }
+    return root+':'+p;
+  }
+  if(root) return 'root='+root;
+  return p?'path='+p:'';
+}
+function displayToolName(tool,args){
+  const op=safeAtom(args?.op);
+  if(op&&['machine_fs','coding_inspect','process_session','desktop_control','machine_observe'].includes(tool)) return tool+'.'+op;
+  return tool;
+}
+export function summarizeLiveToolArgs(tool,rawArgs,{rootPaths={}}={}){
+  const args=sanitizeAuditArgs(rawArgs??{});const where=rootedPath(args,'path',rootPaths);
+  if(/(?:file_read|files_read)$/.test(tool)||/^machine_fs\.(?:read|stat|list)$/.test(tool)) return where;
+  if(/file_write$/.test(tool)||/^machine_fs\.write$/.test(tool)){const bytes=payloadByteCount(args.content);return [where,bytes!==null?'('+bytes+'B)':''].filter(Boolean).join(' ');}
+  if(/text_replace$|symbol_replace$/.test(tool)||/^machine_fs\.edit_exact$/.test(tool)){const bytes=payloadByteCount(args.new_string);return [where,bytes!==null?'('+bytes+'B new)':''].filter(Boolean).join(' ');}
+  if(/^machine_fs\.(?:mkdir|delete)$/.test(tool)||/coding_tree$/.test(tool)) return where;
+  if(/^machine_fs\.move$/.test(tool)) return [
+    rootedPath({...args,path:args.source_path},'path',rootPaths),
+    '->',
+    rootedPath({...args,path:args.destination_path},'path',rootPaths)
+  ].filter(Boolean).join(' ');
+  if(/coding_(?:search|inspect)(?:\.|$)/.test(tool)) return [where,args.pattern?'\"'+clipped(String(args.pattern),36)+'\"':''].filter(Boolean).join(' ');
+  if(/(?:command|benchmark)_run$/.test(tool)){
+    const root=safeAtom(args.root_id);const command=safeAtom(args.command_id);const scriptPath=safePathAtom(args.script_path);
+    if(root&&safePathAtom(rootPaths?.[root])) return [rootedPath({...args,path:scriptPath},'path',rootPaths),command].filter(Boolean).join(' ');
+    return [root,command,scriptPath].filter(Boolean).join(' ');
+  }
+  if(/^host_exec$/.test(tool)) return [rootedPath(args,'path',rootPaths),safeAtom(args.command_id),safeAtom(args.mode)].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(' ');
@@ -98,11 +127,11 @@ function categoryForTool(tool){
   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(/(?:search|inspect|symbol_(?:definition|references|implementations|outline|diagnostics)|(?:^|[._])stat$|(?:^|[._])list$|_tree$)/.test(tool)) return 'search';
+  if(/(?:file_read|files_read|machine_fs[._]read|process_session[._]read|host_file_read)/.test(tool)) return 'read';
+  if(/(?:file_write|machine_fs[._]write|host_file_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(/(?:command_run|benchmark_run|task_run|goal_run|process_session[._](?:start|action|terminate)|host_exec)/.test(tool)) return 'run';
   if(/^process_/.test(tool)) return 'process';
   return 'generic';
 }
@@ -110,7 +139,10 @@ 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 visibleStart(tool){
+  if(['write','edit','run'].includes(categoryForTool(tool))) return true;
+  return START_VISIBLE_PATTERNS.some(pattern=>pattern.test(tool));
+}
 
 function displayTimestamp(ms){
   const shifted=new Date(ms+DISPLAY_UTC_OFFSET_MINUTES*60*1000).toISOString();
@@ -189,24 +221,121 @@ export function createLiveActivityTracker(){
 function shortSpanId(requestId){
   return typeof requestId==='string'&&requestId.length?requestId.slice(0,8):'????????';
 }
+function traceIdentity(event,args=event?.args??{}){
+  const context=event?.context&&typeof event.context==='object'&&!Array.isArray(event.context)?event.context:{};
+  const first=(...values)=>values.map(safeAtom).find(Boolean)||null;
+  const spanId=safeAtom(event?.request_id);
+  return {
+    trace_id:first(context.trace_id,context.job_id,context.session_id,args.goal_id,args.task_id,args.job_id,args.session_id,spanId),
+    span_id:spanId,
+    parent_span_id:first(context.parent_span_id,context.parent_request_id)
+  };
+}
+function shortTraceValue(value,displayMode){
+  if(typeof value!=='string'||!value) return '';
+  if(value.length<=8) return value;
+  return value.slice(0,8)+(displayMode==='ascii'?'...':'…');
+}
+function traceText(meta,displayMode='unicode'){
+  if(!meta?.trace_id||!meta?.span_id) return '';
+  return 'trace='+shortTraceValue(meta.trace_id,displayMode)+' span='+shortTraceValue(meta.span_id,displayMode)+
+    (meta.parent_span_id?' parent='+shortTraceValue(meta.parent_span_id,displayMode):'');
+}
+function outcomeClass(event){
+  if(event?.outcome?.side_effect_state==='unknown') return 'unknown';
+  return event?.outcome?.is_error===true?'error':'ok';
+}
+function parseFilterExpression(expression){
+  if(expression===null||expression===undefined||expression==='') return Object.freeze({});
+  if(typeof expression!=='string'||expression.length>512) throw new Error('timeline filter invalid');
+  const out={};
+  for(const raw of expression.split(',')){
+    const part=raw.trim();if(!part) continue;
+    const at=part.indexOf('=');if(at<1||at===part.length-1) throw new Error('timeline filter term must be key=value');
+    const key=part.slice(0,at).trim();const value=part.slice(at+1).trim();
+    if(!['tool','category','status','trace'].includes(key)) throw new Error(`timeline filter key '${key}' unsupported`);
+    if(Object.hasOwn(out,key)) throw new Error(`timeline filter key '${key}' repeated`);
+    if(key==='status'&&!['ok','error','unknown'].includes(value)) throw new Error('timeline filter status invalid');
+    if(key==='category'&&!Object.hasOwn(TOOL_ICONS,value)) throw new Error('timeline filter category invalid');
+    out[key]=value;
+  }
+  return Object.freeze(out);
+}
+function toolFilterMatch(pattern,tool){
+  if(!pattern) return true;
+  return pattern.endsWith('*')?tool.startsWith(pattern.slice(0,-1)):tool===pattern;
+}
+export function createLiveTimelineFilter(expression=''){
+  const spec=parseFilterExpression(expression);
+  const pending=new Map();
+  const baseMatch=meta=>(!spec.tool||toolFilterMatch(spec.tool,meta.tool))&&(!spec.category||spec.category===meta.category)&&(!spec.trace||spec.trace===meta.trace_id);
+  return Object.freeze({
+    accept(event){
+      if(!event||typeof event!=='object'||Array.isArray(event)) return false;
+      const requestId=safeAtom(event.request_id);const rawTool=safeAtom(event.tool);
+      if(!requestId||!rawTool) return false;
+      if(event.event_type==='tool.request'){
+        const args=event.args??{};const tool=displayToolName(rawTool,args);const trace=traceIdentity(event,args);
+        const meta={tool,category:categoryForTool(tool),trace_id:trace.trace_id};
+        pending.set(requestId,meta);
+        return spec.status?false:baseMatch(meta);
+      }
+      if(event.event_type==='tool.result'){
+        const meta=pending.get(requestId)??{tool:rawTool,category:categoryForTool(rawTool),trace_id:traceIdentity(event).trace_id};
+        pending.delete(requestId);
+        return baseMatch(meta)&&(!spec.status||spec.status===outcomeClass(event));
+      }
+      return false;
+    },
+    spec
+  });
+}
+export function createLiveTimelineWriter({stream=process.stdout,displayMode='unicode',rewrite=true}={}){
+  if(!stream||typeof stream.write!=='function') throw new Error('timeline writer stream invalid');
+  if(!REMOTE_DISPLAY_MODES.includes(displayMode)) throw new Error('timeline writer display mode invalid');
+  if(typeof rewrite!=='boolean') throw new Error('timeline writer rewrite invalid');
+  let active=null;
+  function flush(){
+    if(active){stream.write('\n');active=null;}
+  }
+  function write(line,{event_type=null,request_id=null}={}){
+    if(typeof line!=='string'||!line) return;
+    const tty=stream.isTTY===true&&rewrite;
+    if(!tty){stream.write(line+'\n');return;}
+    if(active&&event_type==='tool.result'&&request_id&&request_id===active.request_id){
+      stream.write('\r\x1b[2K'+line+'\n');active=null;return;
+    }
+    if(active) flush();
+    if(event_type==='tool.call'&&request_id){stream.write(line);active={request_id};return;}
+    stream.write(line+'\n');
+  }
+  return Object.freeze({write,flush,pending(){return active?{...active}:null;}});
+}
 
-export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode'}={}){
+export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false}={}){
   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');
+  if(!rootPaths||typeof rootPaths!=='object'||Array.isArray(rootPaths)) throw new Error('live timeline rootPaths invalid');
+  if(typeof trace!=='boolean') throw new Error('live timeline trace invalid');
   const pending=new Map();
   const completed=new Set();
   const toolCounts=new Map();
-  let resultCount=0,errorCount=0,totalDurationMs=0,burst=null,foldedHeartbeatLines=0;
+  const durationSamples=[];
+  let resultCount=0,okCount=0,errorCount=0,unknownCount=0,mutationCount=0,totalDurationMs=0,slowest=null,burst=null,foldedHeartbeatLines=0;
 
-  function eventPrefix(event,sequence){
+  function eventPrefix(event,sequence,{displayTool=null,icon=null}={}){
     const seq=Number.isSafeInteger(sequence)&&sequence>0?'#'+sequence+'  ':'';
-    return iconForTool(event.tool,displayMode)+'  '+displayClock(eventMs(event,clock))+'  '+seq+'['+shortSpanId(event.request_id)+']  '+event.tool;
+    const tool=displayTool||event.tool;
+    const visual=icon||iconForTool(tool,displayMode);
+    return visual+'  '+displayClock(eventMs(event,clock))+'  '+seq+'['+shortSpanId(event.request_id)+']  '+tool;
   }
+  function traceSuffix(meta){return trace&&meta?'  '+traceText(meta,displayMode):'';}
   function resultLine(event,span,sequence){
     const error=event.outcome?.is_error===true;
     const unknown=event.outcome?.side_effect_state==='unknown';
+    const displayTool=span?.display_tool||event.tool;
     const duration=Number.isFinite(Number(event.outcome?.duration_ms))
       ?formatDuration(event.outcome.duration_ms)
       :span?formatDuration(Math.max(0,clock()-span.started_at_ms)):'';
@@ -214,8 +343,17 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
     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);
+    const category=categoryForTool(displayTool);
+    const receipt=Array.isArray(event.outcome?.receipt_sha256s)&&typeof event.outcome.receipt_sha256s[0]==='string'
+      ?shortValue(event.outcome.receipt_sha256s[0],8):'';
+    const marker=unknown?'FAILED_AFTER_UNKNOWN_EFFECT':
+      error?(displayMode==='ascii'?'ERR':'✗'):
+      ['write','edit','run'].includes(category)?(displayMode==='ascii'?'SUCCEEDED':'✅ SUCCEEDED'):
+      (displayMode==='ascii'?'OK':'✓');
+    const prefixIcon=unknown?(displayMode==='ascii'?'WARN':'⚠️'):null;
+    const evidence=receipt?'  '+(displayMode==='ascii'?'RECEIPT':'🧾 receipt')+(displayMode==='ascii'?'=':'=')+receipt:'';
+    const reasonSep=displayMode==='ascii'?' - ':' — ';
+    return remoteDisplayText(eventPrefix(event,sequence,{displayTool,icon:prefixIcon})+traceSuffix(span?.trace_meta)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+'  '+marker+evidence+(reason?reasonSep+reason:''),displayMode);
   }
   function burstLine(value){
     if(!value) return null;
@@ -233,12 +371,19 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
     burst=null;
     return line;
   }
-  function addStats(event){
+  function addStats(event,span){
     resultCount++;
-    toolCounts.set(event.tool,(toolCounts.get(event.tool)??0)+1);
+    const displayTool=span?.display_tool||event.tool;
+    toolCounts.set(displayTool,(toolCounts.get(displayTool)??0)+1);
+    const outcome=outcomeClass(event);
+    if(outcome==='unknown') unknownCount++;else if(outcome==='error') errorCount++;else okCount++;
+    if(['write','edit','run'].includes(categoryForTool(displayTool))) mutationCount++;
     const duration=Number(event.outcome?.duration_ms);
-    if(Number.isFinite(duration)&&duration>=0) totalDurationMs+=duration;
-    if(event.outcome?.is_error===true) errorCount++;
+    if(Number.isFinite(duration)&&duration>=0){
+      totalDurationMs+=duration;
+      if(durationSamples.length<2048) durationSamples.push(duration);
+      if(!slowest||duration>slowest.duration_ms) slowest={tool:displayTool,duration_ms:duration};
+    }
   }
   function observe(event,{sequence=null}={}){
     if(!event||typeof event!=='object'||Array.isArray(event)) return null;
@@ -246,10 +391,13 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
     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:'')+'  …';
+      const args=event.args??{};
+      const displayTool=displayToolName(tool,args);
+      const summary=summarizeLiveToolArgs(displayTool,args,{rootPaths});
+      const traceMeta=traceIdentity(event,args);
+      pending.set(requestId,{request_id:requestId,tool,display_tool:displayTool,summary,trace_meta:traceMeta,started_at_ms:clock()});
+      if(verbose) return formatRemoteToolCall({...event,tool:displayTool},{clock,displayMode})+traceSuffix(traceMeta);
+      if(visibleStart(displayTool)) return eventPrefix(event,sequence,{displayTool})+traceSuffix(traceMeta)+(summary?'  '+summary:'')+'  …';
       return null;
     }
     if(event.event_type==='tool.result'&&requestId&&tool){
@@ -257,7 +405,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
       const span=pending.get(requestId)??null;
       pending.delete(requestId);
       completed.add(requestId);
-      addStats(event);
+      addStats(event,span);
       const error=event.outcome?.is_error===true;
       const nowMs=eventMs(event,clock);
       if(HEARTBEAT_TOOLS.has(tool)&&!error){
@@ -297,8 +445,14 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
   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')+
+    const sorted=[...durationSamples].sort((a,b)=>a-b);
+    const p50=sorted.length?(sorted.length%2?sorted[(sorted.length-1)/2]:(sorted[sorted.length/2-1]+sorted[sorted.length/2])/2):null;
+    const p95=sorted.length?sorted[Math.max(0,Math.ceil(sorted.length*0.95)-1)]:null;
+    return remoteDisplayText((displayMode==='ascii'?'[SUMMARY]':'📊 [SUMMARY]')+' '+resultCount+' calls | '+okCount+' ok | '+
+      errorCount+' error'+(errorCount===1?'':'s')+' | '+unknownCount+' unknown | '+mutationCount+' mutation'+(mutationCount===1?'':'s')+
       ' | tool time '+(formatDuration(totalDurationMs)||'0ms')+
+      (p50!==null?' | p50 '+formatDuration(p50)+' | p95 '+formatDuration(p95):'')+
+      (slowest?' | slowest '+slowest.tool+' '+formatDuration(slowest.duration_ms):'')+
       (foldedHeartbeatLines?' | folded '+foldedHeartbeatLines+' heartbeat lines':'')+
       (top?' | top: '+top:''),displayMode);
   }

package/src/tool-audit.mjs

@@ -86,7 +86,7 @@ function safeOutcomeReason(value){
   if(value===null||value===undefined) return null;
   let text=typeof value==='string'?value:(value instanceof Error?String(value.message??value):null);
   if(text===null) return null;
-  text=text.replace(/[\\r\\n\\t]+/g,' ').replace(/\\s{2,}/g,' ').trim();
+  text=text.replace(/[\r\n\t]+/g,' ').replace(/\s{2,}/g,' ').trim();
   if(!text) return null;
   const originalBytes=Buffer.from(text,'utf8');
   if(secretValuePattern.test(text)) return `<redacted reason bytes=${originalBytes.length} sha256=${sha256(originalBytes)}>`;

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.21';
+export const DEADBYTE_VERSION = '0.15.23';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/full-max-catalog-r47.test.mjs

@@ -15,7 +15,7 @@ const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy
 const catalogPath=path.join(repoRoot,'docs','R47-FULL-TOOL-CATALOG.json');
 const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
 
-test('R47 runtime full stdio catalog exactly matches canonical registration surface',async()=>{
+test('R47 runtime full stdio catalog exactly matches canonical registration surface',{skip:'historical R47 catalog; R48 supersedes it'},async()=>{
   const canonical=JSON.parse(await readFile(catalogPath,'utf8'));
   assert.equal(canonical.schema,'deadbyte.r47-full-catalog.v1');
   assert.equal(canonical.train,'R47');

package/test/full-max-catalog-r48.test.mjs

@@ -0,0 +1,78 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { createR34Fixture } from './helpers/autonomous-r34-fixture.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+const desktopPolicyPath=path.join(repoRoot,'controller','deadbyte-desktop-policy.json');
+const catalogPath=path.join(repoRoot,'docs','R48-FULL-TOOL-CATALOG.json');
+const absent=async p=>{try{await access(p);return false;}catch(e){if(e?.code==='ENOENT')return true;throw e;}};
+
+test('R48 runtime full stdio catalog exactly matches canonical registration surface',async()=>{
+  const canonical=JSON.parse(await readFile(catalogPath,'utf8'));
+  assert.equal(canonical.schema,'deadbyte.r48-full-catalog.v1');
+  assert.equal(canonical.train,'R48');
+  assert.ok(Array.isArray(canonical.tools));
+  assert.equal(canonical.tool_count,canonical.tools.length);
+  assert.equal(new Set(canonical.tools).size,canonical.tools.length);
+  assert.deepEqual([...canonical.tools].sort(),canonical.tools);
+
+  const f=await createR34Fixture({authority:'disarmed'});
+  const processPolicyPath=path.join(f.root,'process-policy.json');
+  const processGrant=path.join(f.root,'process-grant.json');
+  const processState=path.join(f.root,'process-state');
+  const hostPolicyPath=path.join(f.root,'host-policy.json');
+  const hostArm=path.join(f.root,'host-arm.json');
+  const desktopRaw=JSON.parse(await readFile(desktopPolicyPath,'utf8'));
+  const desktopGrant=desktopRaw.grant_file;
+  await mkdir(processState,{recursive:true});
+  const nodeSha=createHash('sha256').update(await readFile(process.execPath)).digest('hex');
+  await writeFile(processPolicyPath,JSON.stringify({
+    schema:'deadbyte.process-policy.v1',enabled:true,grant_file:processGrant,state_dir:processState,
+    native_host:{path:process.execPath,sha256:nodeSha},
+    roots:{core:{path:f.project,deny_paths:[]}},
+    profiles:{node:{executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],prefix_args:[],transport:'pipe',max_args:8,max_arg_bytes:1024,max_sessions:2,max_input_bytes:65536,max_retained_output_bytes:262144,env_allow:['PATH','TEMP','TMP'],input_actions:{ping:'PING\\r\\n'}}}
+  },null,2));
+  await writeFile(hostPolicyPath,JSON.stringify({
+    schema:'deadbyte.host-policy.v1',enabled:true,arm_file:hostArm,max_read_bytes:262144,max_write_bytes:1048576,
+    roots:{core:{path:f.project,read:true,write:true,exec:true}},
+    commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:nodeSha,root_ids:['core'],prefix_args:[],extensions:['.mjs'],timeout_ms:5000,max_output_bytes:65536}}
+  },null,2));
+  const codingLease=f.codingPolicy.lease_file;
+  const autonomousLease=f.policy.lease_file;
+  for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority unexpectedly armed before start: '+q);
+
+  const client=new Client({name:'deadbyte-r48-full-catalog',version:'0.15.23'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const env={
+    ...getDefaultEnvironment(),DEADBYTE_CAPABILITY_PROFILE:'full',DEADBYTE_AUDIT_RUNTIME:'0',
+    DEADBYTE_STATE_ROOT:path.join(f.root,'state'),DEADBYTE_WORKSPACE_ROOT:f.root,
+    DEADBYTE_SIGNING_KEY:f.keys.privateKeyPath,DEADBYTE_VERIFY_KEY:f.keys.publicKeyPath,
+    DEADBYTE_PRIVILEGED_POLICY:hostPolicyPath,DEADBYTE_MACHINE_RUNTIME:'1',DEADBYTE_AGENT_RUNTIME:'1',
+    DEADBYTE_PROCESS_RUNTIME:'1',DEADBYTE_PROCESS_POLICY:processPolicyPath,DEADBYTE_CODING_RUNTIME:'1',
+    DEADBYTE_CODING_POLICY:path.join(f.root,'coding-policy.json'),DEADBYTE_MACHINE_FS_RUNTIME:'1',
+    DEADBYTE_OBSERVATION_RUNTIME:'1',DEADBYTE_DESKTOP_RUNTIME:'1',DEADBYTE_DESKTOP_POLICY:desktopPolicyPath,
+    DEADBYTE_AUTONOMOUS_RUNTIME:'1',DEADBYTE_AUTONOMOUS_POLICY:path.join(f.root,'autonomous-policy.json'),
+    DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external'
+  };
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(t=>t.name).sort();
+    assert.deepEqual(names,canonical.tools);
+    assert.equal(new Set(names).size,names.length,'runtime duplicate tool names');
+    for(const tool of listed.tools) if(tool.outputSchema!==undefined) assert.equal(tool.outputSchema?.additionalProperties,false,'non-strict output '+tool.name);
+    for(const name of ['agent_task_submit','autonomous_goal_submit','coding_task_submit','process_session_start','machine_fs_write','machine_search_start','desktop_action','host_exec','native_diff_apply','skill_catalog']) assert.ok(names.includes(name),'missing R48 surface '+name);
+  } finally {
+    await client.close().catch(()=>{});
+    for(const q of [processGrant,hostArm,desktopGrant,codingLease,autonomousLease]) assert.equal(await absent(q),true,'authority file appeared during catalog probe: '+q);
+    await f.cleanup();
+  }
+});

package/test/machine-fs-runtime.test.mjs

@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createHash } from 'node:crypto';
-import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { generateTrustKeypair } from '../src/trust.mjs';
@@ -10,7 +10,7 @@ import { createMachineFsRuntime, verifyMachineFsReceiptFile } from '../src/machi
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 
-async function fixture({ readWorkerPath = undefined } = {}) {
+async function fixture({ readWorkerPath = undefined, listEntryLstat = undefined } = {}) {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-machine-fs-'));
   const project = path.join(root, 'project');
   await mkdir(project);
@@ -30,7 +30,7 @@ async function fixture({ readWorkerPath = undefined } = {}) {
     privateKeyPath: path.join(root, 'private.pem'), publicKeyPath: path.join(root, 'public.pem')
   });
   const runtime = createMachineFsRuntime({
-    policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath, readWorkerPath
+    policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath, readWorkerPath, listEntryLstat
   });
   return { root, project, policy, keys, runtime };
 }
@@ -87,6 +87,31 @@ test('R31 machine fs supports exact mkdir/write/stat/list/range-read/edit/move/d
   assert.equal(second.next_cursor, null);
 });
 
+test('R48 machine fs listing isolates one unreadable child instead of failing the page', async () => {
+  let projectPath = null;
+  const injectedLstat = async target => {
+    if (projectPath && path.basename(target) === 'bad.txt') {
+      const error = new Error('simulated Windows lstat EINVAL');
+      error.code = 'EINVAL';
+      error.syscall = 'lstat';
+      throw error;
+    }
+    return lstat(target);
+  };
+  const f = await fixture({ listEntryLstat: injectedLstat });
+  projectPath = f.project;
+  await writeFile(path.join(f.project, 'bad.txt'), 'bad');
+  await writeFile(path.join(f.project, 'good.txt'), 'good');
+  const listed = await f.runtime.list({ rootId:'project', relativePath:'.', limit:10, hashFiles:true });
+  assert.deepEqual(listed.entries.map(item => item.path), ['bad.txt','good.txt']);
+  assert.deepEqual(listed.entries[0], {
+    path:'bad.txt', kind:'unreadable', bytes:0, mtime_utc:null, sha256:null,
+    error:{ code:'EINVAL', operation:'lstat' }
+  });
+  assert.equal(listed.entries[1].kind, 'file');
+  assert.equal(listed.entries[1].sha256, sha(Buffer.from('good')));
+});
+
 test('R31 machine fs fails closed on traversal, denied paths and stale source identity', async () => {
   const f = await fixture();
   await mkdir(path.join(f.project, 'blocked'));

package/test/observation-mcp-tools.test.mjs

@@ -16,14 +16,15 @@ function runtime(){
     searchCancel:async()=>({status:'ok',search_id:hex('a'),state:'cancelled',cancel_requested:true}),
     processList:async()=>({status:'ok',snapshot_id:hex('e'),observed_at_utc:new Date(0).toISOString(),processes:[],next_cursor:null,request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')}),
     systemStatus:async()=>({status:'ok',observed_at_utc:new Date(0).toISOString(),hostname:'x',platform:'win32',architecture:'x64',uptime_seconds:1,total_memory_bytes:2,free_memory_bytes:1,cpu_count:1,load_average:[0,0,0],request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')}),
-    hardwareQuery:async({query})=>({status:'ok',query,observed_at_utc:new Date(0).toISOString(),observer_sha256:hex('e'),data:{vendor:'x'},request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')})
+    hardwareQuery:async({query})=>({status:'ok',query,observed_at_utc:new Date(0).toISOString(),observer_sha256:hex('e'),data:{vendor:'x'},request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')}),
+    windowsQuery:async({query})=>({status:'ok',query,observed_at_utc:new Date(0).toISOString(),observer_sha256:hex('e'),data:{query},request_sha256:hex('b'),result_head_sha256:hex('c'),receipt_id:receipt,receipt_sha256:hex('d')})
   };
 }
 
-test('R45 registers exactly seven bounded observation tools including typed native hardware',()=>{
+test('R48 registers exactly eight bounded observation tools including typed native Windows observation',()=>{
   const server=new FakeServer(); registerObservationTools(server,{runtime:runtime()});
   assert.deepEqual([...server.tools.keys()].sort(),[
-    'machine_hardware_query','machine_process_list','machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_system_status'
+    'machine_hardware_query','machine_process_list','machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_system_status','machine_windows_query'
   ]);
   for(const [name,tool] of server.tools){ assert.ok(tool.spec.inputSchema,`${name} input`); assert.ok(tool.spec.outputSchema,`${name} output`); }
 });

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

@@ -6,31 +6,41 @@ import { DEADBYTE_VERSION } from '../src/version.mjs';
 const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 
-test('R48 successor identity is coherent and binds active 0.15.20 parent plus sealed 0.15.20 source predecessor',async()=>{
+test('R48 0.15.23 successor binds active 0.15.22 parent and livelog trace evidence',async()=>{
   const [pkg,lock,release,provenance]=await Promise.all([
     read('package.json').then(JSON.parse),
     read('package-lock.json').then(JSON.parse),
     read('RELEASE.json').then(JSON.parse),
     read('PROVENANCE.json').then(JSON.parse)
   ]);
-  assert.equal(pkg.version,'0.15.21');
-  assert.equal(lock.version,'0.15.21');
-  assert.equal(lock.packages[''].version,'0.15.21');
-  assert.equal(DEADBYTE_VERSION,'0.15.21');
-  assert.equal(release.version,'0.15.21');
-  assert.equal(provenance.version,'0.15.21');
+  assert.equal(pkg.version,'0.15.23');
+  assert.equal(lock.version,'0.15.23');
+  assert.equal(lock.packages[''].version,'0.15.23');
+  assert.equal(DEADBYTE_VERSION,'0.15.23');
+  assert.equal(release.version,'0.15.23');
+  assert.equal(provenance.version,'0.15.23');
   assert.equal(release.train,'R48');
-  assert.equal(release.label,'CAPABILITY MANIFEST AUTHORITY TRUTH');
-  assert.equal(release.parent.release_id,'v0.15.20-bab990b08c9c1f07');
-  assert.equal(release.parent.manifest_sha256,'bab990b08c9c1f0788a1ede6b0695d293f8433e4ef0f541eca59635cf125a43d');
-  assert.equal(release.parent.generation_manifest_sha256,'617ea6bfbfc7e1952d17e7fea1043fd70b32bb1edacbd3ed6002fec7235c7221');
-  assert.equal(release.source_predecessor.version,'0.15.20');
-  assert.equal(release.source_predecessor.tarball_sha256,'eb7cbe8465ae3834c9857fc2115c7ab4eb3d1a018aa1695b799912def5dc3cee');
-  assert.equal(release.source_predecessor.manifest_file_sha256,'bab990b08c9c1f0788a1ede6b0695d293f8433e4ef0f541eca59635cf125a43d');
+  assert.equal(release.label,'HUMAN LIVELOG TRACE + VISUAL OPCODE BASELINE');
+  assert.equal(release.parent.release_id,'v0.15.22-ed178d33bf883f68');
+  assert.equal(release.parent.manifest_sha256,'ed178d33bf883f68b4f39f2e8bb805094bc8024b30114c4e6a34b80930cfcff8');
+  assert.equal(release.parent.generation_manifest_sha256,'029b177dc1838388ddec154be38cb597a4dcfa0711b2297196d5a9e7cb8dbe18');
+  assert.equal(release.source_predecessor.version,'0.15.22');
+  assert.equal(release.source_predecessor.tarball_sha256,'fda51e06fa16116179d9c48f1466432886c10e62807482326d2dc5ccb7b66eac');
+  assert.equal(release.source_predecessor.manifest_file_sha256,'ed178d33bf883f68b4f39f2e8bb805094bc8024b30114c4e6a34b80930cfcff8');
   assert.equal(release.source_predecessor.reference_server_sha256,'dfc303bb7dd2e8d01debac50fc43bb8644d00089bffdf2887e149497cff8b305');
   assert.equal(release.source_predecessor.reference_schemas_sha256,'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140');
+  assert.equal(release.capabilities.full_tool_count,116);
+  assert.equal(release.capabilities.full_tool_catalog.path,'docs/R48-FULL-TOOL-CATALOG.json');
+  assert.deepEqual(release.capabilities.windows_queries,['registry','services','drivers','sockets','volumes','usb','wsl']);
+  assert.equal(release.capabilities.machine_fs_list_entry_fault_isolation,true);
   assert.equal(release.capabilities.capability_manifest_authority_truth,true);
   assert.equal(release.capabilities.capability_manifest_host_grant_truth,true);
+  assert.equal(release.capabilities.human_livelog_visual_opcode,true);
+  assert.equal(release.capabilities.human_livelog_absolute_root_paths,true);
+  assert.equal(release.capabilities.human_livelog_trace_span,true);
+  assert.equal(release.capabilities.human_livelog_presentation_filter,true);
+  assert.equal(release.capabilities.human_livelog_tty_in_place_rewrite,true);
+  assert.equal(release.capabilities.human_livelog_expanded_summary,true);
   assert.equal(provenance.parent_release_id,release.parent.release_id);
   assert.equal(provenance.parent_manifest_sha256,release.parent.manifest_sha256);
   assert.equal(provenance.parent_generation_manifest_sha256,release.parent.generation_manifest_sha256);