deadbyte-mcp 0.15.22 → 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.22';
+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-r48.test.mjs

@@ -49,7 +49,7 @@ test('R48 runtime full stdio catalog exactly matches canonical registration surf
   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.22'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  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,

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

@@ -6,27 +6,27 @@ 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 0.15.22 successor binds active 0.15.21 parent and native Windows observation release evidence',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.22');
-  assert.equal(lock.version,'0.15.22');
-  assert.equal(lock.packages[''].version,'0.15.22');
-  assert.equal(DEADBYTE_VERSION,'0.15.22');
-  assert.equal(release.version,'0.15.22');
-  assert.equal(provenance.version,'0.15.22');
+  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,'NATIVE WINDOWS OBSERVATION + MACHINE FS RESILIENCE');
-  assert.equal(release.parent.release_id,'v0.15.21-7c2735e0b1c6cc8d');
-  assert.equal(release.parent.manifest_sha256,'7c2735e0b1c6cc8dac6581c47b6b557d8d0157a324b67efd4df058e67cdb289f');
-  assert.equal(release.parent.generation_manifest_sha256,'b376e7fc450f44edddb0d0e1d596014c463f603e4917c56a68906b7f66f99dc7');
-  assert.equal(release.source_predecessor.version,'0.15.21');
-  assert.equal(release.source_predecessor.tarball_sha256,'3439f5f4435632e4cde385a6937e3e3d2ffcfb777295dd56aafbf3b036be7493');
-  assert.equal(release.source_predecessor.manifest_file_sha256,'7c2735e0b1c6cc8dac6581c47b6b557d8d0157a324b67efd4df058e67cdb289f');
+  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);
@@ -35,6 +35,12 @@ test('R48 0.15.22 successor binds active 0.15.21 parent and native Windows obser
   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);

package/test/remote-live-log-r37.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { createLiveTimelineTracker, formatRemoteLifecycle, formatRuntimeDiagnosticLine, summarizeLiveToolArgs, truncateUtf8 } from '../src/remote-live-log.mjs';
+import * as live from '../src/remote-live-log.mjs';
+const {createLiveTimelineTracker,formatRemoteLifecycle,formatRuntimeDiagnosticLine,summarizeLiveToolArgs,truncateUtf8}=live;
 
 test('R40 human live timeline suppresses noisy read request and emits one categorized terminal line',()=>{
   let now=1000;
@@ -43,7 +44,7 @@ test('R40 heartbeat burst folds repeated status calls instead of printing every
     else assert.match(line,/^📡  .*#39  machine_ping ×5  avg 3ms  ✓$/);
     now+=10;
   }
-  assert.match(tracker.summary(),/5 calls \| 0 errors .*folded 4 heartbeat lines.*machine_ping×5/);
+  assert.match(tracker.summary(),/5 calls \| 5 ok \| 0 errors \| 0 unknown \| 0 mutations .*folded 4 heartbeat lines.*machine_ping×5/);
 });
 
 test('R40 transport IN/OUT echo is hidden by default and available only in verbose diagnostics',()=>{
@@ -64,14 +65,19 @@ test('R40 interrupted spans remain correlated and session summary is available',
     args:{root_id:'core',path:'x.txt',content:'x'}},{sequence:50});
   const lines=tracker.reconcileInterrupted('recovery');
   assert.deepEqual(lines,['⚠ [pending-] OUTCOME_UNKNOWN coding_file_write — recovery ended before terminal result; inspect state before retry']);
-  assert.match(tracker.summary(),/^📊 \[SUMMARY\] 0 calls \| 0 errors/);
+  assert.match(tracker.summary(),/^📊 \[SUMMARY\] 0 calls \| 0 ok \| 0 errors \| 0 unknown \| 0 mutations/);
 });
 
 test('R40 CLI exposes explicit verbose mode while keeping default live mode compact',async()=>{
   const {readFile}=await import('node:fs/promises');
   const src=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
-  assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode\}\)/);
-  assert.match(src,/args\.includes\('--verbose'\)/);
+  assert.match(src,/readLiveRootPaths\(ctx\.root\)/);
+  assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode,rootPaths,trace\}\)/);
+  assert.match(src,/createLiveTimelineFilter\(filterExpression\)/);
+  assert.match(src,/createLiveTimelineWriter\(\{stream:process\.stdout,displayMode,rewrite:!verbose\}\)/);
+  assert.match(src,/arg==='--verbose'\|\|arg==='-v'/);
+  assert.match(src,/arg==='--trace'/);
+  assert.match(src,/arg==='--filter'/);
   assert.match(src,/Transport IN\/OUT hidden/);
   assert.doesNotMatch(src,/\[cursor \$\{recorded\.cursor\}\]/);
 });
