deadbyte-mcp 0.15.26 → 0.15.28

package/src/deadbyte-cli.mjs

@@ -13,8 +13,9 @@ import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-resul
 import { DEADBYTE_VERSION } from './version.mjs';
 import { parseActivePointer } from './release-slot.mjs';
 import { printDoctor } from './doctor-r45.mjs';
-import { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine } from './remote-live-log.mjs';
+import { createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
 import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
+import { ensureRuntimeCoherence } from './runtime-coherence.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
@@ -29,12 +30,17 @@ const SESSION_STATUS=[
   ['processstatus',/^Process plane\s*:\s*ARMED\b/m],
   ['codingstatus',/^Coding plane\s*:\s*ARMED\b/m],
   ['autonomousstatus',/^Autonomous\s*:\s*ARMED\b/m],
+  ['desktopstatus',/^Desktop plane\s*:\s*DISARMED\b/m],
   ['hoststatus',/^Host plane\s*:\s*DISARMED\b/m]
 ];
-const SESSION_CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park'];
+const SESSION_CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park'];
 const SUPERVISOR_COMMANDS=Object.freeze({
   start:'supervisorstart',stop:'supervisorstop',status:'supervisorstatus',recover:'supervisorrecover'
 });
+const CURRENT_PACKAGE_ROOT=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const CURRENT_DEPLOY_SCRIPT=path.join(CURRENT_PACKAGE_ROOT,'scripts','deploy-r48.mjs');
+const REMOTE_UPDATE_TIMEOUT_MS=900000;
+const LIVE_LOG_DISCOVERY_INTERVAL_MS=1000;
 
 function stateRoot(){return path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));}
 async function requireRegular(file,label){const info=await lstat(file);if(!info.isFile()||info.isSymbolicLink()) throw new Error(`${label} must be a regular non-symlink file`);return file;}
@@ -94,6 +100,43 @@ async function reportVersionCoherence(root,{displayMode='ascii'}={}){
   writeRemote(process.stderr,`${remoteTag('warn',displayMode)} VERSION SKEW: CLI package ${DEADBYTE_VERSION}; active runtime ${active.version} (${active.release_id})\n`,displayMode);
   return active;
 }
