deadbyte-mcp 0.15.50 → 0.15.52

package/src/commander-large-text-r139.mjs

@@ -0,0 +1,66 @@
+// Bounded-memory Commander text paging, using only the policy-authorized native filesystem.
+// Never rewrites the file. Pages accumulate a SHA-256 checked against one final native hash.
+import {createHash} from 'node:crypto';
+const SHA=/^[a-f0-9]{64}$/;
+const MAX_SCAN=64*1024*1024;
+const MAX_LINE=4*1024*1024;
+
+export async function readCommanderLargeText({runtime,rootId,relativePath,offset=0,length=1000}={}){
+ if(!runtime||typeof runtime.read!=='function')throw new Error('native filesystem read unavailable');
+ if(!Number.isInteger(offset)||offset<0||!Number.isInteger(length)||length<0||length>10000)
+  throw new Error('large text offset or length invalid');
+ const policyChunk=runtime.policy?.max_read_bytes??256*1024;
+ const chunkSize=Math.min(256*1024,policyChunk);
+ if(!Number.isSafeInteger(chunkSize)||chunkSize<1)throw new Error('large text read policy limit invalid');
+ const decoder=new TextDecoder('utf-8',{fatal:true,ignoreBOM:true});
+ let pending='',position=0,fileSha=null,fileSize=null,totalLines=0,scanned=0,done=false;
+ const streamedHash=createHash('sha256');
+ const selected=[];
+ const emit=line=>{
+  if(totalLines>=offset&&selected.length<length)selected.push(line);
+  totalLines++;
+ };
+ const feed=(part,final=false)=>{
+  const value=pending+part;
+  const re=/\r\n|\r|\n/g;
+  let match,from=0;
+  while((match=re.exec(value))){
+   if(!final&&match[0]==='\r'&&match.index+1===value.length)break;
+   emit(value.slice(from,match.index));
+   from=match.index+match[0].length;
+  }
+  pending=value.slice(from);
+  if(Buffer.byteLength(pending,'utf8')>MAX_LINE)throw new Error('large text line exceeds bounded read limit');
+  if(final)emit(pending);
+ };
+ while(!done){
+  const page=await runtime.read({rootId,relativePath,offset:position,maxBytes:chunkSize,hashFile:false});
+  if(Number.isSafeInteger(page.file_size)){
+   if(fileSize===null)fileSize=page.file_size;
+   else if(fileSize!==page.file_size)throw new Error('large text file changed during paged read: size mismatch');
+   if(fileSize>MAX_SCAN)throw new Error('large text file exceeds bounded 64MiB scan limit');
+  }
+  if(!Number.isSafeInteger(page.offset)||page.offset!==position)throw new Error('large text native page offset drift');
+  if(typeof page.data_base64!=='string')throw new Error('large text native payload missing');
+  const bytes=Buffer.from(page.data_base64,'base64');
+  if(bytes.length>chunkSize||page.next_offset!==position+bytes.length)throw new Error('large text native page cursor invalid');
+  if(bytes.length===0&&page.eof!==true)throw new Error('large text read stalled before EOF');
+  streamedHash.update(bytes);
+  position+=bytes.length;scanned+=bytes.length;
+  if(scanned>MAX_SCAN)throw new Error('large text file exceeds bounded 64MiB scan limit');
+  feed(decoder.decode(bytes,{stream:true}));
+  if(page.eof===true){feed(decoder.decode(),true);done=true;}
+ }
+ if(fileSize!==null&&fileSize!==position)throw new Error('large text file changed during paged read: size mismatch');
+ // One native full-file hash after all delivered bytes binds them to final file contents.
+ const closing=await runtime.read({rootId,relativePath,offset:position,maxBytes:1,hashFile:true});
+ if(!SHA.test(closing?.file_sha256??''))throw new Error('large text native file identity missing');
+ if(closing.offset!==position||closing.next_offset!==position||closing.eof!==true||
+    closing.data_base64!==''||!Number.isSafeInteger(closing.file_size)||closing.file_size!==position)
+  throw new Error('large text file changed during paged read: closing cursor or size mismatch');
+ fileSha=closing.file_sha256;
+ if(streamedHash.digest('hex')!==fileSha)throw new Error('large text file changed during paged read: identity mismatch');
+ const start=Math.min(offset,totalLines);
+ return {content:selected.join('\n')+(start+selected.length<totalLines?'\n':''),
+  lineOffset:start,lineCount:selected.length,totalLines,fileSha256:fileSha,bytesScanned:scanned,paged:true};
+}

