deadbyte-mcp 0.15.18 → 0.15.19

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

@@ -1,59 +1,85 @@
 import * as z from 'zod/v4';
 import { createHash } from 'node:crypto';
 import path from 'node:path';
+import { readCommanderUrl } from './commander-url-reader-r48.mjs';
+import { readDocxBytes, createDocxBytes, editDocxBytes, readXlsxBytes, editXlsxBytes, createXlsxBytes, appendXlsxBytes } from './commander-office-reader-r48.mjs';
+import { editDeadbytePdf, parseDeadbytePdf, readPdfText } from './commander-pdf-r48.mjs';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
+const RDC_PROCESS_READ_CHUNK=256*1024;
+const RDC_PROCESS_SNAPSHOT_MAX=16*1024*1024;
+
+function splitLineRanges(bytes){
+  const ranges=[];
+  let start=0;
+  for(let i=0;i<bytes.length;i++){
+    const b=bytes[i];
+    if(b!==0x0a&&b!==0x0d) continue;
+    let next=i+1;
+    if(b===0x0d&&next<bytes.length&&bytes[next]===0x0a) next++;
+    ranges.push({start,end:i,next});
+    start=next;i=next-1;
+  }
+  if(start<bytes.length) ranges.push({start,end:bytes.length,next:bytes.length});
+  return ranges;
+}
+function decodeLines(bytes,ranges){return ranges.map(r=>bytes.subarray(r.start,r.end).toString('utf8'));}
 
 const anyRecord = z.record(z.string(), z.unknown());
