deadbyte-mcp 0.15.51 → 0.15.52

package/src/autonomous-scope-r135.mjs

@@ -0,0 +1,91 @@
+import {createHash} from 'node:crypto';
+import {existsSync,lstatSync,realpathSync} from 'node:fs';
+import path from 'node:path';
+
+// R135 is an offline POLICY PROJECTION only. It cannot mint a lease or grant,
+// modify an active generation, or make a broad manual Coding grant safe to
+// inherit in the same process. Execution requires a separate proven boundary.
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const clone=value=>structuredClone(value);
+function realProjectRoot(input){
+ if(typeof input!=='string'||!path.isAbsolute(input))throw new Error('real project directory required');
+ const candidate=path.resolve(input),disk=path.parse(candidate).root;
+ const eq=(a,b)=>process.platform==='win32'?a.toLowerCase()===b.toLowerCase():a===b;
+ if(eq(candidate,disk))throw new Error('project-scoped root required');
+ try{
+  const info=lstatSync(candidate);
+  if(!info.isDirectory()||info.isSymbolicLink()||!eq(realpathSync(candidate),candidate)){
+   throw new Error('path redirected');
+  }
+  let cursor=candidate;
+  for(;;){
+   if(lstatSync(cursor).isSymbolicLink())throw new Error('linked ancestor');
+   const parent=path.dirname(cursor);
+   if(parent===cursor)break;
+   cursor=parent;
+  }
+ }catch{throw new Error('real project directory required')}
+ return candidate;
+}
+export function deriveIsolatedAutonomousScope({manualCodingPolicy,autonomousPolicy,scopeRootId,isolatedStateRoot}={}){
+ if(manualCodingPolicy?.schema!=='deadbyte.coding-policy.v1'||manualCodingPolicy.enabled!==true)
+  throw new Error('manual Coding policy schema invalid');
+ if(autonomousPolicy?.schema!=='deadbyte.autonomous-policy.v1'||autonomousPolicy.enabled!==true)
+  throw new Error('Autonomous policy schema invalid');
+ if(!/^[A-Za-z0-9._-]{1,64}$/.test(scopeRootId??''))throw new Error('invalid project scope');
+ if(!path.isAbsolute(isolatedStateRoot??''))throw new Error('isolated state root must be absolute');
+ const scopedRoot=manualCodingPolicy.roots?.[scopeRootId];
+ if(!scopedRoot)throw new Error('approved project root missing from Coding policy');
+ if(!Array.isArray(autonomousPolicy.root_ids)||autonomousPolicy.root_ids.length!==1||
+   autonomousPolicy.root_ids[0]!==scopeRootId)throw new Error('Autonomous root outside approved scope');
+ const safeRoot=realProjectRoot(scopedRoot.path);
+ const isolated=realProjectRoot(isolatedStateRoot);
+ const eq=(a,b)=>process.platform==='win32'?a.toLowerCase()===b.toLowerCase():a===b;
+ const manualLease=manualCodingPolicy.lease_file,autonLease=autonomousPolicy.lease_file;
+ for(const lease of [manualLease,autonLease]){
+  if(typeof lease!=='string'||!path.isAbsolute(lease))throw new Error('manual policy lease invalid');
+  const rel=path.relative(isolated,path.resolve(lease));
+  if(rel===''||(!path.isAbsolute(rel)&&rel!=='..'&&!rel.startsWith('..'+path.sep))){
+   throw new Error('isolated state root overlaps manual Coding lease');
+  }
+ }
+ // Fail closed for any profiles referencing another root or missing command.
+ const selectedCommands={};
+ for(const [id,profile] of Object.entries(autonomousPolicy.profiles??{})){
+  if(profile?.root_id!==scopeRootId)throw new Error('Autonomous profile '+id+' root outside approved scope');
+  const command=profile.command_id;
+  if(typeof command!=='string'||!Object.hasOwn(manualCodingPolicy.commands??{},command)){
+   throw new Error('Autonomous command missing from Coding policy');
+  }
+  const selected=clone(manualCodingPolicy.commands[command]);
+  if(!Array.isArray(selected.root_ids)||!selected.root_ids.includes(scopeRootId)){
+   throw new Error('Autonomous command '+command+' outside approved scope');
+  }
+  selected.root_ids=[scopeRootId];
+  selectedCommands[command]=selected;
+ }
+ if(autonomousPolicy.planner?.backend==='codex_app_server'&&
+     autonomousPolicy.planner.root_id!==scopeRootId)throw new Error('planner root outside approved scope');
+ const codingPolicy=clone(manualCodingPolicy);
+ codingPolicy.roots={[scopeRootId]:{...clone(scopedRoot),path:safeRoot}};
+ codingPolicy.commands=selectedCommands;
+ codingPolicy.lease_file=path.join(isolated,'runtime','coding-grant.json');
+ codingPolicy.evidence_dir=path.join(isolated,'evidence','coding');
+ if(existsSync(codingPolicy.lease_file)||existsSync(path.join(isolated,'runtime','autonomous-grant.json'))){
+  throw new Error('isolated grant file already present');
+ }
+ const codingBytes=Buffer.from(JSON.stringify(codingPolicy,null,2)+'\n','utf8');
+ const nextAutonomous=clone(autonomousPolicy);
+ nextAutonomous.root_ids=[scopeRootId];
+ nextAutonomous.coding_policy_sha256=sha(codingBytes);
+ nextAutonomous.lease_file=path.join(isolated,'runtime','autonomous-grant.json');
+ nextAutonomous.evidence_dir=path.join(isolated,'evidence','autonomous');
+ const autonomousBytes=Buffer.from(JSON.stringify(nextAutonomous,null,2)+'\n','utf8');
+ return Object.freeze({
+  scope_root_id:scopeRootId,isolated_state_root:isolated,
+  codingBytes,autonomousBytes,
+  codingPolicy,autonomousPolicy:nextAutonomous,
+  coding_sha256:sha(codingBytes),autonomous_sha256:sha(autonomousBytes),
+  status:'OFFLINE_UNAUTHORIZED_PROJECTION'
+ });
+}