package/src/commander-wire-adapter-r47.mjs

@@ -5,6 +5,7 @@ import { readCommanderUrl } from './commander-url-reader-r48.mjs';
 import { readDocxBytes, searchDocxTextBytes, createDocxBytes, editDocxBytes, readXlsxBytes, editXlsxBytes, createXlsxBytes, appendXlsxBytes } from './commander-office-reader-r48.mjs';
 import { editDeadbytePdf, parseDeadbytePdf, readPdfText } from './commander-pdf-r48.mjs';
 import { decodeUtf8Strict } from './text-policy.mjs';
+import { readCommanderLargeText } from './commander-large-text-r139.mjs';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
 const RDC_PROCESS_READ_CHUNK=256*1024;
@@ -207,12 +208,26 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       const tail=await machineFsRuntime.read({
         rootId:target.rootId,relativePath:target.relativePath,offset:-policyMax,maxBytes:policyMax,hashFile:false
       });
-      let decoded=Buffer.from(tail.data_base64,'base64').toString('utf8').replaceAll('\r\n','\n').replaceAll('\r','\n');
+      let tailBytes=Buffer.from(tail.data_base64,'base64');
       if((tail.offset??0)>0){
-        const firstBreak=decoded.indexOf('\n');
-        if(firstBreak<0) throw new Error('text tail window contains no complete line');
-        decoded=decoded.slice(firstBreak+1);
+        const previous=await machineFsRuntime.read({
+          rootId:target.rootId,relativePath:target.relativePath,
+          offset:tail.offset-1,maxBytes:1,hashFile:false
+        });
+        const before=Buffer.from(previous.data_base64,'base64');
+        if(previous.offset!==tail.offset-1||previous.next_offset!==tail.offset||
+           previous.file_size!==tail.file_size||before.length!==1)
+          throw new Error('text tail window changed before boundary check');
+        const aligned=before[0]===0x0a||(before[0]===0x0d&&tailBytes[0]!==0x0a);
+        if(!aligned){
+          const firstBreak=tailBytes.findIndex(byte=>byte===0x0a||byte===0x0d);
+          if(firstBreak<0) throw new Error('text tail window contains no complete line');
+          const crlf=tailBytes[firstBreak]===0x0d&&tailBytes[firstBreak+1]===0x0a;
+          tailBytes=tailBytes.subarray(firstBreak+(crlf?2:1));
+        }
       }
+      if(tailBytes.includes(0)) throw new Error('text tail window contains NUL byte');
+      let decoded=decodeUtf8Strict(tailBytes).replaceAll('\r\n','\n').replaceAll('\r','\n');
       let all=decoded.split('\n');
       if(all.length&&all.at(-1)==='') all.pop();
       const wanted=Math.abs(requestedOffset);
@@ -232,6 +247,13 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       hashFile:richDocument
     });
     if(richDocument&&raw.eof===false) throw new Error('document exceeds bounded native read limit');
+    if(!richDocument&&raw.eof===false&&!imageMime&&ext!=='.xls'){
+      const large=await readCommanderLargeText({runtime:machineFsRuntime,
+        rootId:target.rootId,relativePath:target.relativePath,
+        offset:requestedOffset,length:requestedLength});
+      return text(large.content,false,{path:args.path,content:large.content,
+        mimeType:'text/plain',isImage:false,isPdf:false,...large,...optionMeta});
+    }
     if(!richDocument&&raw.eof===false) throw new Error('text file exceeds bounded compatibility read limit');
     const bytes=Buffer.from(raw.data_base64,'base64');
     const fileSha256=raw.file_sha256??sha256Bytes(bytes);
@@ -477,11 +499,17 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       });
     }
     if(args.old_string===undefined||args.new_string===undefined) throw new Error('Must provide either old_string + new_string');
-    const raw=await machineFsRuntime.read({rootId:target.rootId,relativePath:target.relativePath,offset:0,maxBytes:Math.min(4*1024*1024,machineFsRuntime.policy.max_read_bytes??4*1024*1024),hashFile:false});
+    const editBound=16*1024*1024;
+    const raw=await machineFsRuntime.read({rootId:target.rootId,relativePath:target.relativePath,offset:0,
+      maxBytes:Math.min(editBound,machineFsRuntime.policy.max_read_bytes??editBound),hashFile:true});
     if(raw.eof===false) throw new Error('text edit target exceeds bounded compatibility edit limit');
     const before=Buffer.from(raw.data_base64,'base64');