-const empty = z.strictObject({});
+const empty = z.object({});
 const origin = z.enum(['ui','llm']).optional();
 
 const RDC = Object.freeze({
-  read_file: z.strictObject({
+  read_file: z.object({
     path:z.string(), isUrl:z.boolean().optional().default(false),
     offset:z.number().optional().default(0), length:z.number().optional().default(1000),
     sheet:z.string().optional(), range:z.string().optional(), options:anyRecord.optional(),
     origin
   }),
-  read_multiple_files:z.strictObject({paths:z.array(z.string())}),
-  write_file:z.strictObject({
+  read_multiple_files:z.object({paths:z.array(z.string())}),
+  write_file:z.object({
     path:z.string(), content:z.string(),
     mode:z.enum(['rewrite','append']).default('rewrite'), origin
   }),
-  create_directory:z.strictObject({path:z.string()}),
-  list_directory:z.strictObject({path:z.string(),depth:z.number().optional().default(2),origin}),
-  move_file:z.strictObject({source:z.string(),destination:z.string()}),
-  get_file_info:z.strictObject({path:z.string()}),
+  create_directory:z.object({path:z.string()}),
+  list_directory:z.object({path:z.string(),depth:z.number().optional().default(2),origin}),
+  move_file:z.object({source:z.string(),destination:z.string()}),
+  get_file_info:z.object({path:z.string()}),
   edit_block:z.object({
     file_path:z.string(), old_string:z.string().optional(), new_string:z.string().optional(),
     expected_replacements:z.number().optional().default(1), range:z.string().optional(),
     content:z.unknown().optional(), options:anyRecord.optional(), origin
-  }),
-  start_process:z.strictObject({command:z.string(),timeout_ms:z.number(),shell:z.string().optional(),verbose_timing:z.boolean().optional(),origin}),
-  read_process_output:z.strictObject({pid:z.number(),timeout_ms:z.number().optional(),offset:z.number().optional(),length:z.number().optional(),verbose_timing:z.boolean().optional()}),
-  interact_with_process:z.strictObject({pid:z.number(),input:z.string(),timeout_ms:z.number().optional(),wait_for_prompt:z.boolean().optional(),verbose_timing:z.boolean().optional()}),
-  force_terminate:z.strictObject({pid:z.number()}),
+  }).refine(data=>((data.old_string!==undefined&&data.old_string!==''&&data.new_string!==undefined)||(data.range!==undefined&&data.range!==''&&data.content!==undefined&&data.content!=='')),{message:'Must provide either (old_string + new_string) or (range + content)'}),
+  start_process:z.object({command:z.string(),timeout_ms:z.number(),shell:z.string().optional(),verbose_timing:z.boolean().optional(),origin}),
+  read_process_output:z.object({pid:z.number(),timeout_ms:z.number().optional(),offset:z.number().optional(),length:z.number().optional(),verbose_timing:z.boolean().optional()}),
+  interact_with_process:z.object({pid:z.number(),input:z.string(),timeout_ms:z.number().optional(),wait_for_prompt:z.boolean().optional(),verbose_timing:z.boolean().optional()}),
+  force_terminate:z.object({pid:z.number()}),
   list_sessions:empty,
   list_processes:empty,
-  kill_process:z.strictObject({pid:z.number()}),
-  start_search:z.strictObject({
+  kill_process:z.object({pid:z.number()}),
+  start_search:z.object({
     path:z.string(),pattern:z.string(),searchType:z.enum(['files','content']).default('files'),
     filePattern:z.string().optional(),ignoreCase:z.boolean().optional().default(true),
     maxResults:z.number().optional(),includeHidden:z.boolean().optional().default(false),
     contextLines:z.number().optional().default(5),timeout_ms:z.number().optional(),
     earlyTermination:z.boolean().optional(),literalSearch:z.boolean().optional().default(false),origin
   }),
-  get_more_search_results:z.strictObject({sessionId:z.string(),offset:z.number().optional().default(0),length:z.number().optional().default(100)}),
-  stop_search:z.strictObject({sessionId:z.string()}),
+  get_more_search_results:z.object({sessionId:z.string(),offset:z.number().optional().default(0),length:z.number().optional().default(100)}),
+  stop_search:z.object({sessionId:z.string()}),
   list_searches:empty,
-  write_pdf:z.strictObject({
+  write_pdf:z.object({
     path:z.string(),
-    content:z.union([z.string(),z.array(z.union([
-      z.strictObject({type:z.literal('insert'),pageIndex:z.number(),markdown:z.string().optional(),sourcePdfPath:z.string().optional(),pdfOptions:anyRecord.optional()}),
-      z.strictObject({type:z.literal('delete'),pageIndexes:z.array(z.number())})
-    ]))]),
+    content:z.preprocess(value=>{
+      if(typeof value==='string'&&value.trim().startsWith('[')){
+        try{return JSON.parse(value);}catch{}
+      }
+      return value;
+    },z.union([z.string(),z.array(z.union([
+      z.object({type:z.literal('insert'),pageIndex:z.number(),markdown:z.string().optional(),sourcePdfPath:z.string().optional(),pdfOptions:anyRecord.optional()}),
+      z.object({type:z.literal('delete'),pageIndexes:z.array(z.number())})
+    ]))])),
     outputPath:z.string().optional(),
-    options:anyRecord.optional(), origin
+    options:anyRecord.optional()
   })
 });
 
@@ -114,77 +140,204 @@ function richFormat(pathname){
   }[ext]??null;
 }
 
-export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime=null,searchRuntime=null,extendedRuntime=null}={}){
+export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime=null,searchRuntime=null,extendedRuntime=null,externalProcessRuntime=null,urlReader=readCommanderUrl}={}){
   const searchSessions=new Map();
 
   async function readFile(args){
-    if(!machineFsRuntime) throw new Error('machine filesystem runtime is disabled');
-    if(args.isUrl) throw new Error('URL reads are not available in the native DEADBYTE plane');
-    if(args.sheet!==undefined||args.range!==undefined) {
-      throw new Error('sheet/range reads require a native spreadsheet adapter; request rejected rather than silently ignored');
-    }
-    if(args.options!==undefined && Object.keys(args.options).length>0) {
-      throw new Error('read_file options require a native format adapter; unsupported options are rejected rather than silently ignored');
+    const requestedOffset=args.offset??0;
+    const requestedLength=args.length??1000;
+    if(!Number.isInteger(requestedOffset)) throw new Error('offset must be an integer');
+    if(!Number.isInteger(requestedLength)||requestedLength<0) throw new Error('length must be a non-negative integer');
+    const ignoredOptions=args.options&&typeof args.options==='object'&&!Array.isArray(args.options)?Object.keys(args.options).sort():[];
+    const optionMeta=ignoredOptions.length?{ignoredOptions}:{};
+    if(args.isUrl){
+      if(args.sheet!==undefined||args.range!==undefined) throw new Error('sheet/range options are not valid for URL reads');
+      const remote=await urlReader(args.path);
+      if(remote.isPdf===true){
+        const pdf=readPdfText(Buffer.from(remote.content,'base64'));
+        const content=pdf.pages.map((page,index)=>`## Page ${index+1}\n${page}`).join('\n\n');
+        return text(content,false,{
+          path:args.path,content,mimeType:'text/markdown',isImage:false,isPdf:true,
+          pageOffset:0,pageCount:pdf.page_count,totalPages:pdf.page_count,profile:pdf.profile,partial:pdf.partial===true,warnings:pdf.warnings??[],
+          fileSha256:remote.sha256,url:remote.url,...optionMeta
+        });
+      }
+      return text(remote.content,false,{
+        path:args.path,content:remote.content,mimeType:remote.mimeType,
+        isImage:remote.isImage===true,isPdf:false,
+        lineOffset:0,lineCount:remote.isImage?0:remote.content.replaceAll('\r\n','\n').replaceAll('\r','\n').split('\n').length,
+        fileSha256:remote.sha256,url:remote.url,...optionMeta
+      });
     }
-    if(!Number.isInteger(args.offset??0)||args.offset<0) throw new Error('offset must be a non-negative integer');
-    if(!Number.isInteger(args.length??1000)||args.length<0) throw new Error('length must be a non-negative integer');
+    if(!machineFsRuntime) throw new Error('machine filesystem runtime is disabled');
     const target=resolveRdcPath(machineFsRuntime,args.path);
-    const start=args.offset??0;
-    const length=args.length??1000;
-    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 fileSha256=raw.file_sha256??sha256Bytes(Buffer.from(raw.data_base64,'base64'));
     const ext=path.extname(args.path).toLowerCase();
+    const richDocument=ext==='.docx'||ext==='.xlsx'||ext==='.xlsm'||ext==='.pdf';
     const imageMime={'.png':'image/png','.jpg':'image/jpeg','.jpeg':'image/jpeg','.gif':'image/gif','.webp':'image/webp'}[ext];
+    if((args.sheet!==undefined||args.range!==undefined)&&!(ext==='.xlsx'||ext==='.xlsm')) {
+      throw new Error('sheet/range reads are valid only for native XLSX/XLSM reads');
+    }
+    if(requestedOffset<0&&!richDocument&&!imageMime&&ext!=='.xls'){
+      const policyMax=Math.min(64*1024*1024,machineFsRuntime.policy.max_read_bytes??4*1024*1024);
+      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');
+      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);
+      }
+      let all=decoded.split('\n');
+      if(all.length&&all.at(-1)==='') all.pop();
+      const wanted=Math.abs(requestedOffset);
+      if((tail.offset??0)>0&&all.length<wanted) throw new Error(`text tail window does not contain ${wanted} complete lines`);
+      const selected=all.slice(Math.max(0,all.length-wanted));
+      const content=selected.join('\n');
+      return text(content,false,{
+        path:args.path,content,mimeType:'text/plain',isImage:false,isPdf:false,
+        lineOffset:Math.max(0,all.length-selected.length),lineCount:selected.length,
+        fileSha256:tail.file_sha256??null,tailByteOffset:tail.offset??null,fileSize:tail.file_size??null,...optionMeta
+      });
+    }
+    const maxRead=richDocument?64*1024*1024:4*1024*1024;
+    const raw=await machineFsRuntime.read({
+      rootId:target.rootId,relativePath:target.relativePath,offset:0,
+      maxBytes:Math.min(maxRead,machineFsRuntime.policy.max_read_bytes??maxRead),
+      hashFile:richDocument
+    });
+    if(richDocument&&raw.eof===false) throw new Error('document exceeds bounded native read limit');
+    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);
+
+    if(ext==='.docx'){
+      const doc=readDocxBytes(bytes,{path:args.path,offset:requestedOffset,length:requestedLength});
+      return text(doc.content,false,{path:args.path,content:doc.content,mimeType:doc.mimeType,isImage:false,isPdf:false,fileSha256,...doc.metadata,outline:doc.outline,...optionMeta});
+    }
+    if(ext==='.xlsx'||ext==='.xlsm'){
+      const book=readXlsxBytes(bytes,{path:args.path,sheet:args.sheet,range:args.range,offset:requestedOffset,length:requestedLength});
+      return text(book.content,false,{path:args.path,content:book.content,mimeType:book.mimeType,isImage:false,isPdf:false,fileSha256,...book.metadata,sheetName:book.sheetName,data:book.data,totalRows:book.totalRows,returnedRows:book.returnedRows,...optionMeta});
+    }
+    if(ext==='.pdf'){
+      const pdf=readPdfText(bytes);
+      const start=requestedOffset<0?Math.max(0,pdf.page_count+requestedOffset):Math.min(requestedOffset,pdf.page_count);
+      const count=requestedOffset<0?pdf.page_count-start:requestedLength;
+      const selected=pdf.pages.slice(start,start+count);
+      const content=selected.map((page,index)=>`## Page ${start+index+1}\n${page}`).join('\n\n');
+      return text(content,false,{
+        path:args.path,content,mimeType:'text/markdown',isImage:false,isPdf:true,fileSha256,
+        pageOffset:start,pageCount:selected.length,totalPages:pdf.page_count,profile:pdf.profile,partial:pdf.partial===true,warnings:pdf.warnings??[],...optionMeta
+      });
+    }
+
     if(imageMime) {
       const content=raw.data_base64;
-      return text(content,false,{path:args.path,content,mimeType:imageMime,isImage:true,isPdf:false,fileSha256});
+      return text(content,false,{path:args.path,content,mimeType:imageMime,isImage:true,isPdf:false,fileSha256,...optionMeta});
     }
-    if(['.xlsx','.xls','.xlsm','.pdf','.docx'].includes(ext)) {
-      throw new Error(`format ${ext} requires a native document adapter; request rejected rather than returned as plain text`);
+    if(ext==='.xls') {
+      throw new Error('format .xls requires a native BIFF adapter; request rejected rather than returned as plain text');
     }
     const all=linesFrom(raw.data_base64);
-    const selected=all.slice(start,start+length);
-    const content=selected.join('\\n')+(start+length<all.length?'\\n':'');
-    return text(content,false,{path:args.path,content,mimeType:'text/plain',isImage:false,isPdf:false,lineOffset:start,lineCount:selected.length,fileSha256});
+    const start=requestedOffset<0?Math.max(0,all.length+requestedOffset):Math.min(requestedOffset,all.length);
+    const end=requestedOffset<0?all.length:Math.min(all.length,start+requestedLength);
+    const selected=all.slice(start,end);
+    const content=selected.join('\n')+(requestedOffset>=0&&end<all.length?'\n':'');
+    return text(content,false,{path:args.path,content,mimeType:'text/plain',isImage:false,isPdf:false,lineOffset:start,lineCount:selected.length,fileSha256,...optionMeta});
   }
 
   async function readMultipleFiles(args){
-    if(!machineFsRuntime) throw new Error('machine filesystem runtime is disabled');
     const results=[];
     for(const pathname of args.paths){
       try{
-        const target=resolveRdcPath(machineFsRuntime,pathname);
-        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 fileSha256=raw.file_sha256??sha256Bytes(Buffer.from(raw.data_base64,'base64'));
-        const ext=path.extname(pathname).toLowerCase();
-        const mime=richFormat(pathname);
-        if(['.png','.jpg','.jpeg','.gif','.webp'].includes(ext)){
-          results.push(rdcFileResult(pathname,{content:raw.data_base64,mime_type:mime,isImage:true,isPdf:false,fileSha256}));
-        } else if(['.xlsx','.xls','.xlsm','.pdf','.docx'].includes(ext)){
-          results.push({path:pathname,error:'format '+ext+' requires a native document adapter; request rejected rather than returned as plain text'});
-        } else {
-          const content=Buffer.from(raw.data_base64,'base64').toString('utf8');
-          results.push(rdcFileResult(pathname,{content,mime_type:'text/plain',isImage:false,isPdf:false,fileSha256}));
-        }
+        const result=await readFile({path:pathname,isUrl:false,offset:0,length:1000});
+        if(result?.isError) throw new Error(result?.structuredContent?.error??result?.content?.[0]?.text??'read failed');
+        const item=result?.structuredContent??{};
+        results.push({
+          path:pathname,
+          content:String(item.content??result?.content?.[0]?.text??''),
+          mimeType:item.mimeType??'text/plain',
+          isImage:item.isImage===true,
+          isPdf:item.isPdf===true,
+          fileSha256:item.fileSha256??null,
+          ...(item.isPdf?{payload:{
+            metadata:{totalPages:item.totalPages??item.pageCount??0,profile:item.profile??null},
+            pages:item.content?String(item.content).split(/\n\n(?=## Page \d+\n)/):[]
+          }}:{})
+        });
       }catch(error){
         results.push({path:pathname,error:error instanceof Error?error.message:String(error)});
       }
     }
-    return text(results.map(x=>x.error?`${x.path}: Error: ${x.error}`:`${x.path}:\\n${x.content}`).join('\\n\\n'),false,{results});
+    return text(results.map(x=>x.error?`${x.path}: Error: ${x.error}`:`${x.path}:\n${x.content}`).join('\n\n'),false,{results});
   }
 
   async function writeFile(args){
     const target=resolveRdcPath(machineFsRuntime,args.path);
+    const ext=path.extname(args.path).toLowerCase();
+    const imageExts=new Set(['.png','.jpg','.jpeg','.gif','.webp']);
+    if(ext==='.pdf') throw new Error('PDF writes must use write_pdf to preserve document semantics');
+    if(ext==='.docx'){
+      if(args.mode==='append') throw new Error('DOCX append not supported. Use edit_block to modify existing DOCX files.');
+      const generated=createDocxBytes(args.content);
+      let expected='absent';
+      try{
+        const current=await machineFsRuntime.read({rootId:target.rootId,relativePath:target.relativePath,offset:0,maxBytes:Math.min(64*1024*1024,machineFsRuntime.policy.max_read_bytes??64*1024*1024),hashFile:true});
+        if(current.eof===false) throw new Error('DOCX target exceeds bounded native write limit');
+        expected=current.file_sha256??sha256Bytes(Buffer.from(current.data_base64,'base64'));
+      }catch(error){if(!/not found|ENOENT/i.test(String(error))) throw error;}
+      const result=await machineFsRuntime.write({rootId:target.rootId,relativePath:target.relativePath,content:generated.bytes.toString('base64'),encoding:'base64',expectedSha256:expected});
+      return text(`Successfully wrote ${args.path}`,false,{path:args.path,mode:args.mode,status:'committed',format:'docx',bytesSha256:generated.bytes_sha256,...result});
+    }
+    if(imageExts.has(ext)) throw new Error(`image write_file for ${ext} requires a dedicated native writer`);
+    if(ext==='.xls') throw new Error('legacy .xls BIFF write is not supported by a native writer');
+
+    if(ext==='.xlsx'||ext==='.xlsm'){
+      let parsed;
+      try{parsed=JSON.parse(args.content);}catch{throw new Error('Invalid XLSX content: expected JSON 2D array or object of sheet arrays');}
+      let expected='absent',existing=null;
+      try{
+        const maxRead=Math.min(64*1024*1024,machineFsRuntime.policy.max_read_bytes??64*1024*1024);
+        const current=await machineFsRuntime.read({
+          rootId:target.rootId,relativePath:target.relativePath,offset:0,maxBytes:maxRead,hashFile:true
+        });
+        if(current.eof===false) throw new Error('XLSX target exceeds bounded native write limit');
+        existing=Buffer.from(current.data_base64,'base64');
+        expected=current.file_sha256??sha256Bytes(existing);
+      }catch(error){
+        if(!/not found|ENOENT/i.test(String(error))) throw error;
+        if(args.mode==='append') existing=null;
+      }
+      const generated=args.mode==='append'&&existing?appendXlsxBytes(existing,parsed):createXlsxBytes(parsed);
+      const bytes=generated.bytes??Buffer.from(generated.bytes_base64,'base64');
+      const result=await machineFsRuntime.write({
+        rootId:target.rootId,relativePath:target.relativePath,
+        content:bytes.toString('base64'),encoding:'base64',expectedSha256:expected
+      });
+      return text(`Successfully wrote ${args.path}`,false,{
+        path:args.path,mode:args.mode,status:'committed',format:'xlsx',
+        bytesSha256:generated.bytes_sha256??generated.after_sha256??sha256Bytes(bytes),
+        appendedRows:generated.appended_rows??0,sheetCount:generated.sheet_count??null,...result
+      });
+    }
+
     let expected='absent';
     let content=args.content;
     try{
-      const current=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:true});
-      expected=current.file_sha256??'absent';
-      if(args.mode==='append') content=Buffer.from(current.data_base64,'base64').toString('utf8')+args.content;
+      const current=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:true
+      });
+      if(current.eof===false) throw new Error('text write target exceeds bounded compatibility limit');
+      const currentBytes=Buffer.from(current.data_base64,'base64');
+      expected=current.file_sha256??sha256Bytes(currentBytes);
+      if(args.mode==='append') content=currentBytes.toString('utf8')+args.content;
     }catch(error){
-      if(args.mode==='append' || !/not found|ENOENT/i.test(String(error))) throw error;
+      if(args.mode==='append'||!/not found|ENOENT/i.test(String(error))) throw error;
     }
-    const result=await machineFsRuntime.write({rootId:target.rootId,relativePath:target.relativePath,content,encoding:'utf8',expectedSha256:expected});
+    const result=await machineFsRuntime.write({
+      rootId:target.rootId,relativePath:target.relativePath,content,encoding:'utf8',expectedSha256:expected
+    });
     return text(`Successfully wrote ${args.path}`,false,{path:args.path,mode:args.mode,status:'committed',...result});
   }
 