package/src/commander-config-recovery-r137.mjs

@@ -0,0 +1,67 @@
+import {createHash,randomUUID} from 'node:crypto';
+import {readFile,writeFile,rename} from 'node:fs/promises';
+import path from 'node:path';
+
+// Reference design: Desktop Commander 0.3.0 MIT config-recovery.
+// DEADBYTE independently restricts salvage to NON-AUTHORITY display limits;
+// privileged configuration never flows into this recovery path.
+const MAX_BYTES=1024*1024;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const isObject=v=>v!==null&&typeof v==='object'&&!Array.isArray(v);
+
+export function salvageSafeCommanderLimits(raw){
+ if(typeof raw!=='string'||Buffer.byteLength(raw,'utf8')>MAX_BYTES)return {};
+ let str=raw.charCodeAt(0)===0xfeff?raw.slice(1):raw;
+ if(!str.trimStart().startsWith('{'))return {};
+ const base=str.indexOf('{'),ends=[];
+ let depth=0,quoted=false,escaped=false;
+ for(let i=base;i<str.length;i++){
+  const c=str[i];
+  if(quoted){if(escaped)escaped=false;else if(c==='\\')escaped=true;else if(c==='"')quoted=false;continue;}
+  if(c==='"'){quoted=true;continue;}
+  if(c==='{'||c==='['){depth++;continue;}
+  if(c==='}'||c===']'){depth--;if(depth===0){ends.push({index:i+1,complete:true});break;}if(depth<0)break;continue;}
+  if(c===','&&depth===1)ends.push({index:i,complete:false});
+ }
+ let obj={};
+ for(const item of ends.reverse()){
+  try{
+   const v=JSON.parse(str.slice(base,item.index)+(item.complete?'':'}'));
+   if(isObject(v)){obj=v;break;}
+  }catch{}
+ }
+ const safe={};
+ for(const [key,max] of [['fileReadLineLimit',1000],['fileWriteLineLimit',50]]){
+  const value=obj[key];
+  if(Number.isSafeInteger(value)&&value>=1&&value<=max)safe[key]=value;
+ }
+ return safe;
+}
+
+export async function recoverCorruptCommanderConfig(file,bytes,defaults){
+ if(!Buffer.isBuffer(bytes)||bytes.length>MAX_BYTES)throw new Error('Commander config corrupt or oversized; manual inspection required');
+ if(!isObject(defaults))throw new Error('recovery defaults invalid');
+ const safe=salvageSafeCommanderLimits(bytes.toString('utf8'));
+ const next={...structuredClone(defaults),...safe};
+ // The only trusted recovered settings are bounded display limits.
+ next.telemetryEnabled=false;
+ next.allowedDirectories=[];
+ next.blockedCommands=structuredClone(defaults.blockedCommands);
+ const current=await readFile(file);
+ if(sha(current)!==sha(bytes))throw new Error('Commander config changed during recovery; stop');
+ const backup=path.basename(file)+'.corrupt.'+Date.now()+'.'+randomUUID();
+ const backupPath=path.join(path.dirname(file),backup);
+ await writeFile(backupPath,bytes,{flag:'wx',mode:0o600});
+ const tmp=file+'.recover-'+randomUUID();
+ try{
+  await writeFile(tmp,JSON.stringify(next)+'\n',{flag:'wx',mode:0o600});
+  const verify=await readFile(file);
+  if(sha(verify)!==sha(bytes))throw new Error('Commander config changed during recovery; stop');
+  await rename(tmp,file);
+ }catch(error){
+  const {rm}=await import('node:fs/promises');
+  await rm(tmp,{force:true}).catch(()=>{});
+  throw error;
+ }
+ return {config:next,recovery:{status:'recovered',backup_filename:backup,corrupt_sha256:sha(bytes),salvaged_keys:Object.keys(safe)}};
+}