+    if(before.includes(0))throw new Error('binary text edit target rejected');
+    let current;
+    try{current=decodeUtf8Strict(before);}catch{throw new Error('invalid UTF-8 in text edit target');}
+    if(before.length>=3&&before[0]===0xef&&before[1]===0xbb&&before[2]===0xbf)
+      current='\uFEFF'+current;
     const fileSha256=raw.file_sha256??sha256Bytes(before);
-    const current=before.toString('utf8');
     let count=0,index=0;
     while((index=current.indexOf(args.old_string,index))>=0){count++;index+=Math.max(1,args.old_string.length);}
     if(count!==args.expected_replacements) throw new Error(`expected ${args.expected_replacements} replacements, found ${count}`);
@@ -652,7 +680,20 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     }
     pidMap.set(compatPid,native.session_id);
     processCompatState.set(compatPid,{last_read_byte:0});
-    return text(`Process started with PID ${compatPid} (DEADBYTE session ${native.session_id})\\n`,false,{pid:compatPid,session_id:native.session_id});
+    let initialOutput='',previewUnavailable=false,previewTruncated=false;
+    try{
+      // Optional, non-waiting preview: does not advance the independent output cursor.
+      const first=await processRuntime.read({sessionId:native.session_id,offset:0,maxBytes:16384,waitMs:0});
+      const data=Buffer.from(first.data_base64??'','base64');
+      if(data.includes(0))throw new Error('binary process output preview');
+      initialOutput=decodeUtf8Strict(data);
+      previewTruncated=(first.stream_head??data.length)>(first.next_offset??data.length);
+    }catch{previewUnavailable=true;}
+    const summary=`Process started with PID ${compatPid} (DEADBYTE session ${native.session_id})`;
+    return text(initialOutput?summary+'\n'+initialOutput:summary+'\n',false,{
+      pid:compatPid,session_id:native.session_id,initial_output:initialOutput,
+      initial_output_truncated:previewTruncated,output_preview_unavailable:previewUnavailable
+    });
   }
   function sessionForPid(pid){
     const sessionId=pidMap.get(pid);
@@ -693,7 +734,9 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
         state:snapshot.state,exitCode:snapshot.exit_code,truncated:wasTruncated
       }),false,{
         pid:args.pid,session_id:sessionId,read_from:readFrom,read_count:readCount,total_lines:retainedRanges.length,
-        remaining,next_line:readFrom+readCount,stream_head:snapshot.stream_head,state:snapshot.state,exit_code:snapshot.exit_code
+        remaining,next_line:readFrom+readCount,stream_head:snapshot.stream_head,state:snapshot.state,exit_code:snapshot.exit_code,
+        earliest_offset:snapshot.earliest_offset,truncated:wasTruncated,
+        next_byte_offset:state.last_read_byte,more_unread:state.last_read_byte<snapshot.stream_head
       });
     }
     const totalLines=retainedRanges.length;