@@ -88,13 +94,13 @@ test('R40 ASCII display fallback contains no non-ASCII bytes and preserves termi
   assert.equal(formatRemoteLifecycle('device_start',{displayMode:'ascii'}),'[DEVICE] Starting DEADBYTE MCP...');
 });
 
-test('R40 interrupted side effect is explicit OUTCOME_UNKNOWN instead of implying failure or replay safety',()=>{
+test('R40 interrupted side effect is explicit failed-after-unknown-effect instead of implying replay safety',()=>{
   const tracker=createLiveTimelineTracker({clock:()=>1000});
   tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'unknown-12345678',
     args:{root_id:'core',path:'x.txt',content:'x'}},{sequence:70});
   const line=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'unknown-12345678',
     outcome:{status:'interrupted',is_error:true,duration_ms:0,side_effect_state:'unknown',recovery:{reason:'runtime_restart'}}},{sequence:71});
-  assert.match(line,/OUTCOME_UNKNOWN — runtime_restart$/);
+  assert.match(line,/FAILED_AFTER_UNKNOWN_EFFECT — runtime_restart$/);
   assert.doesNotMatch(line,/\s[✓✗]\s/);
 });
 
@@ -105,3 +111,96 @@ test('R40 UTF-8 truncation never splits Thai or emoji into replacement character
   assert.equal(clipped.includes('\uFFFD'),false);
   assert.ok(clipped.endsWith('…'));
 });
