deadbyte-mcp 0.11.0 → 0.11.2

package/scripts/windows-gate-evidence-r38.mjs

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.11.2 / R38 WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok) throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.11.2',`Windows gate evidence requires V0.11.2, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r38-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.2',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r38-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256};
+  }catch(error){
+    if(error?.code!=='EEXIST') throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8'));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing Windows gate evidence invalid');
+    insist(existing.version==='0.11.2'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  writeWindowsGateEvidence()
+    .then(result=>console.log(JSON.stringify(result)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/windows-gate-evidence.mjs

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 const here=path.dirname(fileURLToPath(import.meta.url));
 const root=path.resolve(here,'..');
 const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
-const marker='DEADBYTE V0.11.0 / R37 WINDOWS BATCH GATE: PASS';
+const marker='DEADBYTE V0.11.1 / R37 WINDOWS BATCH GATE: PASS';
 function insist(ok,message){if(!ok) throw new Error(message);}
 
 export async function writeWindowsGateEvidence({
@@ -19,11 +19,11 @@ export async function writeWindowsGateEvidence({
   const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
   const manifestSha256=sha256(manifestBytes);
   const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
-  insist(pkg.version==='0.11.0',`Windows gate evidence requires V0.11.0, found ${pkg.version}`);
+  insist(pkg.version==='0.11.1',`Windows gate evidence requires V0.11.1, found ${pkg.version}`);
   const completed=clock();
   insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
   const evidence={
-    schema:'deadbyte.r37-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.0',
+    schema:'deadbyte.r37-windows-gate.v1',status:'passed',exit_code:0,version:'0.11.1',
     marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256
   };
   const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
@@ -39,7 +39,7 @@ export async function writeWindowsGateEvidence({
     const existingBytes=await readFile(file);
     const existing=JSON.parse(existingBytes.toString('utf8'));
     insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing Windows gate evidence invalid');
-    insist(existing.version==='0.11.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    insist(existing.version==='0.11.1'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
     return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256};
   }
 }

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 { createLiveTimelineTracker, formatCompactAuditEvent, formatRemoteLifecycle, formatRuntimeDiagnosticLine } 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],
@@ -52,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||''):'';
@@ -64,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');
@@ -88,13 +104,17 @@ function formatLogLine(file,line,{activityTracker=null}={}){
   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){
   const parsed=parseRemoteResultCursor(cursor);
@@ -105,6 +125,12 @@ async function replayRemoteResults(root,cursor){
   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(`[REPLAY] ${marker} ${event.tool} [cursor r1:${event.session_id}:${event.seq}]\n`);
     }
@@ -139,9 +165,11 @@ async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTra
       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(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;
@@ -257,18 +285,21 @@ async function runRemoteSession({resumeCursor=null}={}){
     const logOffsets=await snapshotRemoteLogOffsets(ctx.root);
     logTask=tailRemoteLogs(ctx.root,aborter.signal,{journal:resultJournal,offsets:logOffsets,activityTracker});
     process.stdout.write('[BOOT] Starting local + remote runtime...\n');
-    const started=[];
-    for(const command of SESSION_START){
-      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,{capture:true,echoCaptured:false});
-      started.push(controllerResult);
-      if(command==='start'){
-        process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);
-        process.stdout.write(`${formatRemoteLifecycle('cloud_connected')}\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});
     }
-    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`);
@@ -320,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/release-generation.mjs

@@ -60,16 +60,33 @@ function rebindCodingPolicy(raw,{developmentRoot,stateRoot,parityScratchRoot}){
   policy.roots.parity_scratch={path:parityScratchRoot,read:true,write:true,exec:false,deny_paths:[]};
   return policy;
 }
+async function currentWindowsGateScript(rootPath){
+  const packagePath=path.join(rootPath,'package.json');
+  const stat=await lstat(packagePath);
+  if(!stat.isFile()||stat.isSymbolicLink()) throw new Error('windows release gate package.json invalid');
+  let pkg;
+  try{ pkg=JSON.parse(await readFile(packagePath,'utf8')); }
+  catch{ throw new Error('windows release gate package.json malformed'); }
+  const command=String(pkg?.scripts?.['gate:windows']??'').trim();
+  const match=/^powershell(?:\.exe)?\s+-NoProfile\s+-ExecutionPolicy\s+Bypass\s+-File\s+(scripts\/[A-Za-z0-9._\/-]+\.ps1)$/i.exec(command);
+  if(!match) throw new Error('windows release gate package script invalid');
+  return safeRel(match[1]);
+}
 async function rebindAutonomousPolicy(raw,{stateRoot,codingPolicy,codingPolicyBytes}){
   const policy=clone(raw);
   policy.lease_file=path.join(stateRoot,'runtime','autonomous-grant.json');
   policy.evidence_dir=path.join(stateRoot,'evidence','autonomous');
   policy.coding_policy_sha256=sha256(codingPolicyBytes);
   for(const [id,profile] of Object.entries(policy.profiles??{})){
-    const rel=safeRel(String(profile.script_path).replaceAll('\\','/'));
     const rootId=String(profile.root_id??'');
     const rootPath=codingPolicy.roots?.[rootId]?.path;
     if(typeof rootPath!=='string'||!path.isAbsolute(rootPath)) throw new Error(`profile root invalid: ${id}`);
+    if(id==='windows-release'){
+      if(profile.kind!=='command'||rootId!=='core'||profile.command_id!=='powershell_script') throw new Error('windows release profile shape invalid');
+      profile.script_path=await currentWindowsGateScript(rootPath);
+      profile.description='Full Windows target release gate; runs only when finish is requested.';
+    }
+    const rel=safeRel(String(profile.script_path).replaceAll('\\','/'));
     const file=path.resolve(rootPath,...rel.split('/'));
     const boundary=path.relative(rootPath,file);
     if(boundary.startsWith(`..${path.sep}`)||path.isAbsolute(boundary)) throw new Error(`profile path escapes coding root: ${id}`);

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 '';
@@ -92,7 +114,7 @@ export function createLiveTimelineTracker({clock=()=>Date.now()}={}){
       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 `▶ [${shortSpanId(requestId)}] RUN ${tool}${summarizeArgs(event.args)}`;
+        return formatRemoteToolCall(event,{clock});
       }
       if(event.event_type==='tool.result'&&requestId&&tool){
         if(completed.has(requestId)) return null;

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.11.0';
+export const DEADBYTE_VERSION = '0.11.2';
 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/cli-entrypoint.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -16,6 +17,14 @@ test('package exposes npx-first deadbyte-mcp bin and is registry-publishable',as
   assert.equal(pkg.publishConfig?.access,'public');
 });
 
+test('npx CLI reports the canonical package version through --version, -v and version',()=>{
+  for(const arg of ['--version','-v','version']){
+    const result=spawnSync(process.execPath,[cliPath,arg],{cwd:root,encoding:'utf8',windowsHide:true});
+    assert.equal(result.status,0,result.stderr);
+    assert.equal(result.stdout.trim(),'0.11.2');
+  }
+});
+
 test('npx CLI remote path invokes stable PS1 directly and never routes through CMD',async()=>{
   const source=await readFile(cliPath,'utf8');
   assert.match(source,/^#!\/usr\/bin\/env node/m);

package/test/containment.test.mjs

@@ -230,6 +230,24 @@ test('native build script targets Windows 10 and preserves MSVC diagnostics', as
   assert.doesNotMatch(source, /\$VsWhere = Join-Path \$\{env:ProgramFiles\(x86\)\}/);
 });
 
+test('native build is reproducible at both MSVC object and linker boundaries', async () => {
+  const buildScript = fileURLToPath(new URL('../scripts/build-containment.ps1', import.meta.url));
+  const source = await readFile(buildScript, 'utf8');
+  const lines = source.split(/\r?\n/);
+  const commonLine = lines.find(line => line.startsWith('$Common ='));
+  const bootstrapLine = lines.find(line => line.startsWith('$BootstrapCommon ='));
+  assert.ok(commonLine?.includes('/Brepro'), 'common compiler flags must include /Brepro');
+  assert.ok(bootstrapLine?.includes('/Brepro'), 'bootstrap compiler flags must include /Brepro');
+  for (const name of [
+    'Launcher','Probe','BootstrapKernel','BootstrapAdvapi','StageLauncher','BootstrapExit',
+    'ChildControlStage','ChildControlProbe','ContainedLauncher','ContainedWorker',
+    'ContainedReverseWorker','TunnelHost','ProcessHost'
+  ]) {
+    const line = lines.find(candidate => candidate.startsWith(`$${name}Command =`));
+    assert.ok(line?.includes('/link /Brepro /INCREMENTAL:NO'), `${name} linker flags must be reproducible and non-incremental`);
+  }
+});
+
 
 
 test('native build command composition is Windows PowerShell 5.1 parser-safe', async () => {

package/test/controller.test.mjs

@@ -215,3 +215,14 @@ test('R34 supervisor lifecycle never arms privileged planes', async () => {
   assert.match(block,/Disarm-Process/);
   assert.match(block,/Disarm-Host/);
 });
+
+test('supervisor recovery never assigns PowerShell automatic variable $Host', async () => {
+  const source=await readFile(controller,'utf8');
+  const start=source.indexOf('function Recover-AutonomousSupervisor');
+  const end=source.indexOf('function Show-State',start);
+  assert.ok(start>=0&&end>start,'supervisor recovery block missing');
+  const block=source.slice(start,end);
+  assert.doesNotMatch(block,/\$host\s*=/i,'PowerShell $Host is read-only and names are case-insensitive');
+  assert.match(block,/\$hostStatus\s*=\s*Get-HostArmStatus\s+\$Cfg/);
+  assert.match(block,/Host=\$hostStatus/);
+});

package/test/core.test.mjs

@@ -105,7 +105,7 @@ test('proof execution creates deterministic output and signed verifiable receipt
   assert.equal(result.receipt.request.schema, 'deadbyte.request.v1');
   assert.match(result.receipt.request.nonce, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.request.sha256, /^[0-9a-f]{64}$/);
-  assert.equal(result.receipt.runtime.package_version, '0.11.0');
+  assert.equal(result.receipt.runtime.package_version, '0.11.2');
   assert.match(result.receipt.runtime.mcp_ingress_adapter, /^(?:none|tunnel-stdio-probe-compat-v1)$/);
   assert.match(result.receipt.runtime.mcp_ingress_adapter_sha256, /^[0-9a-f]{64}$/);
   assert.match(result.receipt.runtime.mcp_ingress_mode_source_sha256, /^[0-9a-f]{64}$/);

package/test/production-docs.test.mjs

@@ -9,9 +9,9 @@ const readme=()=>readFile(path.join(root,'README.txt'),'utf8');
 
 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\.11\.0 mcp/);
+  assert.match(text,/npx -y deadbyte-mcp@0\.11\.2 mcp/);
   assert.match(text,/CLAUDE DESKTOP/);
-  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.11\.0"[\s\S]*?"mcp"/);
+  assert.match(text,/"mcpServers"[\s\S]*?"command"\s*:\s*"npx"[\s\S]*?"-y"[\s\S]*?"deadbyte-mcp@0\.11\.2"[\s\S]*?"mcp"/);
   assert.match(text,/CURSOR/);
   assert.match(text,/\.cursor\/mcp\.json/);
   assert.match(text,/VS CODE/);
@@ -20,7 +20,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\.11\.0",\s*"mcp"\]/);
+  assert.match(text,/args\s*=\s*\["-y",\s*"deadbyte-mcp@0\.11\.2",\s*"mcp"\]/);
 });
 
 test('production README records tracer bullet, semantic scope, remote UX, safety and document extension',async()=>{

package/test/r33-closeout-regression.test.mjs

@@ -5,7 +5,7 @@ import { mkdtemp, mkdir, readFile, rm, writeFile, readdir } from 'node:fs/promis
 import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
-import * as parity from '../scripts/release-parity.mjs';
+import * as parity from '../scripts/release-parity-r38.mjs';
 import { createToolAudit } from '../src/tool-audit.mjs';
 import { verifyAuditChain } from '../src/audit-verify.mjs';
 import { generateTrustKeypair } from '../src/trust.mjs';
@@ -86,12 +86,12 @@ test('audit restart reconciles an orphan request with an explicit interrupted re
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });
 
-test('Windows R37 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
+test('Windows R38 gate emits manifest-bound machine-readable evidence outside the candidate tree', async()=>{
   const stateRoot=await temp('deadbyte-r33-windows-evidence-');
   try{
-    const gate=await readFile(path.join(root,'scripts','gate-windows.ps1'),'utf8');
-    assert.match(gate,/windows-gate-evidence\.mjs/,'gate-windows.ps1 must invoke the evidence writer');
-    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence.mjs')],{
+    const gate=await readFile(path.join(root,'scripts','gate-windows-r38.ps1'),'utf8');
+    assert.match(gate,/windows-gate-evidence-r38\.mjs/,'gate-windows-r38.ps1 must invoke the evidence writer');
+    const result=await run(process.execPath,[path.join(root,'scripts','windows-gate-evidence-r38.mjs')],{
       cwd:root,env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}
     });
     assert.equal(result.code,0,result.stderr||result.stdout);
@@ -99,12 +99,12 @@ test('Windows R37 gate emits manifest-bound machine-readable evidence outside th
     assert.equal(summary.status,'written');
     const evidence=JSON.parse(await readFile(summary.path,'utf8'));
     const manifestSha=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
-    assert.equal(evidence.schema,'deadbyte.r37-windows-gate.v1');
+    assert.equal(evidence.schema,'deadbyte.r38-windows-gate.v1');
     assert.equal(evidence.status,'passed');
     assert.equal(evidence.exit_code,0);
-    assert.equal(evidence.version,'0.11.0');
+    assert.equal(evidence.version,'0.11.2');
     assert.equal(evidence.manifest_sha256,manifestSha);
-    assert.equal(evidence.marker,'DEADBYTE V0.11.0 / R37 WINDOWS BATCH GATE: PASS');
+    assert.equal(evidence.marker,'DEADBYTE V0.11.2 / R38 WINDOWS BATCH GATE: PASS');
     assert.ok(summary.path.startsWith(path.join(stateRoot,'evidence','release')));
   }finally{await rm(stateRoot,{recursive:true,force:true});}
 });

package/test/r33-finalization.test.mjs

@@ -2,8 +2,8 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { R34_EXPECTED_TOOLS } from '../src/remote-mcp-r34-parity-client.mjs';
-import { validateParityEvidence } from '../scripts/release-parity.mjs';
-import { verifyFinalClosureObject } from '../scripts/final-closure-verify.mjs';
+import { validateParityEvidence } from '../scripts/release-parity-r38.mjs';
+import { verifyFinalClosureObject } from '../scripts/final-closure-verify-r38.mjs';
 
 const root = new URL('../', import.meta.url);
 const text = rel => readFile(new URL(rel, root), 'utf8');
@@ -19,28 +19,28 @@ test('R34 public parity catalog is exact, unique, and includes production coding
 
 test('release parity and final verifier are package entry points', async () => {
   const pkg = JSON.parse(await text('package.json'));
-  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity.mjs');
-  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure.mjs');
-  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify.mjs');
+  assert.equal(pkg.scripts['release:parity'], 'node scripts/release-parity-r38.mjs');
+  assert.equal(pkg.scripts['release:final:write'], 'node scripts/final-closure-r38.mjs');
+  assert.equal(pkg.scripts['release:final:verify'], 'node scripts/final-closure-verify-r38.mjs');
   assert.equal(typeof validateParityEvidence, 'function');
   assert.equal(typeof verifyFinalClosureObject, 'function');
 });
 
-test('R37 final closure verifier is implementation-independent from production helpers', async () => {
-  const verifier = await text('scripts/final-closure-verify.mjs');
-  const writer = await text('scripts/final-closure.mjs');
+test('R38 final closure verifier is implementation-independent from production helpers', async () => {
+  const verifier = await text('scripts/final-closure-verify-r38.mjs');
+  const writer = await text('scripts/final-closure-r38.mjs');
   assert.doesNotMatch(verifier, /from ['"]\.\.\/src\//);
   assert.match(verifier, /DEADBYTE-R27-SLOT-UPDATE-V1/);
   assert.match(verifier, /DEADBYTE-MACHINE-PING-V1/);
-  assert.match(verifier, /DEADBYTE-R37-FINAL-CLOSURE-V1/);
-  assert.match(writer, /pointer\.version==='0\.11\.0'/);
-  assert.match(verifier, /envelope\.body\.version==='0\.11\.0'/);
-  assert.match(verifier, /release_label==='R37 FINAL MACHINE BASELINE'/);
-  assert.match(verifier, /8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8/);
+  assert.match(verifier, /DEADBYTE-R38-FINAL-CLOSURE-V1/);
+  assert.match(writer, /pointer\.version==='0\.11\.2'/);
+  assert.match(verifier, /envelope\.body\.version==='0\.11\.2'/);
+  assert.match(verifier, /release_label==='R38 FINAL MACHINE BASELINE'/);
+  assert.match(verifier, /220fac89dd82cdcdddb82cd7d0b71b768f84a5c87d57ebaca0f5383f33d97a76/);
 });
 
 test('final closure verifier canonicalizes traversal order before exact-tree comparison', async () => {
-  const verifier = await text('scripts/final-closure-verify.mjs');
+  const verifier = await text('scripts/final-closure-verify-r38.mjs');
   assert.match(verifier, /const actual=\(await walk\(root\)\)\.filter\(rel=>rel!==manifestName\)\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
   assert.match(verifier, /const expected=\[\.\.\.entries\.keys\(\)\]\.sort\(\(a,b\)=>a\.localeCompare\(b,'en'\)\);/);
 });

package/test/r36-release-identity.test.mjs

@@ -10,10 +10,10 @@ const R36_RELEASE_ID='v0.10.0-8d1e5f09745e7647';
 const R36_MANIFEST='8d1e5f09745e764796b60e0a8a0168be7334ed4bf834fad5974a80eba295b4e8';
 
 test('sealed R36 historical proof scripts preserve 0.10.0 / R36 and exact R35 predecessor',async()=>{
-  const [gate,parity,closure,closureVerify,windowsGate,currentParity]=await Promise.all([
+  const [gate,parity,closure,closureVerify,windowsGate,r37_0110Parity]=await Promise.all([
     text('scripts/gate-windows-r36.ps1'),text('scripts/release-parity-r36.mjs'),
     text('scripts/final-closure-r36.mjs'),text('scripts/final-closure-verify-r36.mjs'),
-    text('scripts/windows-gate-evidence-r36.mjs'),text('scripts/release-parity.mjs')
+    text('scripts/windows-gate-evidence-r36.mjs'),text('scripts/release-parity-r37-0110.mjs')
   ]);
   assert.match(gate,/DEADBYTE V0\.10\.0 \/ R36 WINDOWS BATCH GATE: PASS/);
   assert.match(parity,/deadbyte\.r36-parity\.v1/);
@@ -23,8 +23,8 @@ test('sealed R36 historical proof scripts preserve 0.10.0 / R36 and exact R35 pr
   assert.match(closure,/version:'0\.10\.0'/);
   assert.match(closureVerify,/DEADBYTE-R36-FINAL-CLOSURE-V1/);
   assert.match(windowsGate,/deadbyte\.r36-windows-gate\.v1/);
-  assert.match(currentParity,new RegExp(R36_RELEASE_ID.replaceAll('.','\\.')));
-  assert.match(currentParity,new RegExp(R36_MANIFEST));
+  assert.match(r37_0110Parity,new RegExp(R36_RELEASE_ID.replaceAll('.','\\.')));
+  assert.match(r37_0110Parity,new RegExp(R36_MANIFEST));
 });
 
 test('current R37 controller still binds production remote to compact profile and restores parent environment',async()=>{

package/test/r37-0110-history.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+const root=new URL('../',import.meta.url);
+const text=rel=>readFile(new URL(rel,root),'utf8');
+
+test('sealed public 0.11.0 release scripts remain preserved as historical R37 authority',async()=>{
+  const [gate,evidence,parity,closure,verify,deferred]=await Promise.all([
+    text('scripts/gate-windows-r37-0110.ps1'),text('scripts/windows-gate-evidence-r37-0110.mjs'),
+    text('scripts/release-parity-r37-0110.mjs'),text('scripts/final-closure-r37-0110.mjs'),
+    text('scripts/final-closure-verify-r37-0110.mjs'),text('scripts/deferred-slot-operation-r37-0110.mjs')
+  ]);
+  assert.match(gate,/V0\.11\.0 \/ R37/);
+  assert.match(evidence,/version:'0\.11\.0'/);
+  assert.match(parity,/v0\.10\.0-8d1e5f09745e7647/);
+  assert.match(parity,/candidate\?\.version==='0\.11\.0'/);
+  assert.match(closure,/version:'0\.11\.0'/);
+  assert.match(verify,/value\?\.version==='0\.11\.0'/);
+  assert.match(deferred,/--expected-version','0\.11\.0'/);
+});