package/src/commander-extended-runtime.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { createDeadbytePdf } from './commander-pdf-r48.mjs';
 import { DEADBYTE_VERSION } from './version.mjs';
+import {recoverCorruptCommanderConfig} from './commander-config-recovery-r137.mjs';
 
 export const COMMANDER_EXTENDED_SCHEMA='deadbyte.commander-extended.v1';
 const MAX_VALUE=16384,MAX_FEEDBACK=4096,MAX_PREVIEW=65536;
@@ -44,17 +45,33 @@ function makePdf(text){
 export function createCommanderExtendedRuntime({stateRoot,history=null,prompts=DEFAULT_PROMPTS,resources=[]}={}){
   if(typeof stateRoot!=='string'||!stateRoot)throw new Error('extended runtime stateRoot required');
   const configPath=path.join(stateRoot,'commander-config.json'),feedbackDir=path.join(stateRoot,'feedback');
-  let configCache=null;
+  let configCache=null,recovery=null,loadPromise=null;
   async function loadConfig(){
     if(configCache)return configCache;
-    try{configCache={...structuredClone(COMPAT_CONFIG_DEFAULTS),...JSON.parse(await readFile(configPath,'utf8'))};}
-    catch(e){if(e?.code!=='ENOENT')throw e;configCache=structuredClone(COMPAT_CONFIG_DEFAULTS);}
-    return configCache;
+    if(!loadPromise)loadPromise=(async()=>{
+      let bytes;
+      try{bytes=await readFile(configPath);}
+      catch(e){
+        if(e?.code!=='ENOENT')throw e;
+        configCache=structuredClone(COMPAT_CONFIG_DEFAULTS);return configCache;
+      }
+      try{
+        const parsed=JSON.parse(bytes.toString('utf8'));
+        if(!parsed||typeof parsed!=='object'||Array.isArray(parsed))throw new SyntaxError('config must be an object');
+        configCache={...structuredClone(COMPAT_CONFIG_DEFAULTS),...parsed};
+      }catch(e){
+        if(!(e instanceof SyntaxError))throw e;
+        const result=await recoverCorruptCommanderConfig(configPath,bytes,COMPAT_CONFIG_DEFAULTS);
+        configCache=result.config;recovery=result.recovery;
+      }
+      return configCache;
+    })();
+    try{return await loadPromise;}finally{loadPromise=null;}
   }
   async function getConfig({key=null}={}){
     const cfg=await loadConfig();
     if(key!==null&&!keyOk(key))throw new Error('config key invalid');
-    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',config:key===null?structuredClone(cfg):{[key]:cfg[key]},config_sha256:sha256(cfg)};
+    return {schema:COMMANDER_EXTENDED_SCHEMA,status:'ok',config:key===null?structuredClone(cfg):{[key]:cfg[key]},config_sha256:sha256(cfg),...(recovery?{recovery:structuredClone(recovery)}:{})};
   }
   async function setConfigValue({key,value,expected_sha256}){
     if(!keyOk(key))throw new Error('config key invalid');

package/src/commander-external-process-r48.mjs

@@ -61,17 +61,39 @@ export function createCommanderExternalProcessRuntime({observationRuntime,hostPo
     let cursor=null,first=null;
     const processes=[];
     const receiptIds=[];
+    const cursorSet=new Set(),pidSet=new Set();
     do{
       const page=await observationRuntime.processList({limit:PAGE_SIZE,includeExternal:true,cursor});
       if(page?.status!=='ok'||!Array.isArray(page.processes)) throw new Error('external process observation failed');
+      if(typeof page.snapshot_id!=='string'||!/^[0-9a-f]{64}$/.test(page.snapshot_id))
+        throw new Error('external process observation snapshot identity invalid');
+      if(typeof page.observed_at_utc!=='string'||!ISO_UTC.test(page.observed_at_utc)||
+         !Number.isFinite(Date.parse(page.observed_at_utc)))
+        throw new Error('external process observation timestamp invalid');
       if(!first) first=page;
-      else if(page.snapshot_id!==first.snapshot_id) throw new Error('external process observation snapshot changed during pagination');
+      else{
+        if(page.snapshot_id!==first.snapshot_id) throw new Error('external process observation snapshot changed during pagination');
+        if(page.observed_at_utc!==first.observed_at_utc)
+          throw new Error('external process observation time changed during pagination');
+      }
+      if(page.processes.length>PAGE_SIZE)throw new Error('external process observation page exceeds bounded limit');
       for(const item of page.processes){
         if(processes.length>=MAX_PROCESSES) throw new Error('external process observation exceeds bounded process cap');
-        processes.push(normalizeIdentity(item));
+        const identity=normalizeIdentity(item);
+        if(pidSet.has(identity.pid))throw new Error('external process observation duplicate PID');
+        pidSet.add(identity.pid);
+        processes.push(identity);
       }
       if(typeof page.receipt_id==='string') receiptIds.push(page.receipt_id);
-      cursor=page.next_cursor??null;
+      const next=page.next_cursor??null;
+      if(next!==null){
+        if(typeof next!=='string'||next.length<1||next.length>8192)throw new Error('external process observation cursor invalid');
+        if(cursorSet.has(next))throw new Error('external process pagination cursor repeated');
+        cursorSet.add(next);
+        if(cursorSet.size>Math.ceil(MAX_PROCESSES/PAGE_SIZE)+1)
+          throw new Error('external process pagination exceeded page limit');
+      }
+      cursor=next;
     }while(cursor!==null);
     return {
       status:'ok',

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/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.51';
+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()=>{