+
+
+test('visual opcode projection resolves multiplexed machine_fs operation and exposes terminal evidence',()=>{
+  let now=1000;
+  const receipt='1'.repeat(64);
+  const tracker=createLiveTimelineTracker({clock:()=>now,rootPaths:{projects:'D:\\Projects'}});
+  const start=tracker.observe({event_type:'tool.request',tool:'machine_fs',request_id:'machinefs-12345678',
+    ts:'1970-01-01T00:00:01.000Z',args:{op:'write',root_id:'projects',path:'S3CORE01-R2/STATUS.txt',content:'x'}},{sequence:80});
+  assert.match(start,/^📝 .*machine_fs\.write /);
+  assert.ok(start.includes('D:\\Projects\\S3CORE01-R2\\STATUS.txt [root=projects]'));
+  now=1007;
+  const done=tracker.observe({event_type:'tool.result',tool:'machine_fs',request_id:'machinefs-12345678',
+    ts:'1970-01-01T00:00:01.007Z',outcome:{status:'committed',is_error:false,duration_ms:7,receipt_sha256s:[receipt]}},{sequence:81});
+  assert.match(done,/^📝 .*machine_fs\.write .*7ms  ✅ SUCCEEDED  🧾 receipt=11111111…$/);
+});
+
+test('visual opcode projection reserves warning semantics for explicitly unknown side effects',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000});
+  tracker.observe({event_type:'tool.request',tool:'host_exec',request_id:'unknown-host-1234',
+    args:{root_id:'core',command_id:'powershell_inline',mode:'inline'}},{sequence:90});
+  const done=tracker.observe({event_type:'tool.result',tool:'host_exec',request_id:'unknown-host-1234',
+    outcome:{status:'interrupted',is_error:true,duration_ms:4,side_effect_state:'unknown',recovery:{reason:'runtime_restart'}}},{sequence:91});
+  assert.match(done,/^⚠️ .*host_exec .*4ms  FAILED_AFTER_UNKNOWN_EFFECT — runtime_restart$/);
+  assert.doesNotMatch(done,/❌|🚫/);
+});
+
+
+test('absolute Windows root rendering shows the operator the real host path and root identity',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,rootPaths:{local_c:'C:\\'}});
+  tracker.observe({event_type:'tool.request',tool:'machine_fs',request_id:'localc-123456789',
+    args:{op:'read',root_id:'local_c',path:'Users/DEADBYTE/.deadbyte-mcp/active-release.json'}},{sequence:100});
+  const line=tracker.observe({event_type:'tool.result',tool:'machine_fs',request_id:'localc-123456789',
+    outcome:{is_error:false,duration_ms:1}},{sequence:101});
+  assert.ok(line.includes('C:\\Users\\DEADBYTE\\.deadbyte-mcp\\active-release.json [root=local_c]'));
+  assert.match(line,/^📖 .*machine_fs\.read /);
+});
+
+
+test('trace mode exposes deterministic trace/span hierarchy without payload bytes',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,trace:true});
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'span-1234567890abcdef',
+    context:{parent_span_id:'parent-abcdef123456',job_id:'job-112233445566'},args:{root_id:'core',path:'x.txt',content:'SECRET'}},{sequence:110});
+  assert.match(start,/trace=job-1122… span=span-123… parent=parent-a…/);
+  assert.doesNotMatch(start,/SECRET/);
+  const done=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'span-1234567890abcdef',
+    outcome:{is_error:false,duration_ms:2}},{sequence:111});
+  assert.match(done,/trace=job-1122… span=span-123… parent=parent-a…/);
+});
+
+test('timeline filter keeps audit observation complete while selecting presentation by category status and trace',()=>{
+  const filter=live.createLiveTimelineFilter('category=write,status=error,trace=goal-1234');
+  const request={event_type:'tool.request',tool:'machine_fs',request_id:'filter-span-1',
+    args:{op:'write',root_id:'projects',path:'x.txt',goal_id:'goal-1234'}};
+  assert.equal(filter.accept(request),false,'status-constrained request start is deferred');
+  assert.equal(filter.accept({event_type:'tool.result',tool:'machine_fs',request_id:'filter-span-1',
+    outcome:{is_error:true,duration_ms:1}}),true);
+  const other={event_type:'tool.request',tool:'coding_file_read',request_id:'filter-span-2',
+    args:{root_id:'projects',path:'x.txt',goal_id:'goal-1234'}};
+  assert.equal(filter.accept(other),false);
+  assert.equal(filter.accept({event_type:'tool.result',tool:'coding_file_read',request_id:'filter-span-2',
+    outcome:{is_error:true,duration_ms:1}}),false);
+});
+
+test('TTY writer rewrites matching visible start in place and never rewrites unrelated output',()=>{
+  const writes=[];const stream={isTTY:true,write(value){writes.push(value);return true;}};
+  const writer=live.createLiveTimelineWriter({stream,displayMode:'unicode'});
+  writer.write('RUNNING',{event_type:'tool.call',request_id:'a'});
+  writer.write('DONE',{event_type:'tool.result',request_id:'a'});
+  assert.deepEqual(writes,['RUNNING','\r\x1b[2KDONE\n']);
+  writes.length=0;
+  writer.write('RUN-A',{event_type:'tool.call',request_id:'a'});
+  writer.write('OTHER',{event_type:'tool.result',request_id:'b'});
+  assert.deepEqual(writes,['RUN-A','\n','OTHER\n']);
+});
+
+test('expanded session summary reports outcome classes latency and slowest tool',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000});
+  const events=[
+    ['a','coding_file_read',10,false,false],
+    ['b','coding_file_write',50,false,false],
+    ['c','coding_command_run',100,true,false],
+    ['d','host_exec',200,true,true]
+  ];
+  for(const [id,tool,duration,isError,unknown] of events){
+    tracker.observe({event_type:'tool.request',tool,request_id:id,args:{root_id:'core',path:'x'}});
+    tracker.observe({event_type:'tool.result',tool,request_id:id,outcome:{is_error:isError,duration_ms:duration,
+      ...(unknown?{side_effect_state:'unknown'}:{})}});
+  }
+  const summary=tracker.summary();
+  assert.match(summary,/4 calls \| 2 ok \| 1 error \| 1 unknown \| 3 mutations/);
+  assert.match(summary,/p50 75ms \| p95 200ms/);
+  assert.match(summary,/slowest host_exec 200ms/);
+});