@@ -705,7 +748,9 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       readFrom,readCount,totalLines,remaining,lines,state:snapshot.state,exitCode:snapshot.exit_code,truncated:snapshot.earliest_offset>0
     }),false,{
       pid:args.pid,session_id:sessionId,read_from:readFrom,read_count:readCount,total_lines:totalLines,
-      remaining,next_line:readFrom+readCount,stream_head:snapshot.stream_head,state:snapshot.state,exit_code:snapshot.exit_code
+      remaining,next_line:readFrom+readCount,stream_head:snapshot.stream_head,state:snapshot.state,exit_code:snapshot.exit_code,
+      earliest_offset:snapshot.earliest_offset,truncated:snapshot.earliest_offset>0,
+      next_byte_offset:null,more_unread:remaining>0
     });
   }
   async function interactProcess(args){
@@ -745,8 +790,15 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     return text(`Successfully terminated process ${args.pid}`,false,{pid:args.pid,session_id:sessionId,...native});
   }
   async function listSessions(){
+    if(!processRuntime)throw new Error('process runtime is disabled');
     const native=await processRuntime.list();
-    return text(native.sessions.map(s=>`Session ${s.session_id}: state=${s.state}, profile=${s.profile_id}, root=${s.root_id}`).join('\\n'),false,{sessions:native.sessions});
+    if(!Array.isArray(native?.sessions))throw new Error('native session inventory unavailable');
+    const rows=native.sessions.map(s=>{
+      const pid=Number.isInteger(s.child_pid)&&s.child_pid>0?String(s.child_pid):'unknown';
+      const exit=s.state==='running'?'':`, exit=${Number.isInteger(s.exit_code)?s.exit_code:'unknown'}`;
+      return `Session ${s.session_id}: PID=${pid}, state=${s.state}, profile=${s.profile_id}, root=${s.root_id}${exit}`;
+    });
+    return text(rows.length?rows.join('\n'):'No managed sessions.',false,{sessions:native.sessions});
   }
   async function listProcesses(){
     if(!externalProcessRuntime) return listSessions();
@@ -882,11 +934,10 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
   async function getMoreSearchResults(args){
     const s=searchSessions.get(args.sessionId);
     if(!s) throw new Error('search session not found');
-    if(!s.isComplete) return {results:[],returnedCount:0,totalResults:0,isComplete:false,isError:false,hasMoreResults:true};
     const start=args.offset<0?Math.max(0,s.results.length+args.offset):args.offset;
     const end=args.offset<0?s.results.length:Math.min(s.results.length,start+args.length);
     const results=s.results.slice(start,end);
-    return {results,returnedCount:results.length,totalResults:s.results.length,isComplete:true,isError:s.isError,error:s.error,hasMoreResults:end<s.results.length,runtime:Date.now()-s.created};
+    return {results,returnedCount:results.length,totalResults:s.results.length,isComplete:s.isComplete,isError:s.isError,error:s.error,hasMoreResults:!s.isComplete||end<s.results.length,runtime:Date.now()-s.created};
   }
   async function stopSearch(args){
     const s=searchSessions.get(args.sessionId);

package/src/release-slot.mjs

@@ -79,13 +79,23 @@ async function listManifestTreeFiles(root){
   return files.sort((a,b)=>a.localeCompare(b,'en'));
 }
 
-export async function verifyManifestTreeExact(root,manifest){
+export async function verifyManifestTreeExact(root,manifest,{allowedExtraPaths=[]}={}){
+  // The only unmanifested files accepted in a protected test fixture are
+  // packaging inputs that npm intentionally excludes from published payloads.
+  // No subdirectory, wildcard, executable or mutable runtime state is exempt.
+  const allowedPackagingExtras=new Set(['.npmignore','package-lock.json']);
+  if(!Array.isArray(allowedExtraPaths)||allowedExtraPaths.some(rel=>!allowedPackagingExtras.has(rel))){
+    throw new Error('invalid allowed manifest extra');
+  }
+  const extras=new Set(allowedExtraPaths);
   await verifyManifestTree(root,manifest);
   const actual=await listManifestTreeFiles(root);
   const expected=[...manifest.keys()].sort((a,b)=>a.localeCompare(b,'en'));
-  for(const rel of actual) if(!manifest.has(rel)) throw new Error(`unexpected manifest-tree file: ${rel}`);
+  for(const rel of actual) if(!manifest.has(rel)&&!extras.has(rel)) throw new Error(`unexpected manifest-tree file: ${rel}`);
   for(const rel of expected) if(!actual.includes(rel)) throw new Error(`missing manifest-tree file: ${rel}`);
-  if(actual.length!==expected.length) throw new Error(`manifest-tree file count mismatch: expected=${expected.length} actual=${actual.length}`);
+  if(actual.length!==expected.length+actual.filter(rel=>extras.has(rel)&&!manifest.has(rel)).length){
+    throw new Error(`manifest-tree file count mismatch: expected=${expected.length} actual=${actual.length}`);
+  }
   return {files:manifest.size};
 }
 export async function copyManifestTree({source,destination,manifest}){

package/src/scoped-observer-launcher-r136.mjs

@@ -0,0 +1,77 @@
+import {fork} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const worker=fileURLToPath(new URL('./scoped-observer-worker-r136.mjs',import.meta.url));
+const hex=/^[0-9a-f]{64}$/;
+export async function startScopedObserver({stateRoot,codingPolicyFile,autonomousPolicyFile,codingSha256,autonomousSha256,ambientEnv={}}={}){
+ if(![stateRoot,codingPolicyFile,autonomousPolicyFile].every(p=>typeof p==='string'&&path.isAbsolute(p)))
+  throw new Error('observer absolute isolated paths required');
+ if(!hex.test(codingSha256??'')||!hex.test(autonomousSha256??''))
+  throw new Error('observer pinned policy SHA256 required');
+ // Deliberately no DEADBYTE_ authority config, inherited token, NODE_OPTIONS,
+ // or shell PATH. Child is a disarmed status-only IPC process, not an OS sandbox.
+ const env={};
+ for(const key of ['SystemRoot','SYSTEMROOT','windir','WINDIR','TEMP','TMP']){
+  if(typeof process.env[key]==='string')env[key]=process.env[key];
+ }
+ // ambientEnv is an adversarial test vector and is NEVER merged.
+ void ambientEnv;
+ const child=fork(worker,[stateRoot,codingPolicyFile,codingSha256,autonomousPolicyFile,autonomousSha256],{
+  execPath:process.execPath,execArgv:[],cwd:stateRoot,env,stdio:['ignore','ignore','ignore','ipc'],windowsHide:true
+ });
+ let pending=new Map(),serial=0,closed=false;
+ const rejectAll=reason=>{for(const {reject,timer} of pending.values()){clearTimeout(timer);reject(reason);}pending.clear();};
+ let bootResolve,bootReject;
+ const boot=new Promise((resolve,reject)=>{bootResolve=resolve;bootReject=reject});
+ let bootFinished=false;
+ const bootTimer=setTimeout(()=>{if(!bootFinished){bootFinished=true;bootReject(new Error('observer boot failed: timeout'));child.kill();}},6000);
+ child.on('message',msg=>{
+  if(msg?.kind==='ready'&&!bootFinished){bootFinished=true;clearTimeout(bootTimer);bootResolve(msg.result);return;}
+  if(msg?.kind==='boot-error'&&!bootFinished){bootFinished=true;clearTimeout(bootTimer);bootReject(new Error('observer boot failed: '+msg.reason));child.kill();return;}
+  if(msg?.kind==='reply'){
+   const p=pending.get(msg.id);if(!p)return;pending.delete(msg.id);clearTimeout(p.timer);p.resolve(msg.result);
+  }
+ });
+ child.on('error',error=>{if(!bootFinished){bootFinished=true;clearTimeout(bootTimer);bootReject(error);}rejectAll(error);});
+ child.on('exit',(code)=>{
+  closed=true;
+  if(!bootFinished){bootFinished=true;clearTimeout(bootTimer);bootReject(new Error('observer boot failed: exit '+code));}
+  rejectAll(new Error('observer exited'));
+ });
+ let ready;
+ try{ready=await boot;}catch(error){
+  if(!closed){
+   const exited=new Promise(resolve=>{
+    const timer=setTimeout(()=>{child.kill();},1500);
+    child.once('exit',()=>{clearTimeout(timer);resolve();});
+   });
+   child.kill();await exited;
+  }
+  throw error;
+ }
+ const request=payload=>{
+  if(closed) return Promise.reject(new Error('observer already exited'));
+  return new Promise((resolve,reject)=>{
+   const id=++serial;
+   const timer=setTimeout(()=>{pending.delete(id);reject(new Error('observer request timeout'));child.kill();},3000);
+   pending.set(id,{resolve,reject,timer});
+   try{child.send({kind:'request',id,op:payload?.op},err=>{if(err){clearTimeout(timer);pending.delete(id);reject(err);}});}
+   catch(error){clearTimeout(timer);pending.delete(id);reject(error);}
+  });
+ };
+ return Object.freeze({
+  ready,
+  request,
+  async close(){
+   if(closed)return;
+   const exited=new Promise(resolve=>{
+    if(closed)return resolve();
+    const timer=setTimeout(()=>{child.kill();},1500);
+    child.once('exit',()=>{clearTimeout(timer);resolve();});
+   });
+   try{await request({op:'shutdown'});}catch{child.kill();}
+   await exited;
+  }
+ });
+}

package/src/scoped-observer-worker-r136.mjs

@@ -0,0 +1,65 @@
+import {readFile,lstat,realpath} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const digest=/^[0-9a-f]{64}$/;
+const eq=(a,b)=>process.platform==='win32'?a.toLowerCase()===b.toLowerCase():a===b;
+async function fileInside(state,filename,expected){
+ if(!digest.test(expected??''))throw new Error('policy digest invalid');
+ const root=path.resolve(state),file=path.resolve(filename);
+ const rel=path.relative(root,file);
+ if(rel===''||path.isAbsolute(rel)||rel==='..'||rel.startsWith('..'+path.sep))throw new Error('policy outside isolated state');
+ const item=await lstat(file);
+ if(!item.isFile()||item.isSymbolicLink()||!eq(await realpath(file),file))throw new Error('policy not regular');
+ const bytes=await readFile(file);
+ if(sha(bytes)!==expected)throw new Error('policy digest mismatch');
+ return JSON.parse(bytes.toString('utf8'));
+}
+async function boot(){
+ if(!process.send)throw new Error('IPC required');
+ const [state,codingFile,codingDigest,autoFile,autoDigest]=process.argv.slice(2);
+ if(!state||!path.isAbsolute(state))throw new Error('isolated state required');
+ const isolated=path.resolve(state);
+ if(!eq(await realpath(isolated),isolated))throw new Error('isolated state redirected');
+ const coding=await fileInside(isolated,codingFile,codingDigest);
+ const auto=await fileInside(isolated,autoFile,autoDigest);
+ if(coding?.schema!=='deadbyte.coding-policy.v1'||coding.enabled!==true)throw new Error('coding schema invalid');
+ if(auto?.schema!=='deadbyte.autonomous-policy.v1'||auto.enabled!==true)throw new Error('autonomous schema invalid');
+ if(auto.coding_policy_sha256!==codingDigest)throw new Error('autonomous binding invalid');
+ const ids=Object.keys(coding.roots??{}),selected=auto.root_ids;
+ if(!Array.isArray(selected)||selected.length!==1||ids.length!==1||ids[0]!==selected[0])throw new Error('root scope mismatch');
+ const id=ids[0],root=coding.roots[id]?.path;
+ if(!path.isAbsolute(root??'')||eq(path.resolve(root),path.parse(root).root))throw new Error('broad Coding root forbidden');
+ const stat=await lstat(root);
+ if(!stat.isDirectory()||stat.isSymbolicLink()||!eq(await realpath(root),path.resolve(root)))throw new Error('untrusted project root');
+ const commands=Object.entries(coding.commands??{});
+ for(const [,command] of commands){
+  if(!Array.isArray(command.root_ids)||command.root_ids.length!==1||command.root_ids[0]!==id)
+   throw new Error('command root scope mismatch');
+ }
+ for(const p of Object.values(auto.profiles??{})){
+  if(p?.root_id!==id||!Object.hasOwn(coding.commands,p.command_id))throw new Error('autonomous profile mismatch');
+ }
+ for(const lease of [coding.lease_file,auto.lease_file]){
+  if(typeof lease!=='string'||!path.isAbsolute(lease)||!eq(path.dirname(lease),path.join(isolated,'runtime')))
+   throw new Error('lease state isolation mismatch');
+  try{await lstat(lease);throw new Error('inherited grant present');}
+  catch(error){if(error?.code!=='ENOENT')throw error;}
+ }
+ const ambient=Object.keys(process.env).filter(k=>k.toUpperCase().startsWith('DEADBYTE_'));
+ const ready={pid:process.pid,status:'DISARMED',root_ids:ids,command_ids:commands.map(x=>x[0]),
+  coding_sha256:codingDigest,autonomous_sha256:autoDigest,ambient_deadbyte_keys:ambient.length,
+  node_options_present:Object.hasOwn(process.env,'NODE_OPTIONS'),
+  user_token_present:Object.keys(process.env).some(k=>/OPENAI_API_KEY|NPM_TOKEN|GITHUB_TOKEN|GH_TOKEN|AWS_SECRET_ACCESS_KEY/i.test(k)),
+  grant_files_present:false};
+ process.send({kind:'ready',result:ready});
+ process.on('message',msg=>{
+  if(!msg||msg.kind!=='request'||!Number.isSafeInteger(msg.id))return;
+  if(msg.op==='shutdown'){process.send({kind:'reply',id:msg.id,result:{status:'STOPPING'}});return process.exit(0);}
+  const result=msg.op==='status'?{status:'DISARMED',root_ids:ids}:
+    {status:'DENIED_UNAUTHORIZED',op:typeof msg.op==='string'?msg.op:''};
+  process.send({kind:'reply',id:msg.id,result});
+ });
+}
+boot().catch(err=>{process.send?.({kind:'boot-error',reason:String(err.message??err).slice(0,140)});process.exitCode=3;});

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.50';
+export const DEADBYTE_VERSION = '0.15.52';
 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/commander-wire-contract-r47.test.mjs

@@ -406,13 +406,14 @@ test('R48 read_file tails a large text file from the end without reading the who
     policy:{roots:{project:{real_path:'D:\\RDC-COMPAT-TEST'}},max_read_bytes:64},
     async read(args){
       calls.push({...args});
-      if(args.offset>=0) return {
-        data_base64:Buffer.from('HEAD-ONLY').toString('base64'),
-        file_sha256:null,file_size:1024,eof:false,offset:0,next_offset:9
+      if(args.offset===959) return {
+        data_base64:Buffer.from('x').toString('base64'),
+        file_sha256:null,file_size:1024,eof:false,offset:959,next_offset:960
       };
       assert.equal(args.offset,-64);
+      const suffix='older\nline7\nline8\nline9\n';
       return {
-        data_base64:Buffer.from('older\nline7\nline8\nline9\n').toString('base64'),
+        data_base64:Buffer.from('p'.repeat(64-Buffer.byteLength(suffix))+suffix).toString('base64'),
         file_sha256:null,file_size:1024,eof:true,offset:960,next_offset:1024
       };
     }
@@ -423,8 +424,10 @@ test('R48 read_file tails a large text file from the end without reading the who
   });
   assert.equal(result.isError,undefined,JSON.stringify(result));
   assert.equal(result.structuredContent.content,'line8\nline9');
-  assert.equal(calls.length,1);
+  assert.equal(calls.length,2);
   assert.equal(calls[0].offset,-64);
+  assert.equal(calls[1].offset,959);
+  assert.equal(calls[1].maxBytes,1);
 });
 
 test('R48 edit_block range mutates XLSX through native ZIP/XML writer with hash precondition',async()=>{

package/test/r130-release-security-contract.test.mjs

@@ -13,14 +13,14 @@ test('R130 security patch has a new immutable package identity and truthful sour
     read('SBOM.cdx.json'),read('package-lock.json'),read('TEST-MATRIX.json')]);
   assert.equal(pkg.name,'deadbyte-mcp');
   for(const actual of [pkg.version,release.version,provenance.version,matrix.version,bom.metadata.component.version,lock.version,lock.packages[''].version,DEADBYTE_VERSION])
-    assert.equal(actual,'0.15.50');
-  assert.equal(release.train,'R130');
-  assert.equal(matrix.train,'R130');
-  assert.equal(release.source_predecessor.version,'0.15.49');
-  assert.match(release.source_predecessor.source_path,/0\.15\.49/);
+    assert.equal(actual,'0.15.52');
+  assert.equal(release.train,'R143');
+  assert.equal(matrix.train,'R143');
+  assert.equal(release.source_predecessor.version,'0.15.51');
+  assert.match(release.source_predecessor.source_path,/0\.15\.51/);
   assert.equal(release.runtime_predecessor.version,'0.15.45');
-  assert.equal(provenance.source_predecessor_version,'0.15.49');
-  assert.equal(provenance.source_predecessor_manifest_file_sha256,'0c614697756731ee348f77cb36f9b1780f3037b5846e6482dc9a4c4e48cf01b6');
+  assert.equal(provenance.source_predecessor_version,'0.15.51');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'ef27d35d0d3102b356fcb17478abefa82fae2375df27f913ce3b0ff0e5815a7e');
   assert.equal(pkg.dependencies['@modelcontextprotocol/client'],'2.3.1');
   assert.equal(pkg.dependencies['@modelcontextprotocol/server'],'2.3.1');
   for(const dep of ['@modelcontextprotocol/client','@modelcontextprotocol/server'])

package/test/r131-installed-manifest-boundary.test.mjs

@@ -0,0 +1,65 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp, mkdir, rm, writeFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import {verifyManifestTreeExact} from '../src/release-slot.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function fixture(run) {
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r131-portable-manifest-'));
+  try {
+    await mkdir(path.join(root,'src'));
+    await writeFile(path.join(root,'src','payload.mjs'),'export const x=1;\n');
+    await writeFile(path.join(root,'.npmignore'),'# supplemental npm packaging data\n');
+    await writeFile(path.join(root,'package-lock.json'),'{"name":"fixture"}\n');
+    const manifest=new Map([['src/payload.mjs',sha(Buffer.from('export const x=1;\n'))]]);
+    return await run({root,manifest});
+  } finally {
+    await rm(root,{recursive:true,force:true});
+  }
+}
+
+test('R131 existing strict release-tree gate rejects any supplemental file', async()=>{
+  await fixture(async({root,manifest})=>{
+    await assert.rejects(verifyManifestTreeExact(root,manifest),/unexpected manifest-tree file/);
+  });
+});
+
+test('R131 protected-install gate verifies all manifest hashes but permits ONLY declared packaging extras',async()=>{
+  await fixture(async({root,manifest})=>{
+    const result=await verifyManifestTreeExact(root,manifest,{allowedExtraPaths:['.npmignore','package-lock.json']});
+    assert.deepEqual(result,{files:1});
+  });
+});
+
+test('R131 protected-install gate rejects unexpected executable file even with allowed packaging extras',async()=>{
+  await fixture(async({root,manifest})=>{
+    await writeFile(path.join(root,'src','rogue.mjs'),'export const privileged=true;\n');
+    await assert.rejects(
+      verifyManifestTreeExact(root,manifest,{allowedExtraPaths:['.npmignore','package-lock.json']}),
+      /unexpected manifest-tree file: src\/rogue\.mjs/
+    );
+  });
+});
+
+test('R131 protected-install gate rejects mutated manifested source bytes',async()=>{
+  await fixture(async({root,manifest})=>{
+    await writeFile(path.join(root,'src','payload.mjs'),'export const x=2;\n');
+    await assert.rejects(
+      verifyManifestTreeExact(root,manifest,{allowedExtraPaths:['.npmignore','package-lock.json']}),
+      /hash mismatch: src\/payload\.mjs/
+    );
+  });
+});
+
+test('R131 installed gate disallows broad directory exemptions',async()=>{
+  await fixture(async({root,manifest})=>{
+    await assert.rejects(
+      verifyManifestTreeExact(root,manifest,{allowedExtraPaths:['src/','.npmignore','package-lock.json']}),
+      /invalid allowed manifest extra/
+    );
+  });
+});

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

@@ -0,0 +1,44 @@
+import test from 'node:test';
+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 read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
+
+test('R143 package identities, R132 historic evidence and published predecessor are consistent',async()=>{
+  const [pkg,lock,release,prov,bom,matrix]=await Promise.all([
+    read('package.json'),read('package-lock.json'),read('RELEASE.json'),
+    read('PROVENANCE.json'),read('SBOM.cdx.json'),read('TEST-MATRIX.json')]);
+  for(const value of [pkg.version,lock.version,lock.packages[''].version,release.version,prov.version,bom.metadata.component.version,matrix.version,DEADBYTE_VERSION]){
+    assert.equal(value,'0.15.52');
+  }
+  assert.equal(release.train,'R143');
+  assert.equal(matrix.train,'R143');
+  assert.equal(release.source_predecessor.version,'0.15.51');
+  assert.match(release.source_predecessor.source_path,/0\.15\.51/);
+  assert.equal(prov.source_predecessor_version,'0.15.51');
+  assert.equal(prov.source_predecessor_manifest_file_sha256,'ef27d35d0d3102b356fcb17478abefa82fae2375df27f913ce3b0ff0e5815a7e');
+  assert.equal(prov.parent_tarball_sha256,'69586dc07dc7a3025ec44f08e6b0eab60c1f9e75287da77c850b49e320b201ff');
+  assert.equal(release.runtime_predecessor.version,'0.15.45');
+  assert.equal(prov.runtime_predecessor.release_id,release.runtime_predecessor.release_id);
+  assert.equal(prov.runtime_predecessor.manifest_sha256,release.runtime_predecessor.manifest_sha256);
+  assert.equal(prov.runtime_predecessor.generation_manifest_sha256,release.runtime_predecessor.generation_manifest_sha256);
+  assert.equal(release.r132.manifest_portability,'R131_PROTECTED_FULL_GREEN');
+  assert.equal(release.r132.production_activation,'NOT_RUN');
+  assert.equal(prov.r132.source_lineage_manifest_sha256,'3e5edb9987aa7c9004dda3164a278da70a60495c0c128e2602426075a5222c10');
+  assert.equal(matrix.required.some(t=>t.id==='r132-protected-full'),true);
+});
+
+test('R132 shipped SBOM matches the actual audited bundled MCP SDK',async()=>{
+  const [pkg,bom,lock]=await Promise.all([read('package.json'),read('SBOM.cdx.json'),read('package-lock.json')]);
+  for(const name of ['@modelcontextprotocol/client','@modelcontextprotocol/server','@modelcontextprotocol/core']){
+    const entry=bom.components.find(v=>v.name===name);
+    assert.ok(entry,'missing SBOM component: '+name);
+    assert.equal(entry.version,'2.3.1',name+' SBOM stale');
+    assert.equal(lock.packages['node_modules/'+name].version,'2.3.1',name+' lockfile stale');
+    if(name!=='@modelcontextprotocol/core')assert.equal(pkg.dependencies[name],'2.3.1');
+  }
+});