@@ -196,9 +349,40 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
 
   async function listDirectory(args){
     const target=resolveRdcPath(machineFsRuntime,args.path);
-    const entries=await machineFsRuntime.list({rootId:target.rootId,relativePath:target.relativePath,limit:1000,hashFiles:false});
-    const rows=entries.entries.map(e=>`${e.type==='directory'?'[DIR]':'[FILE]'} ${e.path}`);
-    return text(rows.join('\\n'),false,{path:args.path,entries:entries.entries,next_cursor:entries.next_cursor??null});
+    const depth=args.depth??2;
+    if(!Number.isInteger(depth)||depth<1||depth>10) throw new Error('list_directory depth must be an integer in [1, 10]');
+    const maxEntries=4096,all=[];
+    let truncated=false;
+    let frontier=[{relativePath:target.relativePath,level:1}];
+    for(let level=1;level<=depth&&frontier.length&&!truncated;level++){
+      const next=[];
+      for(const node of frontier){
+        let cursor=null;
+        const seen=new Set();
+        do{
+          const page=await machineFsRuntime.list({
+            rootId:target.rootId,relativePath:node.relativePath,cursor,limit:1000,hashFiles:false
+          });
+          for(const entry of page.entries??[]){
+            if(all.length>=maxEntries){truncated=true;break;}
+            all.push(entry);
+            const kind=entry.kind??entry.type;
+            if(kind==='directory'&&level<depth) next.push({relativePath:entry.path,level:level+1});
+          }
+          if(truncated) break;
+          const nextCursor=page.next_cursor??null;
+          if(nextCursor!==null){
+            if(seen.has(nextCursor)) throw new Error('list_directory cursor loop detected');
+            seen.add(nextCursor);
+          }
+          cursor=nextCursor;
+        }while(cursor!==null);
+        if(truncated) break;
+      }
+      frontier=next;
+    }
+    const rows=all.map(e=>`${(e.kind??e.type)==='directory'?'[DIR]':'[FILE]'} ${e.path}`);
+    return text(rows.join('\n'),false,{path:args.path,depth,entries:all,truncated,entryCount:all.length});
   }
 
   async function moveFile(args){
@@ -216,24 +400,99 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
   }
 
   async function editBlock(args){
-    if(args.range!==undefined) throw new Error('structured range edits require a native DEADBYTE document adapter');
-    if(args.old_string===undefined||args.new_string===undefined) throw new Error('Must provide either old_string + new_string');
     const target=resolveRdcPath(machineFsRuntime,args.file_path);
+    const ext=path.extname(args.file_path).toLowerCase();
+    if(ext==='.docx'){
+      if(args.range!==undefined) throw new Error('DOCX edit_block uses old_string/new_string XML replacement, not range mode');
+      if(args.old_string===undefined||args.new_string===undefined) throw new Error('DOCX edit requires old_string + new_string');
+      const maxRead=Math.min(64*1024*1024,machineFsRuntime.policy.max_read_bytes??64*1024*1024);
+      const raw=await machineFsRuntime.read({
+        rootId:target.rootId,relativePath:target.relativePath,offset:0,maxBytes:maxRead,hashFile:true
+      });
+      if(raw.eof===false) throw new Error('DOCX document exceeds bounded native edit limit');
+      const before=Buffer.from(raw.data_base64,'base64');
+      const beforeSha=raw.file_sha256??sha256Bytes(before);
+      const edited=editDocxBytes(before,{
+        oldString:args.old_string,newString:args.new_string,expectedReplacements:args.expected_replacements
+      });
+      const result=await machineFsRuntime.write({
+        rootId:target.rootId,relativePath:target.relativePath,
+        content:edited.bytes_base64,encoding:'base64',expectedSha256:beforeSha
+      });
+      return text(`Successfully edited ${args.file_path}`,false,{
+        path:args.file_path,status:'committed',format:'docx',replacements:edited.replacements,
+        beforeSha256:edited.before_sha256,afterSha256:edited.after_sha256,...result
+      });
+    }
+    if(args.range!==undefined){
+      const ext=path.extname(args.file_path).toLowerCase();
+      if(ext!=='.xlsx'&&ext!=='.xlsm') throw new Error('structured range edits are supported only for XLSX/XLSM');
+      if(args.content===undefined) throw new Error('range edit requires content');
+      const maxRead=Math.min(64*1024*1024,machineFsRuntime.policy.max_read_bytes??64*1024*1024);
+      const raw=await machineFsRuntime.read({
+        rootId:target.rootId,relativePath:target.relativePath,offset:0,maxBytes:maxRead,hashFile:true
+      });
+      if(raw.eof===false) throw new Error('XLSX document exceeds bounded native edit limit');
+      const before=Buffer.from(raw.data_base64,'base64');
+      const beforeSha=raw.file_sha256??sha256Bytes(before);
+      const edited=editXlsxBytes(before,{range:args.range,content:args.content});
+      const result=await machineFsRuntime.write({
+        rootId:target.rootId,relativePath:target.relativePath,
+        content:edited.bytes_base64,encoding:'base64',expectedSha256:beforeSha
+      });
+      const ignoredOptions=args.options&&typeof args.options==='object'&&!Array.isArray(args.options)?Object.keys(args.options).sort():[];
+      return text(`Successfully edited ${args.file_path} range ${args.range}`,false,{
+        path:args.file_path,status:'committed',range:args.range,sheet:edited.sheet,
+        updatedCells:edited.updated_cells,beforeSha256:edited.before_sha256,afterSha256:edited.after_sha256,
+        ...(ignoredOptions.length?{ignoredOptions}:{}),...result
+      });
+    }
+    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 fileSha256=raw.file_sha256??sha256Bytes(Buffer.from(raw.data_base64,'base64'));
-    const current=Buffer.from(raw.data_base64,'base64').toString('utf8');
+    if(raw.eof===false) throw new Error('text edit target exceeds bounded compatibility edit limit');
+    const before=Buffer.from(raw.data_base64,'base64');
+    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}`);
     const next=current.split(args.old_string).join(args.new_string);
-    const result=await machineFsRuntime.write({rootId:target.rootId,relativePath:target.relativePath,content:next,encoding:'utf8',expectedSha256:raw.file_sha256});
+    const result=await machineFsRuntime.write({rootId:target.rootId,relativePath:target.relativePath,content:next,encoding:'utf8',expectedSha256:fileSha256});
     return text(`Successfully edited ${args.file_path}`,false,{path:args.file_path,status:'committed',replacements:count,...result});
   }
 
-  function profileForCommand(){
-    const id=process.env.DEADBYTE_COMMANDER_COMPAT_PROFILE;
-    if(!id) throw new Error('RDC start_process requires DEADBYTE_COMMANDER_COMPAT_PROFILE to bind command execution to a configured profile');
-    return id;
+  function shellKey(value){
+    if(typeof value!=='string'||!value.trim()) return null;
+    const base=path.win32.basename(value.trim()).toLowerCase();
+    return base.endsWith('.exe')?base.slice(0,-4):base;
+  }
+  function profileForCommand(shell=null){
+    const forced=process.env.DEADBYTE_COMMANDER_COMPAT_PROFILE;
+    if(forced) return forced;
+    const profiles=processRuntime?.policy?.profiles??{};
+    const requested=shellKey(shell);
+    if(requested){
+      const matches=Object.entries(profiles).filter(([,profile])=>shellKey(profile?.executable)===requested);
+      const raw=matches.find(([,profile])=>profile?.allow_raw_input===true);
+      if(raw) return raw[0];
+      if(matches.length===1) return matches[0][0];
+      if(matches.length>1) throw new Error(`RDC shell '${shell}' maps to multiple process profiles; set DEADBYTE_COMMANDER_COMPAT_PROFILE`);
+      throw new Error(`RDC shell '${shell}' is not represented by an approved DEADBYTE process profile`);
+    }
+    if(profiles.powershell_repl?.allow_raw_input===true) return 'powershell_repl';
+    const raw=Object.entries(profiles).filter(([,profile])=>profile?.allow_raw_input===true);
+    if(raw.length===1) return raw[0][0];
+    throw new Error('RDC start_process requires an approved raw-input process profile or DEADBYTE_COMMANDER_COMPAT_PROFILE');
+  }
+  function assertRequestedShell(profileId,shell){
+    if(shell===undefined) return;
+    const profile=processRuntime?.policy?.profiles?.[profileId];
+    if(profile){
+      if(shellKey(profile.executable)!==shellKey(shell)) throw new Error(`RDC shell '${shell}' does not match approved profile '${profileId}'`);
+      return;
+    }
+    const configured=process.env.DEADBYTE_COMMANDER_COMPAT_SHELL;
+    if(configured!==shell) throw new Error('RDC shell does not match the explicitly configured compatibility shell');
   }
   function defaultProcessRoot(){
     const id=process.env.DEADBYTE_COMMANDER_COMPAT_ROOT;
@@ -243,14 +502,114 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     throw new Error('RDC start_process requires DEADBYTE_COMMANDER_COMPAT_ROOT when multiple process roots exist');
   }
   const pidMap=new Map();
+  const processCompatState=new Map();
+
+  function boundedLineLength(value){
+    const n=value??1000;
+    if(!Number.isInteger(n)||n<1||n>100000) throw new Error('RDC process length must be an integer in [1,100000]');
+    return n;
+  }
+  function boundedWait(value,fallback){
+    const n=value??fallback;
+    if(!Number.isFinite(n)||n<0||n>300000) throw new Error('RDC process timeout_ms must be in [0,300000]');
+    return Math.floor(n);
+  }
+  async function processStreamSnapshot(sessionId){
+    const probe=await processRuntime.read({sessionId,offset:0,maxBytes:1,waitMs:0});
+    const earliest=Number.isInteger(probe.earliest_offset)?probe.earliest_offset:probe.offset;
+    const streamHead=Number.isInteger(probe.stream_head)?probe.stream_head:probe.next_offset;
+    if(!Number.isInteger(earliest)||!Number.isInteger(streamHead)||earliest<0||streamHead<earliest) throw new Error('native process stream identity invalid');
+    if(streamHead-earliest>RDC_PROCESS_SNAPSHOT_MAX) throw new Error(`RDC retained process output exceeds ${RDC_PROCESS_SNAPSHOT_MAX} byte compatibility bound`);
+    const chunks=[];
+    let position=earliest;
+    while(position<streamHead){
+      const page=await processRuntime.read({
+        sessionId,offset:position,maxBytes:Math.min(RDC_PROCESS_READ_CHUNK,streamHead-position),waitMs:0
+      });
+      if(page.offset!==position) throw new Error('native process output moved during compatibility snapshot');
+      const data=Buffer.from(page.data_base64??'','base64');
+      if(data.length<1) throw new Error('native process output snapshot made no forward progress');
+      chunks.push(data);
+      const next=page.next_offset;
+      if(!Number.isInteger(next)||next<=position||next>streamHead) throw new Error('native process output cursor invalid');
+      position=next;
+    }
+    return {
+      bytes:Buffer.concat(chunks),
+      earliest_offset:earliest,
+      stream_head:streamHead,
+      state:probe.state,
+      exit_code:probe.exit_code
+    };
+  }
+  async function waitForStreamAdvance(sessionId,baseline,timeoutMs){
+    let remaining=timeoutMs;
+    while(remaining>0){
+      const slice=Math.min(30000,remaining);
+      const observed=await processRuntime.read({sessionId,offset:baseline,maxBytes:1,waitMs:slice});
+      if((Number.isInteger(observed.stream_head)&&observed.stream_head>baseline)||observed.state!=='running') return observed;
+      remaining-=slice;
+    }
+    return null;
+  }
+  async function readProcessRange(sessionId,start,end){
+    if(!Number.isInteger(start)||!Number.isInteger(end)||start<0||end<start) throw new Error('native process range invalid');
+    if(end-start>RDC_PROCESS_SNAPSHOT_MAX) throw new Error(`RDC process response exceeds ${RDC_PROCESS_SNAPSHOT_MAX} byte compatibility bound`);
+    const chunks=[];
+    let position=start;
+    while(position<end){
+      const page=await processRuntime.read({sessionId,offset:position,maxBytes:Math.min(RDC_PROCESS_READ_CHUNK,end-position),waitMs:0});
+      if(page.offset!==position) throw new Error('native process response moved during compatibility read');
+      const data=Buffer.from(page.data_base64??'','base64');
+      if(data.length<1) throw new Error('native process response made no forward progress');
+      chunks.push(data);
+      const next=page.next_offset;
+      if(!Number.isInteger(next)||next<=position||next>end) throw new Error('native process response cursor invalid');
+      position=next;
+    }
+    return Buffer.concat(chunks);
+  }
+  function lineIndexAtByte(ranges,relativeByte){
+    let index=0;
+    while(index<ranges.length&&ranges[index].next<=relativeByte) index++;
+    return index;
+  }
+  function processOutputText({readFrom,readCount,totalLines,remaining,lines,state,exitCode,truncated}){
+    let header=readFrom===0
+      ?`[Reading ${readCount} lines (total: ${totalLines} lines)]`
+      :`[Reading ${readCount} lines from line ${readFrom} (total: ${totalLines} lines, ${remaining} remaining)]`;
+    if(truncated) header+='\n[WARNING: earliest retained process output was evicted; line numbers refer to retained output only]';
+    const body=lines.length?lines.join('\n'):'(No output in requested range)';
+    const terminal=state==='running'?'':`\nProcess ${state}${exitCode===null||exitCode===undefined?'':` with exit code ${exitCode}`}`;
+    return `${header}\n\n${body}${terminal}`;
+  }
 
   async function startProcess(args){
-    if(args.shell!==undefined && args.shell!==process.env.DEADBYTE_COMMANDER_COMPAT_SHELL) throw new Error('RDC shell is not silently ignored; configure DEADBYTE_COMMANDER_COMPAT_SHELL to the approved native shell');
-    const profileId=profileForCommand(),rootId=defaultProcessRoot();
-    const native=await processRuntime.start({profileId,rootId,cwd:'.',args:args.command.trim()===''?[]:args.command.trim().split(/\\s+/),timeoutMs:args.timeout_ms});
+    if(!processRuntime) throw new Error('process runtime is disabled');
+    const profileId=profileForCommand(args.shell??null),rootId=defaultProcessRoot();
+    assertRequestedShell(profileId,args.shell);
+    const profile=processRuntime?.policy?.profiles?.[profileId]??null;
+    const rawInput=profile?.allow_raw_input===true;
+    const native=await processRuntime.start({
+      profileId,rootId,cwd:'.',
+      args:rawInput?[]:(args.command.length===0?[]:[args.command]),
+      timeoutMs:args.timeout_ms
+    });
+    try{
+      if(rawInput&&args.command.length>0){
+        await processRuntime.write({sessionId:native.session_id,input:args.command,appendNewline:true});
+      }
+    }catch(error){
+      await processRuntime.terminate({sessionId:native.session_id}).catch(()=>{});
+      throw error;
+    }
     const compatPid=native.child_pid??0;
-    if(!Number.isInteger(compatPid)||compatPid<=0) throw new Error('native process did not expose a usable child PID');
+    if(!Number.isInteger(compatPid)||compatPid<=0) {
+      await processRuntime.terminate({sessionId:native.session_id}).catch(()=>{});
+      throw new Error('native process did not expose a usable child PID');
+    }
     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});
   }
   function sessionForPid(pid){
@@ -260,60 +619,193 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
   }
   async function readProcessOutput(args){
     const sessionId=sessionForPid(args.pid);
-    const native=await processRuntime.read({sessionId,offset:args.offset??0,maxBytes:262144,waitMs:args.timeout_ms??0});
-    const output=Buffer.from(native.data_base64,'base64').toString('utf8');
-    return text(output,false,{pid:args.pid,session_id:sessionId,offset:native.offset,next_offset:native.next_offset,state:native.state,exit_code:native.exit_code});
+    const state=processCompatState.get(args.pid)??{last_read_byte:0};
+    const requestedOffset=args.offset??0;
+    if(!Number.isInteger(requestedOffset)||requestedOffset<-(1<<30)||requestedOffset>(1<<30)) throw new Error('RDC process offset invalid');
+    const length=boundedLineLength(args.length);
+    const waitMs=boundedWait(args.timeout_ms,5000);
+    let snapshot=await processStreamSnapshot(sessionId);
+    let retainedRanges=splitLineRanges(snapshot.bytes);
+    if(requestedOffset===0){
+      let startByte=Math.max(state.last_read_byte,snapshot.earliest_offset);
+      if(startByte>=snapshot.stream_head&&snapshot.state==='running'&&waitMs>0){
+        await waitForStreamAdvance(sessionId,snapshot.stream_head,waitMs);
+        snapshot=await processStreamSnapshot(sessionId);
+        retainedRanges=splitLineRanges(snapshot.bytes);
+        startByte=Math.max(state.last_read_byte,snapshot.earliest_offset);
+      }
+      const wasTruncated=state.last_read_byte<snapshot.earliest_offset;
+      const relativeStart=Math.max(0,startByte-snapshot.earliest_offset);
+      const unread=snapshot.bytes.subarray(relativeStart);
+      const unreadRanges=splitLineRanges(unread);
+      const selected=unreadRanges.slice(0,length);
+      const lines=decodeLines(unread,selected);
+      const readFrom=lineIndexAtByte(retainedRanges,relativeStart);
+      const readCount=selected.length;
+      const remaining=Math.max(0,unreadRanges.length-readCount);
+      const consumed=selected.length?selected.at(-1).next:0;
+      state.last_read_byte=startByte+consumed;
+      processCompatState.set(args.pid,state);
+      return text(processOutputText({
+        readFrom,readCount,totalLines:retainedRanges.length,remaining,lines,
+        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
+      });
+    }
+    const totalLines=retainedRanges.length;
+    const readFrom=requestedOffset<0?Math.max(0,totalLines+requestedOffset):Math.min(requestedOffset,totalLines);
+    const selected=retainedRanges.slice(readFrom,readFrom+length);
+    const lines=decodeLines(snapshot.bytes,selected);
+    const readCount=selected.length,remaining=Math.max(0,totalLines-(readFrom+readCount));
+    return text(processOutputText({
+      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
+    });
   }
   async function interactProcess(args){
     const sessionId=sessionForPid(args.pid);
-    const native=await processRuntime.write({sessionId,input:args.input,appendNewline:true});
-    return text(`Input sent to process ${args.pid}`,false,{pid:args.pid,session_id:sessionId,...native});
+    const before=await processStreamSnapshot(sessionId);
+    const written=await processRuntime.write({sessionId,input:args.input,appendNewline:true});
+    const waitForPrompt=args.wait_for_prompt??true;
+    if(!waitForPrompt){
+      return text(`Input sent to process ${args.pid}. Use read_process_output to get the response.`,false,{
+        pid:args.pid,session_id:sessionId,wait_for_prompt:false,...written
+      });
+    }
+    const waitMs=boundedWait(args.timeout_ms,8000);
+    let observed=await processRuntime.read({sessionId,offset:before.stream_head,maxBytes:1,waitMs:0});
+    if((observed.stream_head??before.stream_head)<=before.stream_head&&observed.state==='running'&&waitMs>0){
+      observed=await waitForStreamAdvance(sessionId,before.stream_head,waitMs)??observed;
+    }
+    const streamHead=Number.isInteger(observed.stream_head)?observed.stream_head:before.stream_head;
+    const earliest=Number.isInteger(observed.earliest_offset)?observed.earliest_offset:observed.offset;
+    const start=Math.max(before.stream_head,earliest);
+    const responseBytes=streamHead>start?await readProcessRange(sessionId,start,streamHead):Buffer.alloc(0);
+    const response=responseBytes.toString('utf8');
+    const output=response.length?response:'(No output produced)';
+    return text(`Input executed in process ${args.pid}:\n\n${output}`,false,{
+      pid:args.pid,session_id:sessionId,wait_for_prompt:true,response_from_offset:start,
+      stream_head:streamHead,state:observed.state,exit_code:observed.exit_code,...written
+    });
   }
   async function terminateProcess(args){
     const sessionId=sessionForPid(args.pid);
     const native=await processRuntime.terminate({sessionId});
     pidMap.delete(args.pid);
+    processCompatState.delete(args.pid);
     return text(`Successfully terminated process ${args.pid}`,false,{pid:args.pid,session_id:sessionId,...native});
   }
   async function listSessions(){
     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});
   }
-  async function listProcesses(){ return listSessions(); }
-  async function killProcess(args){ return terminateProcess(args); }
+  async function listProcesses(){
+    if(!externalProcessRuntime) return listSessions();
+    const native=await externalProcessRuntime.list();
+    const lines=native.processes.map(p=>`PID: ${p.pid}, Command: ${p.name}, CPU: n/a, Memory: n/a`);
+    return text(lines.join('\n'),false,{...native});
+  }
+  async function killProcess(args){
+    if(pidMap.has(args.pid)) return terminateProcess(args);
+    if(!externalProcessRuntime) throw new Error(`unknown RDC pid ${args.pid}`);
+    const native=await externalProcessRuntime.terminate({pid:args.pid});
+    return text(`Successfully terminated process ${args.pid}`,false,native);
+  }
 
   async function writePdf(args){
-    if(!extendedRuntime) throw new Error('write_pdf compatibility requires the DEADBYTE document runtime');
-    if(Array.isArray(args.content)) throw new Error('write_pdf operation arrays are wire-accepted but semantic PDF page editing is not yet implemented; request rejected rather than approximated');
-    const pdf=extendedRuntime.writePdf({text:args.content,metadata:{...args.options??{}}});
+    if(!machineFsRuntime) throw new Error('write_pdf compatibility requires the machine filesystem runtime');
+    async function readPdfBytes(compatPath,label){
+      const resolved=resolveRdcPath(machineFsRuntime,compatPath);
+      const maxRead=Math.min(64*1024*1024,machineFsRuntime.policy.max_read_bytes??64*1024*1024);
+      const raw=await machineFsRuntime.read({rootId:resolved.rootId,relativePath:resolved.relativePath,offset:0,maxBytes:maxRead,hashFile:true});
+      if(raw.eof===false) throw new Error(`${label} exceeds bounded native PDF read limit`);
+      return {resolved,raw,bytes:Buffer.from(raw.data_base64,'base64')};
+    }
+    let pdf;
+    let ignoredPdfOptions=[];
+    if(Array.isArray(args.content)){
+      ignoredPdfOptions=args.content.flatMap((op,index)=>
+        op?.type==='insert'&&op.pdfOptions!==undefined&&Object.keys(op.pdfOptions??{}).length>0?[index]:[]
+      );
+      const base=await readPdfBytes(args.path,'base PDF');
+      pdf=await editDeadbytePdf(base.bytes,args.content,{
+        sourceResolver:async sourcePdfPath=>(await readPdfBytes(sourcePdfPath,'source PDF')).bytes
+      });
+    }else{
+      if(!extendedRuntime) throw new Error('write_pdf string mode requires the DEADBYTE document runtime');
+      pdf=extendedRuntime.writePdf({text:args.content,metadata:{...args.options??{}}});
+    }
     const targetPath=args.outputPath??args.path;
     const target=resolveRdcPath(machineFsRuntime,targetPath);
     let expected='absent';
     try{
-      const current=await machineFsRuntime.read({rootId:target.rootId,relativePath:target.relativePath,offset:0,maxBytes:128*1024*1024,hashFile:true});
-      expected=current.file_sha256??'absent';
+      const current=await machineFsRuntime.read({
+        rootId:target.rootId,relativePath:target.relativePath,offset:0,
+        maxBytes:Math.min(64*1024*1024,machineFsRuntime.policy.max_read_bytes??64*1024*1024),
+        hashFile:true
+      });
+      if(current.eof===false) throw new Error('target PDF exceeds bounded native read limit');
+      expected=current.file_sha256??sha256Bytes(Buffer.from(current.data_base64,'base64'));
     }catch(error){
       if(!/not found|ENOENT/i.test(String(error))) throw error;
     }
-    const result=await machineFsRuntime.write({rootId:target.rootId,relativePath:target.relativePath,content:pdf.bytes_base64,encoding:'base64',expectedSha256:expected});
-    return text(`Successfully wrote PDF to ${targetPath}${args.outputPath?`\\nOriginal file: ${args.path}`:''}`,false,{
-      path:args.path,outputPath:args.outputPath??null,status:'committed',mimeType:'application/pdf',bytes:pdf.bytes,bytesSha256:pdf.bytes_sha256,...result
+    const bytesBase64=pdf.bytes_base64??pdf.bytes?.toString('base64');
+    const bytesCount=pdf.bytes?.length??Buffer.from(bytesBase64,'base64').length;
+    const digest=pdf.bytes_sha256??sha256Bytes(Buffer.from(bytesBase64,'base64'));
+    const result=await machineFsRuntime.write({
+      rootId:target.rootId,relativePath:target.relativePath,
+      content:bytesBase64,encoding:'base64',expectedSha256:expected
+    });
+    return text(`Successfully wrote PDF to ${targetPath}${args.outputPath?`\nOriginal file: ${args.path}`:''}`,false,{
+      path:args.path,outputPath:args.outputPath??null,status:'committed',mimeType:'application/pdf',
+      bytes:bytesCount,bytesSha256:digest,pageCount:pdf.page_count??null,profile:pdf.profile??null,
+      ...(ignoredPdfOptions.length?{ignoredPdfOptions}:{}),...result
     });
   }
 
   async function startSearch(args){
     if(!searchRuntime) throw new Error('dedicated search runtime is disabled');
     const id=`search-${Date.now().toString(36)}-${Math.random().toString(36).slice(2,8)}`;
-    const state={id,created:Date.now(),args,isComplete:false,isError:false,results:[],error:null};
+    const exactFilename=args.searchType==='files'&&/\.[a-zA-Z0-9]+$/.test(args.pattern)&&!/[\*\?\[\]\{\}]/.test(args.pattern);
+    const timeoutMs=args.timeout_ms??(exactFilename?1500:null);
+    const state={id,created:Date.now(),args,isComplete:false,isError:false,results:[],error:null,timedOut:false,abortController:new AbortController()};
     searchSessions.set(id,state);
+    let timeoutHandle=null;
+    if(timeoutMs){
+      timeoutHandle=setTimeout(()=>{
+        if(state.isComplete) return;
+        state.timedOut=true;
+        state.abortController.abort();
+        state.isComplete=true;
+      },Math.max(0,timeoutMs));
+    }
     state.promise=(async()=>{
       try{
         const target=machineFsRuntime?resolveRdcPath(machineFsRuntime,args.path):{rootId:'core',relativePath:args.path};
-        const query={rootId:target.rootId,path:target.relativePath,pattern:args.pattern,target:args.searchType==='content'?'content':'path',mode:args.literalSearch?'literal':'regex',caseSensitive:!args.ignoreCase,maxResults:Math.min(Math.max(Math.trunc(args.maxResults??500),1),5000),maxFileBytes:262144,maxScanBytes:64*1024*1024,pageSize:500,cursor:null,filePattern:args.filePattern,includeHidden:args.includeHidden,contextLines:args.contextLines,earlyTermination:args.earlyTermination};
-        const r=await searchRuntime(query);
-        state.results=(r.matches??[]).map(x=>({file:x.path,line:x.line,match:x.preview,type:args.searchType==='content'?'content':'file'}));
-        state.isComplete=true;
-      }catch(error){state.isError=true;state.error=String(error?.message??error);state.isComplete=true;}
+        const query={rootId:target.rootId,path:target.relativePath,pattern:args.pattern,target:args.searchType==='content'?'content':'path',mode:args.literalSearch?'literal':'regex',caseSensitive:!args.ignoreCase,maxResults:Math.min(Math.max(Math.trunc(args.maxResults??500),1),5000),maxFileBytes:262144,maxScanBytes:64*1024*1024,pageSize:500,cursor:null,filePattern:args.filePattern,includeHidden:args.includeHidden,contextLines:args.contextLines,earlyTermination:args.searchType==='files'?args.earlyTermination!==false:false};
+        const seenCursors=new Set();
+        if(args.searchType!=='content'){
+          query.mode='literal';
+          query.pathGlob=true;
+        }
+        do{
+          const r=await searchRuntime({...query,signal:state.abortController.signal});
+          if(state.cancelled||state.timedOut) break;
+          const remaining=query.maxResults-state.results.length;
+          state.results.push(...(r.matches??[]).slice(0,remaining).map(x=>({file:x.path,line:x.line,match:x.preview,type:args.searchType==='content'?'content':'file'})));
+          query.cursor=r.next_cursor??null;
+          if(query.cursor!==null){
+            if(seenCursors.has(query.cursor)) throw new Error('search runtime repeated a paging cursor');
+            seenCursors.add(query.cursor);
+          }
+        }while(query.cursor!==null&&state.results.length<query.maxResults);
+        if(!state.cancelled&&!state.timedOut) state.isComplete=true;
+      }catch(error){if(!state.cancelled&&!state.timedOut){state.isError=true;state.error=String(error?.message??error);}state.isComplete=true;}
+      finally{if(timeoutHandle!==null) clearTimeout(timeoutHandle);}
     })();
     return {sessionId:id,isComplete:false,isError:false,results:[],totalResults:0};
   }
@@ -328,8 +820,10 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
   }
   async function stopSearch(args){
     const s=searchSessions.get(args.sessionId);
-    if(!s) return false;
+    if(!s||s.isComplete) return false;
     s.cancelled=true;
+    s.abortController.abort();
+    s.isComplete=true;
     return true;
   }
   async function listSearches(){