package/test/remote-session-cli.test.mjs

@@ -466,3 +466,43 @@ winTest('bare remote surfaces bounded controller-start-failure evidence instead
     assert.match(output.stderr,/controller-start-failure/i);
   }finally{await rm(fx.dir,{recursive:true,force:true});}
 });
+
+
+winTest('remote --trace --filter selects presentation without dropping journaled events',async()=>{
+  const fx=await fixture();
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote','--trace','--filter','category=write,status=error,trace=goal-1234'],{
+      env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true
+    });
+    const output=await collect(child);
+    await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
+    const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
+    const auditDir=path.join(fx.state,'audit');await mkdir(auditDir,{recursive:true});
+    const audit=[
+      {event_type:'tool.request',tool:'machine_fs',request_id:'filter-write-1234',created_at_utc:'2026-09-19T01:00:00.000Z',
+        args:{op:'write',root_id:'projects',path:'x.txt',goal_id:'goal-1234',content:'SECRET'}},
+      {event_type:'tool.result',tool:'machine_fs',request_id:'filter-write-1234',created_at_utc:'2026-09-19T01:00:00.010Z',
+        outcome:{is_error:true,duration_ms:10,reason:'denied'}},
+      {event_type:'tool.request',tool:'coding_file_read',request_id:'filter-read-12345',created_at_utc:'2026-09-19T01:00:00.020Z',
+        args:{root_id:'projects',path:'x.txt',goal_id:'goal-1234'}},
+      {event_type:'tool.result',tool:'coding_file_read',request_id:'filter-read-12345',created_at_utc:'2026-09-19T01:00:00.030Z',
+        outcome:{is_error:true,duration_ms:10,reason:'missing'}}
+    ];
+    await writeFile(path.join(auditDir,'segment-00000001.jsonl'),audit.map(JSON.stringify).join('\n')+'\n','utf8');
+    const deadline=Date.now()+4000;
+    while(Date.now()<deadline&&!/machine_fs\.write.*trace=goal-1234/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/machine_fs\.write.*trace=goal-123\.\.\. span=filter-w\.\.\..*10ms.*ERR - denied/);
+    assert.doesNotMatch(output.stdout,/coding_file_read.*missing/);
+    assert.doesNotMatch(output.stdout,/SECRET/);
+    const journal=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-results',marker.result_session_id+'.json'),'utf8'));
+    assert.equal(journal.events.length,4,'presentation filter must not remove journal evidence');
+    child.stdin.end();
+    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    assert.equal(ended.timeout,undefined);
+    assert.equal(ended.code,0,output.stderr);
+  }finally{
+    if(child?.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});

package/test/tool-audit.test.mjs

@@ -132,3 +132,20 @@ test('controller enables audit only for Bridge child and restores parent audit e
   assert.match(source,/if \(\$hadAuditRuntimeEnv\) \{ \$env:DEADBYTE_AUDIT_RUNTIME = \$previousAuditRuntimeEnv \}/);
   assert.match(source,/else \{ Remove-Item Env:DEADBYTE_AUDIT_RUNTIME -ErrorAction SilentlyContinue \}/);
 });
+
+
+test('audit outcome reason preserves ordinary letters and Windows paths while folding actual whitespace',async()=>{
+  const root=await temp();
+  try{
+    const k=await keys(root);
+    const audit=await createToolAudit({stateRoot:root,signingKeyPath:k.privateKeyPath,contextProvider:async()=>context()});
+    const server=fakeServer();installToolAudit(server,audit);
+    server.registerTool('broken_read',{},async()=>({
+      isError:true,
+      structuredContent:{status:'error',error:"Error:\tENOENT: no such file or directory,\nrealpath 'D:\\\\Projects\\\\runtime'"}
+    }));
+    await server.handlers.get('broken_read')({path:'x'});
+    const all=await events(root);
+    assert.equal(all.at(-1).outcome.reason,"Error: ENOENT: no such file or directory, realpath 'D:\\\\Projects\\\\runtime'");
+  }finally{await rm(root,{recursive:true,force:true});}
+});