+async function synchronizeForegroundRuntime(ctx,{displayMode='unicode'}={}){
+  const packageManifestSha256=createHash('sha256').update(await readFile(path.join(CURRENT_PACKAGE_ROOT,'MANIFEST.SHA256'))).digest('hex');
+  return ensureRuntimeCoherence({
+    cliVersion:DEADBYTE_VERSION,
+    packageManifestSha256,
+    readActive:()=>readActiveRuntimeBinding(ctx.root),
+    disarmPrivileged:async()=>{
+      for(const command of ['disarmhost','disarmdesktop']){
+        const result=invokeController(ctx,command,{capture:true,allowFailure:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+        if(result.status!==0) throw new Error(`runtime coherence '${command}' failed exit=${result.status}`);
+      }
+    },
+    activateCurrentPackage:async()=>{
+      const result=spawnSync(process.execPath,[CURRENT_DEPLOY_SCRIPT],{
+        cwd:CURRENT_PACKAGE_ROOT,
+        env:{...process.env,DEADBYTE_STATE_ROOT:ctx.root},
+        encoding:'utf8',
+        windowsHide:true,
+        shell:false,
+        timeout:REMOTE_UPDATE_TIMEOUT_MS,
+        maxBuffer:16*1024*1024
+      });
+      if(result.error){
+        if(result.error?.code==='ETIMEDOUT') throw new Error(`runtime coherence activation timed out after ${REMOTE_UPDATE_TIMEOUT_MS}ms`);
+        throw result.error;
+      }
+      if(result.status!==0){
+        const detail=boundedSingleLine(result.stderr||result.stdout||'no deployment output',2048);
+        throw new Error(`runtime coherence activation failed exit=${String(result.status)}: ${detail}`);
+      }
+    },
+    onEvent:event=>{
+      if(event.phase==='upgrade_start') writeRemote(process.stdout,`[UPDATE] Runtime ${event.from_version} -> ${event.to_version}; activating current package...\n`,displayMode);
+      else if(event.phase==='upgrade_complete') writeRemote(process.stdout,`[UPDATE] Runtime synchronized: ${event.release_id||event.to_version}\n`,displayMode);
+    }
+  });
+}
 async function readControllerStartFailure(root,command,{maxChars=2048}={}){
   const file=path.join(root,'runtime','controller-start-failure.json');
   let raw;
@@ -158,32 +201,34 @@ function controllerRuntimeDegraded(text){
   return /^DEADBYTE MCP\s*=\s*DEGRADED\s*$/m.test(String(text||''));
 }
 async function listLogFiles(root){
-  const files=[];
-  const audit=path.join(root,'audit');
-  const runtimeLogs=path.join(root,'runtime','logs');
-  for(const [dir,accept] of [
-    [audit,name=>/^segment-\d{8}\.jsonl$/.test(name)],
-    [runtimeLogs,name=>/\.log$/i.test(name)]
-  ]){
-    let names=[];try{names=await readdir(dir);}catch(error){if(error?.code==='ENOENT') continue;throw error;}
-    for(const name of names.sort()) if(accept(name)) files.push(path.join(dir,name));
-  }
-  return files;
+  const auditDir=path.join(root,'audit');
+  const runtimeDir=path.join(root,'runtime','logs');
+  let auditNames=[],runtimeNames=[];
+  try{auditNames=await readdir(auditDir);}catch(error){if(error?.code!=='ENOENT') throw error;}
+  try{runtimeNames=await readdir(runtimeDir);}catch(error){if(error?.code!=='ENOENT') throw error;}
+  const selected=selectLiveLogNames({auditNames,runtimeNames});
+  return [
+    ...selected.audit.map(name=>path.join(auditDir,name)),
+    ...selected.runtime.map(name=>path.join(runtimeDir,name))
+  ];
+}
+function parseAuditLogLine(file,line){
+  if(!/^segment-\d{8}\.jsonl$/.test(path.basename(file))||!line) return null;
+  try{return JSON.parse(line);}catch{return null;}
 }
-function formatLogLine(file,line,{activityTracker=null,sequence=null,verbose=false,displayMode='unicode'}={}){
+function formatLogLine(file,line,{auditEvent=null,activityTracker=null,sequence=null,verbose=false,displayMode='unicode'}={}){
   if(!line) return null;
   if(/^segment-\d{8}\.jsonl$/.test(path.basename(file))){
-    try{
-      const event=JSON.parse(line);
-      return activityTracker?activityTracker.observe(event,{sequence}):formatCompactAuditEvent(event);
-    }catch{return null;}
+    const event=auditEvent??parseAuditLogLine(file,line);
+    if(!event) return null;
+    return activityTracker?activityTracker.observe(event,{sequence}):formatCompactAuditEvent(event);
   }
   return formatRuntimeDiagnosticLine(file,line,{verbose,displayMode});
 }
 function remoteResultJournalPath(root,sessionId){return path.join(root,'runtime','remote-results',`${sessionId}.json`);}
-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;}
+function auditTimelineRecord(file,line,auditEvent=null){
+  const event=auditEvent??parseAuditLogLine(file,line);
+  if(!event) return null;
   if(typeof event?.request_id!=='string'||!event.request_id||typeof event.tool!=='string'||!event.tool) return null;
   const stamp=[event.ts,event.created_at_utc,event.observed_at_utc].find(value=>typeof value==='string'&&Number.isFinite(Date.parse(value)));
   const observed=stamp?new Date(Date.parse(stamp)).toISOString():new Date().toISOString();
@@ -239,7 +284,8 @@ async function readAppend(file,offset){
 }
 async function snapshotRemoteLogOffsets(root){
   const offsets=new Map();
-  for(const file of await listLogFiles(root)){
+  const files=await listLogFiles(root);
+  for(const file of files){
     try{offsets.set(file,(await stat(file)).size);}catch{}
   }
   return offsets;
@@ -264,20 +310,28 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
     ? '[LOG] Verbose live timeline. Full sanitized request detail enabled; Ctrl+C disconnects and revokes authority.\n'
     : '[LOG] Human live timeline. Transport IN/OUT hidden; full replay/audit detail remains on disk. Ctrl+C disconnects and revokes authority.\n');
   const activeOffsets=offsets??await snapshotRemoteLogOffsets(root);
+  let liveFiles=[...activeOffsets.keys()];
+  let nextDiscoveryAt=0;
   while(!signal.aborted){
-    for(const file of await listLogFiles(root)){
+    const now=Date.now();
+    if(now>=nextDiscoveryAt){
+      liveFiles=await listLogFiles(root);
+      nextDiscoveryAt=now+LIVE_LOG_DISCOVERY_INTERVAL_MS;
+    }
+    for(const file of liveFiles){
       const prior=activeOffsets.has(file)?activeOffsets.get(file):0;
       const next=await readAppend(file,prior);
       activeOffsets.set(file,next.offset);
       for(const line of next.text.split(/\r?\n/)){
-        const timeline=auditTimelineRecord(file,line);
+        const auditEvent=parseAuditLogLine(file,line);
+        const timeline=auditTimelineRecord(file,line,auditEvent);
         let recorded=null;
         if(timeline&&journal) recorded=timeline.event_type==='tool.call'
           ? await journal.recordCall(timeline)
           : await journal.recordTerminal(timeline);
         if(recorded?.duplicate) continue;
         const accepted=timelineFilter&&timeline?timelineFilter.accept(timelineFilterEvent(timeline)):true;
-        const formatted=formatLogLine(file,line,{activityTracker,sequence:recorded?.event?.seq??null,verbose,displayMode});
+        const formatted=formatLogLine(file,line,{auditEvent,activityTracker,sequence:recorded?.event?.seq??null,verbose,displayMode});
         if(!formatted||!accepted) continue;
         const output=Array.isArray(formatted)?formatted:[formatted];
         for(const item of output) if(item){
@@ -381,11 +435,17 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   const display=prepareRemoteConsole();
   const displayMode=display.mode;
   const ctx=await remoteContext();
-  await reportVersionCoherence(ctx.root,{displayMode});
   if(displayMode==='ascii') writeRemote(process.stdout,`[DISPLAY] ASCII fallback: ${display.reason}\n`,displayMode);
   if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{displayMode});
   await recoverRemoteSession(ctx,{displayMode});
   const marker=await claimRemoteSession(ctx);
+  try{
+    await synchronizeForegroundRuntime(ctx,{displayMode});
+  }catch(error){
+    await cleanupRemoteSession(ctx,{displayMode});
+    await releaseRemoteSession(ctx,marker,{displayMode});
+    throw error;
+  }
   const resultJournal=await openRemoteResultJournal({
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
@@ -442,13 +502,13 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
     process.stdout.write('[OK] ONLINE\n');
     process.stdout.write(`${formatRemoteLifecycle('ready',{displayMode})}\n`);
     if(url) writeRemote(process.stdout,`URL: ${url}\n`,displayMode);
-    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} Verifying process, coding, autonomous; host must stay DISARMED...\n`,displayMode);
+    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} Verifying process, coding, autonomous; desktop + host must stay DISARMED...\n`,displayMode);
     for(const [command,pattern] of SESSION_STATUS){
       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;
-    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} ARMED: process, coding, autonomous | host DISARMED\n`,displayMode);
+    writeRemote(process.stdout,`${remoteTag('auth',displayMode)} ARMED: process, coding, autonomous | desktop, host DISARMED\n`,displayMode);
     await logTask;
   }finally{
     const wasAborted=aborter.signal.aborted;

package/src/remote-live-log.mjs

@@ -53,6 +53,13 @@ const TOOL_ICONS_ASCII=Object.freeze({read:'R',write:'W',edit:'E',run:'>',verify
 const START_VISIBLE_PATTERNS=[/(?:^|_)file_write$/,/text_replace$/,/symbol_replace$/,/native_diff_(?:apply|preview)$/,
   /(?:command|benchmark)_run$/,/task_run$/,/goal_run$/,/goal_submit$/,/goal_approve$/,/process_session_(?:start|action|terminate)$/,/^desktop_action$/];
 
+export function selectLiveLogNames({auditNames=[],runtimeNames=[]}={}){
+  if(!Array.isArray(auditNames)||!Array.isArray(runtimeNames)) throw new Error('live log names must be arrays');
+  const audit=auditNames.filter(name=>typeof name==='string'&&/^segment-\d{8}\.jsonl$/.test(name)).sort().slice(-2);
+  const runtime=runtimeNames.filter(name=>typeof name==='string'&&/\.log$/i.test(name)).sort();
+  return Object.freeze({audit:Object.freeze(audit),runtime:Object.freeze(runtime)});
+}
+
 export function truncateUtf8(value,maxBytes,{ellipsis='…'}={}){
   if(typeof value!=='string'||!Number.isInteger(maxBytes)||maxBytes<1) return '';
   const bytes=new TextEncoder().encode(value);
@@ -312,18 +319,19 @@ export function createLiveTimelineWriter({stream=process.stdout,displayMode='uni
   return Object.freeze({write,flush,pending(){return active?{...active}:null;}});
 }
 
-export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false}={}){
+export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false,slowCallMs=1000}={}){
   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');
+  if(!Number.isInteger(slowCallMs)||slowCallMs<100||slowCallMs>600000) throw new Error('live timeline slowCallMs invalid');
   const pending=new Map();
   const completed=new Set();
   const toolCounts=new Map();
   const durationSamples=[];
-  let resultCount=0,okCount=0,errorCount=0,unknownCount=0,mutationCount=0,totalDurationMs=0,slowest=null,burst=null,foldedHeartbeatLines=0;
+  let resultCount=0,okCount=0,errorCount=0,unknownCount=0,mutationCount=0,totalDurationMs=0,slowest=null,burst=null,foldedHeartbeatLines=0,peakInFlight=0;
 
   function eventPrefix(event,sequence,{displayTool=null,icon=null}={}){
     const seq=Number.isSafeInteger(sequence)&&sequence>0?'#'+sequence+'  ':'';
@@ -336,9 +344,11 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
     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)
+    const rawDuration=Number(event.outcome?.duration_ms);
+    const duration=Number.isFinite(rawDuration)
+      ?formatDuration(rawDuration)
       :span?formatDuration(Math.max(0,clock()-span.started_at_ms)):'';
+    const slow=Number.isFinite(rawDuration)&&rawDuration>=slowCallMs?'  [SLOW]':'';
     const summary=span?.summary||'';
     const rawReason=typeof event.outcome?.reason==='string'&&event.outcome.reason?event.outcome.reason:
       (unknown&&typeof event.outcome?.recovery?.reason==='string'?event.outcome.recovery.reason:'');
@@ -353,7 +363,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
     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);
+    return remoteDisplayText(eventPrefix(event,sequence,{displayTool,icon:prefixIcon})+traceSuffix(span?.trace_meta)+(summary?'  '+summary:'')+(duration?'  '+duration:'')+slow+'  '+marker+evidence+(reason?reasonSep+reason:''),displayMode);
   }
   function burstLine(value){
     if(!value) return null;
@@ -396,6 +406,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
       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()});
+      peakInFlight=Math.max(peakInFlight,pending.size);
       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;
@@ -453,6 +464,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
       ' | tool time '+(formatDuration(totalDurationMs)||'0ms')+
       (p50!==null?' | p50 '+formatDuration(p50)+' | p95 '+formatDuration(p95):'')+
       (slowest?' | slowest '+slowest.tool+' '+formatDuration(slowest.duration_ms):'')+
+      ' | peak in-flight '+peakInFlight+
       (foldedHeartbeatLines?' | folded '+foldedHeartbeatLines+' heartbeat lines':'')+
       (top?' | top: '+top:''),displayMode);
   }

package/src/remote-session-guardian.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 
-const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park'];
+const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park'];
 
 function parseArgs(argv){
   const out={};

package/src/runtime-coherence.mjs

@@ -0,0 +1,50 @@
+const SEMVER=/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+const HEX64=/^[0-9a-f]{64}$/;
+
+function parseSemver(value){
+  const match=SEMVER.exec(String(value??''));
+  if(!match) throw new Error(`runtime version invalid: ${String(value)}`);
+  return {major:Number(match[1]),minor:Number(match[2]),patch:Number(match[3]),prerelease:match[4]??null};
+}
+export function compareRuntimeVersions(a,b){
+  const left=parseSemver(a),right=parseSemver(b);
+  for(const key of ['major','minor','patch']) if(left[key]!==right[key]) return left[key]<right[key]?-1:1;
+  if(left.prerelease===right.prerelease) return 0;
+  if(left.prerelease===null) return 1;
+  if(right.prerelease===null) return -1;
+  return left.prerelease.localeCompare(right.prerelease,'en',{numeric:true,sensitivity:'case'});
+}
+function assertManifest(value,label){
+  if(!HEX64.test(String(value??''))) throw new Error(`${label} must be lowercase SHA-256`);
+  return value;
+}
+export async function ensureRuntimeCoherence({
+  cliVersion,packageManifestSha256,readActive,disarmPrivileged,activateCurrentPackage,onEvent=()=>{}
+}={}){
+  parseSemver(cliVersion);assertManifest(packageManifestSha256,'package manifest');
+  if(typeof readActive!=='function'||typeof disarmPrivileged!=='function'||typeof activateCurrentPackage!=='function'||typeof onEvent!=='function') {
+    throw new Error('runtime coherence callbacks invalid');
+  }
+  const initial=await readActive();
+  if(!initial) return {status:'unbound',active:null};
+  const activeVersion=String(initial.version??'');
+  const relation=compareRuntimeVersions(cliVersion,activeVersion);
+  if(relation===0){
+    if(String(initial.manifest_sha256??'')!==packageManifestSha256) {
+      throw new Error(`runtime manifest skew for ${cliVersion}: package ${packageManifestSha256}; active ${String(initial.manifest_sha256??'missing')}`);
+    }
+    return {status:'coherent',active:initial};
+  }
+  if(relation<0) throw new Error(`active runtime ${activeVersion} is newer than CLI package ${cliVersion}; refusing automatic downgrade`);
+  onEvent({phase:'upgrade_start',from_version:activeVersion,to_version:cliVersion,from_release_id:initial.release_id??null});
+  await disarmPrivileged();
+  await activateCurrentPackage();
+  const active=await readActive();
+  if(!active) throw new Error('runtime coherence activation completed without active release pointer');
+  if(String(active.version??'')!==cliVersion) throw new Error(`runtime coherence activation version mismatch: expected ${cliVersion}, found ${String(active.version??'missing')}`);
+  if(String(active.manifest_sha256??'')!==packageManifestSha256) {
+    throw new Error(`runtime coherence activation manifest mismatch: expected ${packageManifestSha256}, found ${String(active.manifest_sha256??'missing')}`);
+  }
+  onEvent({phase:'upgrade_complete',from_version:activeVersion,to_version:cliVersion,release_id:active.release_id??null});
+  return {status:'upgraded',active};
+}

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.26';
+export const DEADBYTE_VERSION = '0.15.28';
 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/coding-runtime.test.mjs

@@ -39,7 +39,7 @@ async function fixture({ armed = true } = {}) {
   }
   const runtime = createCodingRuntime({ policy, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath });
   const tasks = createCodingTaskRuntime({ codingRuntime: runtime, signingKeyPath: keys.privateKeyPath, verifyKeyPath: keys.publicKeyPath });
-  return { root, project, policy, runtime, tasks };
+  return { root, project, policy, runtime, tasks, keys };
 }
 test('coding plane edits files under lease and verifies signed action receipts', async () => {
   const f = await fixture();
@@ -233,3 +233,37 @@ test('coding task rejects recomputed journal content without the private signing
     await assert.rejects(() => f.tasks.status({ taskId: submitted.task_id }), /signature verification failed|hash-chain mismatch/);
   } finally { await rm(f.root, { recursive: true, force: true }); }
 });
+
+
+test('R51 coding command retries reuse one in-flight execution and completed receipt', async () => {
+  const f = await fixture();
+  try {
+    const script = path.join(f.project, 'dedup.mjs');
+    await writeFile(script, "import { appendFileSync } from 'node:fs'; appendFileSync('runs.txt', process.pid+'\\n'); await new Promise(r=>setTimeout(r,250)); process.stdout.write('dedup-ok');");
+    const args={rootId:'project',commandId:'node_script',scriptPath:'dedup.mjs',scriptSha256:await sha256File(script),timeoutMs:5000};
+    const [a,b]=await Promise.all([f.runtime.commandRun(args),f.runtime.commandRun(args)]);
+    assert.equal(a.status,'passed',a.stderr);assert.equal(b.status,'passed',b.stderr);
+    assert.equal(a.request_sha256,b.request_sha256);
+    assert.equal(a.receipt_id,b.receipt_id,'same logical request must reuse the same signed execution receipt');
+    const c=await f.runtime.commandRun(args);
+    assert.equal(c.receipt_id,a.receipt_id,'completed retry must reuse bounded cached execution result');
+    const runs=(await readFile(path.join(f.project,'runs.txt'),'utf8')).trim().split(/\\r?\\n/).filter(Boolean);
+    assert.equal(runs.length,1,'retry spawned duplicate child process');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R51 coding command single-flight spans independent runtime instances sharing evidence state', async () => {
+  const f = await fixture();
+  try {
+    const script = path.join(f.project, 'cross-runtime-dedup.mjs');
+    await writeFile(script, "import { appendFileSync } from 'node:fs'; appendFileSync('cross-runs.txt', process.pid+'\\n'); await new Promise(r=>setTimeout(r,500)); process.stdout.write('cross-ok');");
+    const second = createCodingRuntime({ policy:f.policy, signingKeyPath:f.keys.privateKeyPath, verifyKeyPath:f.keys.publicKeyPath });
+    const args={rootId:'project',commandId:'node_script',scriptPath:'cross-runtime-dedup.mjs',scriptSha256:await sha256File(script),timeoutMs:5000};
+    const [a,b]=await Promise.all([f.runtime.commandRun(args),second.commandRun(args)]);
+    assert.equal(a.status,'passed',a.stderr);assert.equal(b.status,'passed',b.stderr);
+    assert.equal(a.request_sha256,b.request_sha256);
+    assert.equal(a.receipt_id,b.receipt_id,'shared evidence state must converge on one signed execution receipt');
+    const runs=(await readFile(path.join(f.project,'cross-runs.txt'),'utf8')).trim().split(/\\r?\\n/).filter(Boolean);
+    assert.equal(runs.length,1,'independent runtime instances spawned duplicate child processes');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});

package/test/package-boundary.test.mjs

@@ -42,3 +42,9 @@ test('publish boundary excludes live state, private keys, grants and non-example
   const forbidden=files.filter(rel=>rel.startsWith('tmp/')||rel.startsWith('.deadbyte-machine-fs-recovery/')||/(^|\/)(active-release\.json|runtime\/|audit\/|evidence\/)|\.pem$|(^|\/)deadbyte-controller\.config\.psd1$|(^|\/)deadbyte-host-policy\.json$|(^|\/)[^/]*(?:grant|arm)\.json$/i.test(rel));
   assert.deepEqual(forbidden,[]);
 });
+
+test('publish boundary includes only the canonical top-level Windows launcher',()=>{
+  const files=packFiles();
+  const launchers=files.filter(rel=>/^DEADBYTE-MCP.*\.cmd$/i.test(rel));
+  assert.deepEqual(launchers,['DEADBYTE-MCP.cmd']);
+});

package/test/production-docs.test.mjs

@@ -3,15 +3,17 @@ import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { DEADBYTE_VERSION } from '../src/version.mjs';
 
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const readme=()=>readFile(path.join(root,'README.txt'),'utf8');
+const versionPattern=DEADBYTE_VERSION.replace(/[.*+?^$()|[\]\\]/g,'\\$&');
 
 test('production README documents one-command stdio configs for major MCP clients',async()=>{
   const text=await readme();
-  assert.match(text,/npx -y deadbyte-mcp@0\.15\.5 mcp/);
+  assert.match(text,new RegExp(`npx -y deadbyte-mcp@${versionPattern} mcp`));
   assert.match(text,/CLAUDE DESKTOP/);
-  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.15\.5"[\s\S]*?"mcp"/);
+  assert.match(text,new RegExp(`"mcpServers"[\\s\\S]*?"command"\\s*:\\s*"npx"[\\s\\S]*?"-y"[\\s\\S]*?"deadbyte-mcp@${versionPattern}"[\\s\\S]*?"mcp"`));
   assert.match(text,/CURSOR/);
   assert.match(text,/\.cursor\/mcp\.json/);
   assert.match(text,/VS CODE/);
@@ -20,7 +22,7 @@ test('production README documents one-command stdio configs for major MCP client
   assert.match(text,/CODEX/);
   assert.match(text,/\[mcp_servers\.deadbyte\]/);
   assert.match(text,/command\s*=\s*"npx"/);
-  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.15\.5",\s*"mcp"\]/);
+  assert.match(text,new RegExp(`args\\s*=\\s*\\["-y",\\s*"deadbyte-mcp@${versionPattern}",\\s*"mcp"\\]`));
 });
 
 test('production README records tracer bullet, semantic scope, remote UX, safety and document extension',async()=>{

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

@@ -3,40 +3,32 @@ import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { DEADBYTE_VERSION } from '../src/version.mjs';
 
-const root=new URL('../',import.meta.url);
-const read=rel=>readFile(new URL(rel,root),'utf8');
+const root = new URL('../', import.meta.url);
+const read = rel => readFile(new URL(rel, root), 'utf8');
+const json = rel => read(rel).then(JSON.parse);
 
-test('R49 0.15.26 successor binds exact published immutable 0.15.25 parent',async()=>{
-  const [pkg,lock,release,provenance,matrix]=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),
-    read('TEST-MATRIX.json').then(JSON.parse)
+test('R48 compatibility release contract remains coherent in the current successor', async () => {
+  const [pkg, lock, release, provenance, matrix] = await Promise.all([
+    json('package.json'), json('package-lock.json'), json('RELEASE.json'),
+    json('PROVENANCE.json'), json('TEST-MATRIX.json')
   ]);
-  for(const value of [pkg.version,lock.version,lock.packages[''].version,DEADBYTE_VERSION,release.version,provenance.version,matrix.version])assert.equal(value,'0.15.26');
-  assert.equal(release.train,'R49');
-  assert.equal(release.label,'BOUNDED SEMANTIC DESKTOP WAIT + REMOTE CONTROL HARDENING');
-  assert.equal(release.parent.release_id,'v0.15.25-7ed657b1aa038ee6');
-  assert.equal(release.parent.manifest_sha256,'7ed657b1aa038ee679ff081f1a83c421a5eeb5fc7ea6b746e0f661079b69b319');
-  assert.equal(release.parent.generation_manifest_sha256,'c9763738e27ec39b1180473995f2af088d85293a94f5693abd6a843e09cecec9');
-  assert.equal(release.source_predecessor.version,'0.15.25');
-  assert.equal(release.source_predecessor.tarball_sha256,'0410b41b3c891210262a4db793ee3b339862472ef069f881c9e092c1083ba6d2');
-  assert.equal(release.source_predecessor.manifest_file_sha256,'7ed657b1aa038ee679ff081f1a83c421a5eeb5fc7ea6b746e0f661079b69b319');
-  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,117);
-  assert.equal(release.capabilities.desktop_bounded_semantic_wait,true);
-  assert.equal(release.capabilities.commander_incremental_pdf_revisions,true);
-  assert.equal(release.capabilities.commander_docx_header_footer_search,true);
-  assert.equal(release.capabilities.commander_directory_read_fallback,true);
-  assert.equal(release.capabilities.commander_binary_detection,true);
-  assert.equal(release.capabilities.commander_protocol_adversarial,true);
-  assert.equal(release.capabilities.atomic_mutation_unknown_effect,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);
-  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
-  assert.equal(matrix.predecessor_r48_full_regression_partition_proof.files,211);
-  assert.equal(matrix.predecessor_r48_full_regression_partition_proof.not_valid_as_r49_proof,true);
+
+  for (const value of [
+    pkg.version, lock.version, lock.packages[''].version, DEADBYTE_VERSION,
+    release.version, provenance.version, matrix.version
+  ]) assert.equal(value, DEADBYTE_VERSION);
+
+  assert.equal(release.capabilities.full_tool_count, 117);
+  assert.equal(release.capabilities.desktop_bounded_semantic_wait, true);
+  assert.equal(release.capabilities.commander_incremental_pdf_revisions, true);
+  assert.equal(release.capabilities.commander_docx_header_footer_search, true);
+  assert.equal(release.capabilities.commander_directory_read_fallback, true);
+  assert.equal(release.capabilities.commander_binary_detection, true);
+  assert.equal(release.capabilities.commander_protocol_adversarial, true);
+  assert.equal(release.capabilities.atomic_mutation_unknown_effect, 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);
+  assert.equal(provenance.source_predecessor_tarball_sha256, release.source_predecessor.tarball_sha256);
 });

package/test/r49-windows-gate.test.mjs

@@ -1,27 +1,31 @@
 import assert from 'node:assert/strict';
-import {readFile} from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import test from 'node:test';
 
 const read = path => readFile(new URL(`../${path}`, import.meta.url), 'utf8');
 
-test('R49 canonical Windows gate is successor-bound and preserves the R48 historical gate', async () => {
-  const [pkgText, gate, evidence, historical, deferred] = await Promise.all([
+test('R51 canonical Windows gate is successor-bound and preserves R50/R49 historical gates', async () => {
+  const [pkgText, gate, evidence, historicalR50, historicalR49, deferred] = await Promise.all([
     read('package.json'),
+    read('scripts/gate-windows-r51.ps1'),
+    read('scripts/windows-gate-evidence-r51.mjs'),
+    read('scripts/gate-windows-r50.ps1'),
     read('scripts/gate-windows-r49.ps1'),
-    read('scripts/windows-gate-evidence-r49.mjs'),
-    read('scripts/gate-windows-r48.ps1'),
     read('scripts/deferred-slot-operation-r46.mjs')
   ]);
   const pkg = JSON.parse(pkgText);
-  assert.match(pkg.scripts['gate:windows'], /gate-windows-r49\.ps1$/);
-  assert.match(gate, /DEADBYTE 0\.15\.26 \/ R49 WINDOWS GATE: PASS/);
+  assert.match(pkg.scripts['gate:windows'], /gate-windows-r51\.ps1$/);
+  assert.match(gate, /DEADBYTE 0\.15\.28 \/ R51 WINDOWS GATE: PASS/);
+  assert.match(gate, /r51-package-boundary/);
+  assert.match(gate, /r51-focused-contracts/);
   assert.match(gate, /r49-remote-control-donors\.test\.mjs/);
   assert.match(gate, /desktop-runtime-r40\.test\.mjs/);
   assert.match(gate, /manifest-final-verify/);
-  assert.match(evidence, /deadbyte\.r49-windows-gate\.v1/);
-  assert.match(evidence, /pkg\.version==='0\.15\.26'/);
-  assert.match(evidence, /release\.train==='R49'/);
-  assert.match(historical, /DEADBYTE 0\.15\.25 \/ R48 WINDOWS GATE: PASS/);
+  assert.match(evidence, /deadbyte\.r51-windows-gate\.v1/);
+  assert.match(evidence, /pkg\.version === '0\.15\.28'/);
+  assert.match(evidence, /release\.train === 'R51'/);
+  assert.match(historicalR50, /DEADBYTE 0\.15\.27 \/ R50 WINDOWS GATE: PASS/);
+  assert.match(historicalR49, /DEADBYTE 0\.15\.26 \/ R49 WINDOWS GATE: PASS/);
   assert.match(deferred, /const expectedVersion=packageIdentity\.version/);
   assert.match(deferred, /'--expected-version',expectedVersion/);
   assert.match(deferred, /async function awaitHandoffCompletion/);

package/test/r51-live-log-polling.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { selectLiveLogNames } from '../src/remote-live-log.mjs';
+import { readFile } from 'node:fs/promises';
+
+test('R51 live log discovery tails only current and previous audit segments plus runtime logs',()=>{
+  const selected=selectLiveLogNames({
+    auditNames:['segment-00000001.jsonl','junk.txt','segment-00000003.jsonl','segment-00000002.jsonl'],
+    runtimeNames:['bridge.stdout.log','bridge.stderr.log','note.txt']
+  });
+  assert.deepEqual(selected.audit,['segment-00000002.jsonl','segment-00000003.jsonl']);
+  assert.deepEqual(selected.runtime,['bridge.stderr.log','bridge.stdout.log']);
+});
+
+test('R51 live tail caches directory discovery instead of rescanning every 250ms poll',async()=>{
+  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(cli,/LIVE_LOG_DISCOVERY_INTERVAL_MS\s*=\s*1000/);
+  assert.match(cli,/nextDiscoveryAt/);
+  assert.doesNotMatch(cli,/for\(const file of await listLogFiles\(root\)\)/);
+});
+
+test('R51 live tail parses each audit line once and reuses the decoded event',async()=>{
+  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+  assert.match(cli,/parseAuditLogLine/);
+  assert.match(cli,/auditEvent/);
+  assert.match(cli,/auditTimelineRecord\(file,line,auditEvent\)/);
+  assert.match(cli,/formatLogLine\(file,line,\{auditEvent,/);
+});