deadbyte-mcp 0.10.0 → 0.11.1

package/src/deadbyte-cli.mjs

@@ -9,14 +9,17 @@ import { fileURLToPath } from 'node:url';
 import { defaultPublicKeyPath } from './trust.mjs';
 import { verifyAuditChain } from './audit-verify.mjs';
 import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-result-journal.mjs';
-import { createLiveActivityTracker, formatCompactAuditEvent, formatRemoteLifecycle } from './remote-live-log.mjs';
+import { DEADBYTE_VERSION } from './version.mjs';
+import { createLiveTimelineTracker, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
   'armprocess','disarmprocess','processstatus','armhost','disarmhost','hoststatus','hosttest',
   'armcoding','disarmcoding','codingstatus','codingtest','armautonomous','disarmautonomous','autonomousstatus','autonomoustest'
 ]);
-const SESSION_START=['start','armprocess','armcoding','armautonomous'];
+const SESSION_ARM=['armprocess','armcoding','armautonomous'];
+const REMOTE_STATUS_TIMEOUT_MS=30000;
+const REMOTE_START_TIMEOUT_MS=150000;
 const SESSION_STATUS=[
   ['processstatus',/^Process plane\s*:\s*ARMED\b/m],
   ['codingstatus',/^Coding plane\s*:\s*ARMED\b/m],
@@ -34,9 +37,8 @@ function printHelp(){
   process.stdout.write([
     'DEADBYTE MCP CLI','',
     '  npx deadbyte-mcp@latest mcp                 # stdio MCP server for local clients',
-    '  npx deadbyte-mcp@latest remote              # compact foreground device session',
-    '  npx deadbyte-mcp@latest remote --verbose    # detailed audit + bridge logs',
-    '  npx deadbyte-mcp@latest remote --resume <cursor> # replay missed compact results, then reconnect',
+    '  npx deadbyte-mcp@latest remote              # unified foreground device session + live timeline',
+    '  npx deadbyte-mcp@latest remote --resume <cursor> # replay missed results, then reconnect',
     '  npx deadbyte-mcp@latest remote status',
     '  npx deadbyte-mcp@latest remote restart',
     '  npx deadbyte-mcp@latest supervisor status',
@@ -53,11 +55,16 @@ async function remoteContext(){
   const powershell=await requireRegular(path.join(systemRoot,'System32','WindowsPowerShell','v1.0','powershell.exe'),'Windows PowerShell');
   return {root,launcher,powershell};
 }
-function invokeController(ctx,command,{capture=false,allowFailure=false,echoCaptured=true}={}){
-  const result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],{
+function invokeController(ctx,command,{capture=false,allowFailure=false,echoCaptured=true,timeoutMs=null}={}){
+  const options={
     stdio:capture?['ignore','pipe','pipe']:'inherit',encoding:capture?'utf8':undefined,windowsHide:false,shell:false
-  });
-  if(result.error) throw result.error;
+  };
+  if(Number.isInteger(timeoutMs)&&timeoutMs>0) options.timeout=timeoutMs;
+  const result=spawnSync(ctx.powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',ctx.launcher,command],options);
+  if(result.error){
+    if(result.error?.code==='ETIMEDOUT') throw new Error(`remote controller '${command}' timed out after ${timeoutMs}ms`);
+    throw result.error;
+  }
   const status=Number.isInteger(result.status)?result.status:1;
   const stdout=capture?String(result.stdout||''):'';
   const stderr=capture?String(result.stderr||''):'';
@@ -65,6 +72,14 @@ function invokeController(ctx,command,{capture=false,allowFailure=false,echoCapt
   if(status!==0&&!allowFailure) throw new Error(`remote controller '${command}' failed exit=${status}`);
   return {status,stdout,stderr};
 }
+function controllerRuntimeReady(text){
+  const value=String(text||'');
+  return /^DEADBYTE MCP\s*=\s*ONLINE\s*$/m.test(value)&&
+    /^Bridge PID\s*:\s*\d+\s+\[verified\]\s*$/m.test(value)&&
+    /^Cloud PID\s*:\s*\d+\s+\[verified\]\s*$/m.test(value)&&
+    /^Local ready\s*:\s*True\s*$/m.test(value)&&
+    /^Loop supervisor:\s*RUNNING\s+\[verified\]\s*$/m.test(value);
+}
 async function listLogFiles(root){
   const files=[];
   const audit=path.join(root,'audit');
@@ -78,46 +93,30 @@ async function listLogFiles(root){
   }
   return files;
 }
-function formatLogLine(file,line,{verbose=false,activityTracker=null}={}){
+function formatLogLine(file,line,{activityTracker=null}={}){
   if(!line) return null;
   if(/^segment-\d{8}\.jsonl$/.test(path.basename(file))){
     try{
       const event=JSON.parse(line);
-      if(!verbose) return activityTracker?activityTracker.observe(event):formatCompactAuditEvent(event);
-      const seq=Number.isInteger(event.seq)?`#${event.seq}`:'#?';
-      const request=typeof event.request_id==='string'?` ${event.request_id.slice(0,8)}`:'';
-      const tool=typeof event.tool==='string'?` ${event.tool}`:'';
-      let marker='';
-      if(event.event_type==='tool.request') marker='📥 ';
-      else if(event.event_type==='tool.result'){
-        if(event.outcome?.is_error===true) marker='📤❌ ';
-        else if(event.outcome?.is_error===false) marker='📤✅ ';
-        else marker='📤 ';
-      }
-      return `${marker}[AUDIT ${seq}] ${event.event_type||'event'}${tool}${request}`;
-    }catch{return verbose?`[AUDIT] ${line}`:null;}
-  }
-  if(!verbose) return null;
-  const label=path.basename(file).replace(/\.log$/i,'').toUpperCase();
-  let marker='';
-  if(/\[TOOL IN \]/.test(line)) marker='📥 ';
-  else if(/\[TOOL OUT\]/.test(line)){
-    if(/"is_error"\s*:\s*true/.test(line)) marker='📤❌ ';
-    else if(/"is_error"\s*:\s*false/.test(line)) marker='📤✅ ';
-    else marker='📤 ';
+      return activityTracker?activityTracker.observe(event):formatCompactAuditEvent(event);
+    }catch{return null;}
   }
-  return `${marker}[${label}] ${line}`;
+  return formatRuntimeDiagnosticLine(file,line);
 }
 function remoteResultJournalPath(root,sessionId){return path.join(root,'runtime','remote-results',`${sessionId}.json`);}
-function auditTerminalResult(file,line){
+function auditTimelineRecord(file,line){
   if(!/^segment-\d{8}\.jsonl$/.test(path.basename(file))||!line) return null;
   let event;try{event=JSON.parse(line);}catch{return null;}
-  if(event?.event_type!=='tool.result'||typeof event.request_id!=='string'||!event.request_id||typeof event.tool!=='string'||!event.tool) return null;
+  if(typeof event?.request_id!=='string'||!event.request_id||typeof event.tool!=='string'||!event.tool) return null;
   const observed=Number.isFinite(Date.parse(event.created_at_utc))?new Date(Date.parse(event.created_at_utc)).toISOString():new Date().toISOString();
-  return {request_id:event.request_id,tool:event.tool,status:event.outcome?.is_error===true?'error':'ok',observed_at_utc:observed,
-    payload_sha256:createHash('sha256').update(Buffer.from(line,'utf8')).digest('hex')};
+  const payload_sha256=createHash('sha256').update(Buffer.from(line,'utf8')).digest('hex');
+  if(event.event_type==='tool.request') return {event_type:'tool.call',request_id:event.request_id,tool:event.tool,
+    observed_at_utc:observed,arguments:event.args??{},payload_sha256};
+  if(event.event_type==='tool.result') return {event_type:'tool.result',request_id:event.request_id,tool:event.tool,
+    status:event.outcome?.is_error===true?'error':'ok',observed_at_utc:observed,payload_sha256};
+  return null;
 }
-async function replayRemoteResults(root,cursor,{verbose=false}={}){
+async function replayRemoteResults(root,cursor){
   const parsed=parseRemoteResultCursor(cursor);
   const file=remoteResultJournalPath(root,parsed.session_id);
   await requireRegular(file,'remote result journal');
@@ -126,8 +125,14 @@ async function replayRemoteResults(root,cursor,{verbose=false}={}){
   for(;;){
     const page=await journal.replayAfter(next,{limit:200});
     for(const event of page.events){
+      if(event.event_type==='tool.call'){
+        const line=formatRemoteToolCall({event_type:'tool.request',tool:event.tool,request_id:event.request_id,
+          observed_at_utc:event.observed_at_utc,args:event.arguments});
+        process.stdout.write(`${line} | REPLAY cursor r1:${event.session_id}:${event.seq}\n`);
+        continue;
+      }
       const marker=event.status==='error'?'[ERR]':'[OK]';
-      process.stdout.write(`${verbose?'[REPLAY] ': '[REPLAY] '}${marker} ${event.tool} [cursor r1:${event.session_id}:${event.seq}]\n`);
+      process.stdout.write(`[REPLAY] ${marker} ${event.tool} [cursor r1:${event.session_id}:${event.seq}]\n`);
     }
     next=page.next_cursor;
     if(!page.has_more) return next;
@@ -151,10 +156,8 @@ async function snapshotRemoteLogOffsets(root){
   }
   return offsets;
 }
-async function tailRemoteLogs(root,signal,{verbose=false,journal=null,offsets=null,activityTracker=null}={}){
-  process.stdout.write(verbose
-    ?'📜 [LOG] Live logs active. Press Ctrl+C to disconnect and revoke authority.\n'
-    :'[LOG] Live activity. Ctrl+C disconnects and revokes authority.\n');
+async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTracker=null}={}){
+  process.stdout.write('[LOG] Unified live timeline. Ctrl+C disconnects and revokes authority.\n');
   const activeOffsets=offsets??await snapshotRemoteLogOffsets(root);
   while(!signal.aborted){
     for(const file of await listLogFiles(root)){
@@ -162,25 +165,25 @@ async function tailRemoteLogs(root,signal,{verbose=false,journal=null,offsets=nu
       const next=await readAppend(file,prior);
       activeOffsets.set(file,next.offset);
       for(const line of next.text.split(/\r?\n/)){
-        const terminal=auditTerminalResult(file,line);
+        const timeline=auditTimelineRecord(file,line);
         let recorded=null;
-        if(terminal&&journal) recorded=await journal.recordTerminal(terminal);
-        if(recorded?.duplicate&&!verbose) continue;
-        const formatted=formatLogLine(file,line,{verbose,activityTracker});
+        if(timeline&&journal) recorded=timeline.event_type==='tool.call'
+          ? await journal.recordCall(timeline)
+          : await journal.recordTerminal(timeline);
+        if(recorded?.duplicate) continue;
+        const formatted=formatLogLine(file,line,{activityTracker});
         if(!formatted) continue;
-        if(!verbose&&recorded) process.stdout.write(`${formatted} [cursor ${recorded.cursor}]\n`);
+        if(recorded) process.stdout.write(`${formatted} [cursor ${recorded.cursor}]\n`);
         else process.stdout.write(`${formatted}\n`);
       }
     }
     try{await sleep(250,null,{signal});}catch(error){if(error?.name!=='AbortError') throw error;}
   }
 }
-async function cleanupRemoteSession(ctx,{verbose=false}={}){
+async function cleanupRemoteSession(ctx){
   for(const command of SESSION_CLEANUP){
     try{
-      const result=invokeController(ctx,command,verbose
-        ?{allowFailure:true}
-        :{allowFailure:true,capture:true,echoCaptured:false});
+      const result=invokeController(ctx,command,{allowFailure:true,capture:true,echoCaptured:false});
       if(result.status!==0) process.stderr.write(`⚠️ [WARN] cleanup ${command} exit=${result.status}\n`);
     }
     catch(error){process.stderr.write(`⚠️ [WARN] cleanup ${command}: ${String(error?.message||error)}\n`);}
@@ -259,15 +262,15 @@ async function releaseRemoteSession(ctx,marker){
   const same=current?.schema==='deadbyte.remote-session.v2'&&current.owner_pid===marker.owner_pid&&current.session_nonce===marker.session_nonce;
   if(same) await rm(remoteSessionMarker(ctx.root),{force:true});
 }
-async function runRemoteSession({verbose=false,resumeCursor=null}={}){
+async function runRemoteSession({resumeCursor=null}={}){
   const ctx=await remoteContext();
-  if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{verbose});
+  if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor);
   await recoverRemoteSession(ctx);
   const marker=await claimRemoteSession(ctx);
   const resultJournal=await openRemoteResultJournal({
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
-  const activityTracker=createLiveActivityTracker();
+  const activityTracker=createLiveTimelineTracker();
   const aborter=new AbortController();
   const abort=()=>aborter.abort();
   const watchStdin=!process.stdin.isTTY;
@@ -276,67 +279,56 @@ async function runRemoteSession({verbose=false,resumeCursor=null}={}){
   let ready=false;
   let logTask=null;
   try{
-    if(verbose) process.stdout.write('DEADBYTE MCP DEVICE SESSION\n');
-    else process.stdout.write('DEADBYTE MCP\n');
+    process.stdout.write('DEADBYTE MCP\n');
     process.stdout.write(`${formatRemoteLifecycle('device_start')}\n`);
     process.stdout.write(`${formatRemoteLifecycle(resumeCursor!==null?'session_restored':'session_new')}\n`);
     const logOffsets=await snapshotRemoteLogOffsets(ctx.root);
-    logTask=tailRemoteLogs(ctx.root,aborter.signal,{verbose,journal:resultJournal,offsets:logOffsets,activityTracker});
-    if(verbose) process.stdout.write('[INFO] Starting local + remote runtime...\n');
-    else process.stdout.write('[BOOT] Starting local + remote runtime...\n');
-    const started=[];
-    for(const command of SESSION_START){
-      if(!verbose){
-        if(command==='start') process.stdout.write('[BOOT] Starting bridge/runtime...\n');
-        else process.stdout.write(`🔐 [AUTH] Arming ${command.slice(3)}...\n`);
-      }
-      const controllerResult=invokeController(ctx,command,verbose?{}:{capture:true,echoCaptured:false});
-      started.push(controllerResult);
-      if(command==='start'){
-        process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);
-        process.stdout.write(`${formatRemoteLifecycle('cloud_connected')}\n`);
-      }
+    logTask=tailRemoteLogs(ctx.root,aborter.signal,{journal:resultJournal,offsets:logOffsets,activityTracker});
+    process.stdout.write('[BOOT] Starting local + remote runtime...\n');
+    const preflight=invokeController(ctx,'status',{capture:true,allowFailure:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+    let startText=preflight.stdout||'';
+    if(preflight.status===0&&controllerRuntimeReady(preflight.stdout)){
+      process.stdout.write('[BOOT] Runtime already ONLINE; reusing verified bridge/cloud/supervisor.\n');
+    }else{
+      process.stdout.write('[BOOT] Starting bridge/runtime...\n');
+      const started=invokeController(ctx,'start',{capture:true,echoCaptured:false,timeoutMs:REMOTE_START_TIMEOUT_MS});
+      startText=started.stdout||'';
+    }
+    process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);
+    process.stdout.write(`${formatRemoteLifecycle('cloud_connected')}\n`);
+    for(const command of SESSION_ARM){
+      process.stdout.write(`🔐 [AUTH] Arming ${command.slice(3)}...\n`);
+      invokeController(ctx,command,{capture:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
     }
-    if(!verbose){
-      const startText=started[0]?.stdout||'';
-      const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
-      process.stdout.write('[OK] ONLINE\n');
-      process.stdout.write(`${formatRemoteLifecycle('ready')}\n`);
-      if(url) process.stdout.write(`URL: ${url}\n`);
-      process.stdout.write('🔐 [AUTH] Verifying process, coding, autonomous; host must stay DISARMED...\n');
-    }else process.stdout.write('🛡️ [AUTHORITY] Verifying runtime planes; host must stay DISARMED...\n');
+    const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
+    process.stdout.write('[OK] ONLINE\n');
+    process.stdout.write(`${formatRemoteLifecycle('ready')}\n`);
+    if(url) process.stdout.write(`URL: ${url}\n`);
+    process.stdout.write('🔐 [AUTH] Verifying process, coding, autonomous; host must stay DISARMED...\n');
     for(const [command,pattern] of SESSION_STATUS){
-      const result=invokeController(ctx,command,{capture:true,echoCaptured:verbose});
+      const result=invokeController(ctx,command,{capture:true,echoCaptured:false});
       if(!pattern.test(result.stdout)) throw new Error(`remote session authority verification failed: ${command} state mismatch`);
     }
     ready=true;
-    if(verbose) process.stdout.write('[DEVICE] DEADBYTE MCP online; process/coding/autonomous ARMED; host DISARMED.\n');
-    else process.stdout.write('🔐 [AUTH] ARMED: process, coding, autonomous | host DISARMED\n');
+    process.stdout.write('🔐 [AUTH] ARMED: process, coding, autonomous | host DISARMED\n');
     await logTask;
   }finally{
     const wasAborted=aborter.signal.aborted;
     aborter.abort();
     if(logTask) await logTask.catch(()=>{});
-    if(!verbose){for(const line of activityTracker.reconcileInterrupted('session_end')) process.stdout.write(`${line}\n`);}
+    for(const line of activityTracker.reconcileInterrupted('session_end')) process.stdout.write(`${line}\n`);
     process.removeListener('SIGINT',abort);process.removeListener('SIGTERM',abort);
     if(watchStdin){process.stdin.removeListener('end',abort);process.stdin.removeListener('close',abort);process.stdin.pause();}
     process.stdout.write(`${formatRemoteLifecycle('cleanup')}\n`);
-    if(ready||!wasAborted) process.stdout.write(verbose?'[INFO] Closing remote device session and revoking authority...\n':'[INFO] Disconnecting; revoking authority...\n');
-    await cleanupRemoteSession(ctx,{verbose});
+    if(ready||!wasAborted) process.stdout.write('[INFO] Disconnecting; revoking authority...\n');
+    await cleanupRemoteSession(ctx);
     await releaseRemoteSession(ctx,marker);
   }
 }
 async function runRemote(args){
   if(args.length===0){await runRemoteSession();return;}
-  if(args.length===1&&args[0]==='--verbose'){await runRemoteSession({verbose:true});return;}
   if(args.length===2&&args[0]==='--resume'){await runRemoteSession({resumeCursor:args[1]});return;}
-  if(args.length===3&&args[0]==='--verbose'&&args[1]==='--resume'){
-    await runRemoteSession({verbose:true,resumeCursor:args[2]});return;
-  }
-  if(args.length===3&&args[0]==='--resume'&&args[2]==='--verbose'){
-    await runRemoteSession({verbose:true,resumeCursor:args[1]});return;
-  }
-  if(args.length>1) throw new Error('remote accepts one controller command, --verbose, or --resume <cursor>');
+  if(args.length>1) throw new Error('remote accepts one controller command or --resume <cursor>');
   const command=args[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);
   const ctx=await remoteContext();
   const result=invokeController(ctx,command,{allowFailure:true});
@@ -359,6 +351,10 @@ async function runAudit(args){
 }
 async function main(argv){
   const [command,...rest]=argv;
+  if(command==='--version'||command==='-v'||command==='version'){
+    if(rest.length) throw new Error('version accepts no arguments');
+    process.stdout.write(`${DEADBYTE_VERSION}\n`);return;
+  }
   if(!command||command==='help'||command==='--help'||command==='-h'){printHelp();return;}
   if(command==='mcp'){
     if(rest.length) throw new Error('mcp accepts no arguments');

package/src/effect-ledger.mjs

@@ -0,0 +1,47 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const EFFECT_LEDGER_SCHEMA='deadbyte.effect-ledger.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,128}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+
+function assertHex(name,value){if(!HEX64.test(value??'')) throw new Error(`${name} must be sha256`);}
+function assertId(name,value){if(!ID.test(value??'')) throw new Error(`${name} invalid`);}
+
+export function effectIdentity({goalId,planId,stepId,mutationEpoch,action,observationHeadSha256=null}){
+  assertHex('goalId',goalId);
+  assertHex('planId',planId);
+  assertId('stepId',stepId);
+  if(!Number.isInteger(mutationEpoch)||mutationEpoch<0) throw new Error('mutationEpoch invalid');
+  if(!action||typeof action!=='object'||Array.isArray(action)||typeof action.kind!=='string') throw new Error('action invalid');
+  if(observationHeadSha256!==null) assertHex('observationHeadSha256',observationHeadSha256);
+  const effectShape={schema:EFFECT_LEDGER_SCHEMA,kind:action.kind,mutation_epoch:mutationEpoch,
+    observation_head_sha256:observationHeadSha256,action};
+  const fingerprint=sha(effectShape);
+  const identity={schema:EFFECT_LEDGER_SCHEMA,goal_id:goalId,plan_id:planId,step_id:stepId,
+    mutation_epoch:mutationEpoch,fingerprint};
+  return Object.freeze({...identity,effect_id:sha(identity)});
+}
+
+export function loopGuardDisposition(events,candidate,{maxRepeats=3,window=24}={}){
+  if(!Array.isArray(events)) throw new Error('effect events must be array');
+  if(!candidate||!HEX64.test(candidate.fingerprint??'')) throw new Error('effect candidate invalid');
+  if(!Number.isInteger(maxRepeats)||maxRepeats<1) throw new Error('maxRepeats invalid');
+  if(!Number.isInteger(window)||window<1) throw new Error('window invalid');
+  const recent=events.slice(-window);
+  const started=recent.filter(event=>event?.type==='effect_started'&&event.payload?.fingerprint===candidate.fingerprint);
+  const terminal=new Set(recent.filter(event=>['effect_completed','effect_failed'].includes(event?.type)&&HEX64.test(event.payload?.effect_id??''))
+    .map(event=>event.payload.effect_id));
+  const repeated=started.filter(event=>terminal.has(event.payload?.effect_id)).length;
+  return Object.freeze({allowed:repeated<maxRepeats,reason:repeated<maxRepeats?'allowed':'effect_repeat_limit',
+    repeated_count:repeated,max_repeats:maxRepeats,fingerprint:candidate.fingerprint});
+}
+
+export function bindEffectCompletion(effect,outcome){
+  if(!effect||!HEX64.test(effect.effect_id??'')||!HEX64.test(effect.fingerprint??'')) throw new Error('effect identity invalid');
+  if(!outcome||typeof outcome!=='object'||Array.isArray(outcome)) throw new Error('effect outcome invalid');
+  const result_sha256=sha(outcome);
+  return Object.freeze({schema:'deadbyte.effect-completion.v1',effect_id:effect.effect_id,
+    fingerprint:effect.fingerprint,result_sha256});
+}

package/src/observation-lease.mjs

@@ -0,0 +1,32 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const OBSERVATION_LEASE_SCHEMA='deadbyte.observation-lease.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+
+export function issueObservationLease({goalId,mutationEpoch,observations,ttlMs=30000,nowMs=Date.now()}){
+  if(!HEX64.test(goalId??'')) throw new Error('goalId must be sha256');
+  if(!Number.isInteger(mutationEpoch)||mutationEpoch<0) throw new Error('mutationEpoch invalid');
+  if(!Array.isArray(observations)||observations.length<1) throw new Error('observations required');
+  if(!Number.isInteger(ttlMs)||ttlMs<100) throw new Error('ttlMs invalid');
+  if(!Number.isFinite(nowMs)||nowMs<0) throw new Error('nowMs invalid');
+  const latest=[...observations].reverse().find(item=>HEX64.test(item?.event_sha256??'')||HEX64.test(item?.receipt_sha256??'')||HEX64.test(item?.result_head_sha256??''));
+  if(!latest) throw new Error('observation identity unavailable');
+  const observation_head_sha256=HEX64.test(latest.result_head_sha256??'')?latest.result_head_sha256:
+    HEX64.test(latest.receipt_sha256??'')?latest.receipt_sha256:latest.event_sha256;
+  const body={schema:OBSERVATION_LEASE_SCHEMA,goal_id:goalId,mutation_epoch:mutationEpoch,observation_head_sha256,
+    issued_at_ms:nowMs,expires_at_ms:nowMs+ttlMs};
+  return Object.freeze({...body,lease_id:sha(body)});
+}
+
+export function verifyObservationLease(lease,{goalId,currentMutationEpoch,nowMs=Date.now(),observationHeadSha256=null}){
+  if(!lease||lease.schema!==OBSERVATION_LEASE_SCHEMA||!HEX64.test(lease.lease_id??'')) throw new Error('observation lease invalid');
+  const {lease_id,...body}=lease;
+  if(sha(body)!==lease_id) throw new Error('observation lease identity mismatch');
+  if(lease.goal_id!==goalId) throw new Error('observation lease goal mismatch');
+  if(lease.mutation_epoch!==currentMutationEpoch) throw new Error('observation lease stale mutation epoch');
+  if(nowMs>lease.expires_at_ms) throw new Error('observation lease expired');
+  if(observationHeadSha256!==null&&lease.observation_head_sha256!==observationHeadSha256) throw new Error('observation lease head mismatch');
+  return Object.freeze({ok:true,lease_id:lease.lease_id,observation_head_sha256:lease.observation_head_sha256,mutation_epoch:lease.mutation_epoch});
+}

package/src/remote-live-log.mjs

@@ -1,3 +1,6 @@
+import { canonicalJson } from './canonical-json.mjs';
+import { sanitizeAuditArgs } from './tool-audit.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({
   device_start:'🚀 [DEVICE] Starting DEADBYTE MCP...',
@@ -30,6 +33,25 @@ function summarizeArgs(args){
   return parts.length?` ${parts.join(' ')}`:'';
 }
 
+const TOOL_COLUMN_WIDTH=32;
+
+function eventTimestamp(event,clock){
+  for(const value of [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();
+  }
+  const value=Number(clock());
+  return new Date(Number.isFinite(value)?value:Date.now()).toISOString();
+}
+
+export function formatRemoteToolCall(event,{clock=()=>Date.now()}={}){
+  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)}`;
+}
+
 function formatDuration(ms){
   const value=Number(ms);
   if(!Number.isFinite(value)||value<0) return '';
@@ -74,3 +96,62 @@ export function createLiveActivityTracker(){
     }
   });
 }
+
+
+function shortSpanId(requestId){
+  return typeof requestId==='string'&&requestId.length?requestId.slice(0,8):'????????';
+}
+
+export function createLiveTimelineTracker({clock=()=>Date.now()}={}){
+  if(typeof clock!=='function') throw new Error('live timeline clock must be a function');
+  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}`;
+      }
+      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;
+    }
+  });
+}
+
+
+export function formatRuntimeDiagnosticLine(file,line){
+  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]}`;
+  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]}`;
+  }
+  return null;
+}

package/src/remote-mcp-autonomous-smoke-client.mjs

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
 import { R36_COMPACT_GATEWAYS, R36_COMPACT_TOOL_LIMIT } from './remote-mcp-r36-parity-client.mjs';
 import { promptContexts, promptObservations, promptMutationEpoch } from './autonomous-live-state.mjs';
+import { classifyAutonomousTimeoutRecovery } from './autonomous-timeout-recovery.mjs';
 
 const endpointText = process.argv[2];
 if (!endpointText) throw new Error('usage: node src/remote-mcp-autonomous-smoke-client.mjs https://host/mcp/path');
@@ -26,22 +27,21 @@ function structured(result, label) {
   if (!result.structuredContent || typeof result.structuredContent !== 'object') throw new Error(`${label} returned no structured object`);
   return result.structuredContent;
 }
-async function recoverTimedOutGoal(client, goalId) {
+async function recoverTimedOutGoal(client, goalId, beforeJournalHead) {
   for (let poll = 0; poll < AUTONOMOUS_TIMEOUT_RECOVERY_MAX_POLLS; poll += 1) {
     const status = structured(await client.callTool(
       { name:'autonomous_goal_status', arguments:{ goal_id:goalId } },
       { timeout:30000, maxTotalTimeout:30000 }
     ), 'autonomous_goal_status');
-    if (status.state === 'succeeded') return status;
-    if (status.state === 'cancelled' || status.state === 'paused') {
+    const disposition=classifyAutonomousTimeoutRecovery(status,{beforeJournalHead});
+    if (disposition.kind === 'completed') return { kind:'completed', status };
+    if (disposition.kind === 'terminal_failure') {
       throw new Error(`autonomous goal became terminal after request timeout: ${JSON.stringify(status)}`);
     }
-    if (status.state !== 'pending' && status.state !== 'running') {
-      throw new Error(`autonomous goal returned unexpected recovery state: ${JSON.stringify(status)}`);
-    }
+    if (disposition.kind === 'resumable') return { kind:'resumable', status };
     await sleep(AUTONOMOUS_TIMEOUT_RECOVERY_POLL_MS);
   }
-  throw new Error('autonomous goal did not reach a durable terminal state after request timeout');
+  throw new Error('autonomous goal did not reach a durable terminal or resumable boundary after request timeout');
 }
 function messageText(content) {
   if (typeof content === 'string') return content;
@@ -137,6 +137,10 @@ try {
   let ran = null;
   let recoveredRequestTimeout = false;
   for (let requestRound = 0; requestRound < AUTONOMOUS_RUN_MAX_REQUESTS; requestRound += 1) {
+    const beforeRun=structured(await client.callTool(
+      { name:'autonomous_goal_status', arguments:{ goal_id:goalId } },
+      { timeout:30000, maxTotalTimeout:30000 }
+    ), 'autonomous_goal_status');
     try {
       ran = structured(await client.callTool(
         { name:'autonomous_goal_run', arguments:{ goal_id:goalId, max_cycles:AUTONOMOUS_RUN_MAX_CYCLES_PER_REQUEST } },
@@ -144,8 +148,10 @@ try {
       ), 'autonomous_goal_run');
     } catch (error) {
       if (String(error?.code ?? '') !== 'REQUEST_TIMEOUT') throw error;
-      const recovered = await recoverTimedOutGoal(client, goalId);
-      ran = { status:'completed', state:recovered.state, goal_id:goalId, recovered_from_timeout:true };
+      const recovered = await recoverTimedOutGoal(client, goalId, beforeRun.journal_head_sha256);
+      ran = recovered.kind === 'completed'
+        ? { status:'completed', state:recovered.status.state, goal_id:goalId, recovered_from_timeout:true }
+        : { status:'yielded', state:recovered.status.state, goal_id:goalId, recovered_from_timeout:true };
       recoveredRequestTimeout = true;
     }
     if (ran.status === 'completed' && ran.state === 'succeeded') break;

package/src/remote-result-journal.mjs

@@ -1,10 +1,12 @@
 import { lstat, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { sanitizeAuditArgs } from './tool-audit.mjs';
 
 export const REMOTE_RESULT_JOURNAL_SCHEMA='deadbyte.remote-result-journal.v1';
 const SESSION=/^[0-9a-f]{24}$/;
 const HASH=/^[0-9a-f]{64}$/;
 const STATUS=new Set(['ok','error']);
+const EVENT_TYPES=new Set(['tool.call','tool.result']);
 
 function text(value,label,max){
   if(typeof value!=='string'||value.length<1||value.length>max||value.includes('\0')) throw new Error(`${label} invalid`);
@@ -26,14 +28,22 @@ function validateEvent(raw,index=null){
   const sessionId=validateSession(raw.session_id);
   const requestId=text(raw.request_id,'remote result request_id',256);
   const tool=text(raw.tool,'remote result tool',128);
-  if(!STATUS.has(raw.status)) throw new Error('remote result status invalid');
+  const eventType=raw.event_type===undefined?'tool.result':raw.event_type;
+  if(!EVENT_TYPES.has(eventType)) throw new Error('remote result event_type invalid');
   const observed=iso(raw.observed_at_utc,'remote result observed_at_utc');
   if(typeof raw.payload_sha256!=='string'||!HASH.test(raw.payload_sha256)) throw new Error('remote result payload_sha256 invalid');
   if(index!==null&&seq!==index) throw new Error('remote result sequence mismatch');
-  return Object.freeze({session_id:sessionId,seq,request_id:requestId,tool,status:raw.status,
+  if(eventType==='tool.call'){
+    const rawArgs=raw.arguments??{};
+    if(!rawArgs||typeof rawArgs!=='object'||Array.isArray(rawArgs)) throw new Error('remote result call arguments invalid');
+    return Object.freeze({session_id:sessionId,seq,event_type:eventType,request_id:requestId,tool,
+      observed_at_utc:observed,payload_sha256:raw.payload_sha256,arguments:sanitizeAuditArgs(rawArgs)});
+  }
+  if(!STATUS.has(raw.status)) throw new Error('remote result status invalid');
+  return Object.freeze({session_id:sessionId,seq,event_type:eventType,request_id:requestId,tool,status:raw.status,
     observed_at_utc:observed,payload_sha256:raw.payload_sha256});
 }
-function identity(item){return `${item.request_id}\0${item.status}\0${item.payload_sha256}`;}
+function identity(item){return `${item.event_type}\0${item.request_id}\0${item.status??''}\0${item.payload_sha256}`;}
 export function parseRemoteResultCursor(cursor){
   if(typeof cursor!=='string') throw new Error('remote result cursor invalid');
   const match=/^r1:([0-9a-f]{24}):(0|[1-9][0-9]{0,15})$/.exec(cursor);
@@ -89,8 +99,17 @@ export async function openRemoteResultJournal({filePath,sessionId,maxEntries=204
   return Object.freeze({
     file_path:file,session_id:sid,
     cursor(){return cursorFor(sid,state.next_seq-1);},
+    async recordCall(input){
+      const candidate=validateEvent({session_id:sid,seq:state.next_seq,event_type:'tool.call',...input});
+      const key=identity(candidate);
+      const existing=state.events.find(event=>identity(event)===key);
+      if(existing) return {duplicate:true,event:existing,cursor:cursorFor(sid,state.next_seq-1)};
+      const event=candidate;
+      state.events.push(event);state.next_seq+=1;await persist();
+      return {duplicate:false,event,cursor:cursorFor(sid,event.seq)};
+    },
     async recordTerminal(input){
-      const candidate=validateEvent({session_id:sid,seq:state.next_seq,...input});
+      const candidate=validateEvent({session_id:sid,seq:state.next_seq,event_type:'tool.result',...input});
       const key=identity(candidate);
       const existing=state.events.find(event=>identity(event)===key);
       if(existing) return {duplicate:true,event:existing,cursor:cursorFor(sid,state.next_seq-1)};

package/src/version.mjs

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