deadbyte-mcp 0.15.16 → 0.15.18

package/src/commander-core-bridge.mjs

@@ -1,30 +1,26 @@
-import * as z from 'zod/v4';
-const anyArgs=z.record(z.string(),z.unknown());
-const sessions=new Map(); let sessionCounter=0;
-function denied(tool,reason='required native runtime is disabled'){return {status:'denied',tool,error:reason};}
-function register(server,name,schema,handler){server.registerTool(name,{description:'Native Commander-compatible adapter; execution remains inside DEADBYTE policy and evidence boundaries.',inputSchema:schema},handler);}
-function fsOr(runtime,name,fn){return runtime?fn(runtime):denied(name);}
-function processOr(runtime,name,fn){return runtime?fn(runtime):denied(name);}
-function mapResult(item,type){return type==='files'?{file:item.path,type:'file'}:{file:item.path,line:item.line,match:item.preview,type:'content'};}
-function queryArgs(a){return {rootId:a.root_id??'core',path:a.path,pattern:a.pattern,target:a.searchType==='content'?'content':'path',mode:a.literalSearch===true?'literal':'regex',caseSensitive:a.ignoreCase===false,maxResults:Number.isInteger(a.maxResults)?Math.min(Math.max(a.maxResults,1),1000):200,maxFileBytes:262144,maxScanBytes:64*1024*1024,pageSize:500,cursor:null};}
-export function registerCommanderCoreBridge(server,{machineFsRuntime=null,processRuntime=null,searchRuntime=null,remoteDevicePlane=null}={}){
-  register(server,'read_file',z.strictObject({root_id:z.string().min(1).max(64),path:z.string().min(1).max(2048),offset:z.number().int().min(0).default(0),max_bytes:z.number().int().min(1).max(4194304).default(65536),hash_file:z.boolean().default(false),timeout_ms:z.number().int().min(100).max(180000).default(30000)}),a=>fsOr(machineFsRuntime,'read_file',r=>r.read({rootId:a.root_id,relativePath:a.path,offset:a.offset,maxBytes:a.max_bytes,hashFile:a.hash_file,timeoutMs:a.timeout_ms})));
-  register(server,'read_multiple_files',z.strictObject({root_id:z.string().min(1).max(64),paths:z.array(z.string().min(1).max(2048)).min(1).max(64),max_bytes:z.number().int().min(1).max(4194304).default(65536),timeout_ms:z.number().int().min(100).max(180000).default(30000)}),a=>fsOr(machineFsRuntime,'read_multiple_files',r=>r.readMany({rootId:a.root_id,relativePaths:a.paths,maxBytes:a.max_bytes,timeoutMs:a.timeout_ms})));
-  register(server,'write_file',z.strictObject({root_id:z.string().min(1).max(64),path:z.string().min(1).max(2048),content:z.string().max(12582912),encoding:z.enum(['utf8','base64']).default('utf8'),expected_sha256:z.string().regex(/^(?:absent|[0-9a-f]{64})$/)}),a=>fsOr(machineFsRuntime,'write_file',r=>r.write({rootId:a.root_id,relativePath:a.path,content:a.content,encoding:a.encoding,expectedSha256:a.expected_sha256})));
-  register(server,'create_directory',z.strictObject({root_id:z.string().min(1).max(64),path:z.string().min(1).max(2048)}),a=>fsOr(machineFsRuntime,'create_directory',r=>r.mkdir({rootId:a.root_id,relativePath:a.path})));
-  register(server,'list_directory',z.strictObject({root_id:z.string().min(1).max(64),path:z.string().min(1).max(2048).default('.'),cursor:z.string().max(4096).nullable().default(null),limit:z.number().int().min(1).max(1000).default(100),hash_files:z.boolean().default(false)}),a=>fsOr(machineFsRuntime,'list_directory',r=>r.list({rootId:a.root_id,relativePath:a.path,cursor:a.cursor,limit:a.limit,hashFiles:a.hash_files})));
-  register(server,'move_file',z.strictObject({root_id:z.string().min(1).max(64),source_path:z.string().min(1).max(2048),destination_path:z.string().min(1).max(2048),expected_source_identity:z.string().regex(/^[0-9a-f]{64}$/)}),a=>fsOr(machineFsRuntime,'move_file',r=>r.move({rootId:a.root_id,sourcePath:a.source_path,destinationPath:a.destination_path,expectedSourceIdentity:a.expected_source_identity})));
-  register(server,'get_file_info',z.strictObject({root_id:z.string().min(1).max(64),path:z.string().min(1).max(2048),hash:z.boolean().default(false)}),a=>fsOr(machineFsRuntime,'get_file_info',r=>r.stat({rootId:a.root_id,relativePath:a.path,hash:a.hash})));
-  register(server,'edit_block',z.strictObject({root_id:z.string().min(1).max(64),path:z.string().min(1).max(2048),expected_sha256:z.string().regex(/^[0-9a-f]{64}$/),old_string:z.string().min(1).max(262144),new_string:z.string().max(524288),expected_replacements:z.number().int().min(1).max(64).default(1)}),a=>fsOr(machineFsRuntime,'edit_block',r=>r.editExact({rootId:a.root_id,relativePath:a.path,expectedSha256:a.expected_sha256,oldString:a.old_string,newString:a.new_string,expectedReplacements:a.expected_replacements})));
-  register(server,'start_process',anyArgs,a=>processOr(processRuntime,'start_process',r=>r.start(a)));
-  register(server,'read_process_output',anyArgs,a=>processOr(processRuntime,'read_process_output',r=>r.read(a)));
-  register(server,'interact_with_process',anyArgs,a=>processOr(processRuntime,'interact_with_process',r=>r.action(a)));
-  register(server,'force_terminate',anyArgs,a=>processOr(processRuntime,'force_terminate',r=>r.terminate(a)));
-  register(server,'list_sessions',z.strictObject({}),()=>processOr(processRuntime,'list_sessions',r=>r.list()));
-  register(server,'list_processes',z.strictObject({}),()=>processOr(processRuntime,'list_processes',r=>r.list()));
-  register(server,'kill_process',anyArgs,a=>processOr(processRuntime,'kill_process',r=>r.cancel(a)));
-  register(server,'start_search',z.strictObject({path:z.string().min(1),pattern:z.string().min(1).max(256),searchType:z.enum(['files','content']).default('files'),filePattern:z.string().optional(),ignoreCase:z.boolean().default(true),maxResults:z.number().int().min(1).max(1000).optional(),includeHidden:z.boolean().default(false),contextLines:z.number().int().min(0).max(50).default(5),timeout_ms:z.number().int().min(100).max(120000).optional(),earlyTermination:z.boolean().optional(),literalSearch:z.boolean().default(false),origin:z.enum(['ui','llm']).optional()}),async a=>{if(!searchRuntime)return denied('start_search','dedicated search runtime is disabled');const id='search-'+(++sessionCounter)+'-'+Date.now().toString(36);const s={id,searchType:a.searchType,pattern:a.pattern,startTime:Date.now(),isComplete:false,isError:false,results:[],totalMatches:0,wasIncomplete:false};sessions.set(id,s);s.promise=(async()=>{try{const r=await searchRuntime(queryArgs(a));s.results=r.matches.map(x=>mapResult(x,a.searchType)).slice(0,a.maxResults??200);s.totalMatches=r.matches.length;s.wasIncomplete=r.truncated===true;s.isComplete=true;}catch(e){s.isError=true;s.error=String(e?.message??e).slice(0,512);s.isComplete=true;}})();return {sessionId:id,isComplete:false,isError:false,results:[],totalResults:0,runtime:0};});
-  register(server,'get_more_search_results',z.strictObject({sessionId:z.string().min(1).max(128),offset:z.number().int().default(0),length:z.number().int().min(1).max(1000).default(100)}),async({sessionId,offset,length})=>{const s=sessions.get(sessionId);if(!s)return {status:'error',error:'search session not found'};if(!s.isComplete)return {results:[],returnedCount:0,totalResults:s.results.length,totalMatches:s.totalMatches,isComplete:false,isError:false,hasMoreResults:true,runtime:Date.now()-s.startTime};const start=offset<0?Math.max(0,s.results.length+offset):offset;const end=offset<0?s.results.length:Math.min(s.results.length,start+length);const results=s.results.slice(start,end);return {results,returnedCount:results.length,totalResults:s.results.length,totalMatches:s.totalMatches,isComplete:true,isError:s.isError,error:s.error,hasMoreResults:end<s.results.length,runtime:Date.now()-s.startTime,wasIncomplete:s.wasIncomplete};});
-  register(server,'stop_search',z.strictObject({sessionId:z.string().min(1).max(128)}),async({sessionId})=>{const s=sessions.get(sessionId);if(!s)return false;s.cancelled=true;return true;});
-  register(server,'list_searches',z.strictObject({}),async()=>[...sessions.values()].map(s=>({id:s.id,searchType:s.searchType,pattern:s.pattern,isComplete:s.isComplete,isError:s.isError,runtime:Date.now()-s.startTime,totalResults:s.results.length})));
-}
+import { createCommanderWireAdapter } from './commander-wire-adapter-r47.mjs';
+
+export function registerCommanderCoreBridge(
+  server,
+  { machineFsRuntime=null, processRuntime=null, searchRuntime=null, extendedRuntime=null, includeMarkdownEditor=false }={}
+){
+  const adapter=createCommanderWireAdapter({machineFsRuntime,processRuntime,searchRuntime,extendedRuntime});
+  const names=Object.keys(adapter.handlers);
+  for(const name of names){
+    server.registerTool(name,{
+      description:'RDC wire-compatible adapter. Requests are normalized into DEADBYTE native policy/evidence planes; no Commander runtime dependency is imported.',
+      inputSchema:adapter.schemas[name]
+    },async args=>{
+      try{return await adapter.handlers[name](args);}
+      catch(error){
+        const message=error instanceof Error?error.message:String(error);
+        return {
+          content:[{type:'text',text:`Error: ${name}: ${message}`}],
+          isError:true,
+          structuredContent:{status:'error',tool:name,error:message}
+        };
+      }
+    });
+  }
+  if(includeMarkdownEditor) server.registerTool('markdown_editor',{description:'RDC markdown editor compatibility alias backed by the native edit_block transaction.',inputSchema:adapter.schemas.edit_block},async args=>adapter.handlers.edit_block(args));
+}

package/src/commander-extended-bridge-r47.mjs

@@ -0,0 +1,17 @@
+import * as z from 'zod/v4';
+
+export function registerCommanderExtendedBridge(server,{extendedRuntime,observability=null,skillPlane=null}={}){
+  if(!extendedRuntime) throw new Error('Commander extended runtime is required');
+  const reg=(name,schema,handler)=>server.registerTool(name,{description:'RDC-compatible DEADBYTE native extended surface.',inputSchema:schema},async args=>{
+    try{return await handler(args??{});}
+    catch(error){const message=error instanceof Error?error.message:String(error);return {content:[{type:'text',text:`Error: ${name}: ${message}`}],isError:true,structuredContent:{status:'error',tool:name,error:message}};}
+  });
+  reg('get_config',z.strictObject({key:z.string().optional()}),a=>extendedRuntime.getConfig(a));
+  reg('set_config_value',z.strictObject({key:z.string(),value:z.union([z.string(),z.number(),z.boolean(),z.array(z.string()),z.null()]),expected_sha256:z.string().regex(/^[0-9a-f]{64}$/)}),a=>extendedRuntime.setConfigValue(a));
+  reg('give_feedback_to_desktop_commander',z.strictObject({message:z.string(),category:z.string().optional()}),a=>extendedRuntime.feedback(a));
+  reg('get_prompts',z.strictObject({}),()=>extendedRuntime.getPrompts());
+  reg('resources',z.strictObject({}),()=>extendedRuntime.getResources());
+  reg('file_preview',z.strictObject({root_id:z.string(),path:z.string(),offset:z.number().int().min(0).optional(),max_bytes:z.number().int().min(1).max(65536).optional(),mime_type:z.string().optional()}),a=>extendedRuntime.filePreview({rootId:a.root_id,path:a.path,offset:a.offset,maxBytes:a.max_bytes,mimeType:a.mime_type}));
+  reg('get_recent_tool_calls',z.strictObject({after_sequence:z.number().int().min(0).optional(),limit:z.number().int().min(1).max(1000).optional()}),a=>observability?observability.recentToolCalls({afterSequence:a.after_sequence??0,limit:a.limit??100}):({status:'unavailable',error:'observability disabled'}));
+  reg('get_usage_stats',z.strictObject({}),()=>observability?observability.usageStats():({status:'unavailable',error:'observability disabled'}));
+}

package/src/commander-extended-runtime.mjs

@@ -37,7 +37,8 @@ export function createCommanderExtendedRuntime({stateRoot,history=null,prompts=[
   }
   async function setConfigValue({key,value,expected_sha256}){
     if(!keyOk(key))throw new Error('config key invalid');
-    if(!['string','number','boolean'].includes(typeof value)&&value!==null)throw new Error('config value must be scalar');
+    const validValue=value===null||['string','number','boolean'].includes(typeof value)||(Array.isArray(value)&&value.every(item=>typeof item==='string'));
+    if(!validValue)throw new Error('config value must be string, number, boolean, string array, or null');
     if(Buffer.byteLength(typeof value==='string'?value:canonicalJson(value))>MAX_VALUE)throw new Error('config value exceeds byte limit');
     const cfg=await loadConfig(),beforeSha=sha256(cfg);
     if(expected_sha256!==beforeSha)throw new Error('config precondition mismatch');

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

@@ -0,0 +1,341 @@
+import * as z from 'zod/v4';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+
+const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
+
+const anyRecord = z.record(z.string(), z.unknown());
+const empty = z.strictObject({});
+const origin = z.enum(['ui','llm']).optional();
+
+const RDC = Object.freeze({
+  read_file: z.strictObject({
+    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({
+    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()}),
+  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()}),
+  list_sessions:empty,
+  list_processes:empty,
+  kill_process:z.strictObject({pid:z.number()}),
+  start_search:z.strictObject({
+    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()}),
+  list_searches:empty,
+  write_pdf:z.strictObject({
+    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())})
+    ]))]),
+    outputPath:z.string().optional(),
+    options:anyRecord.optional(), origin
+  })
+});
+
+function text(text,isError=false,structuredContent){
+  const out={content:[{type:'text',text:String(text)}]};
+  if(isError) out.isError=true;
+  if(structuredContent!==undefined) out.structuredContent=structuredContent;
+  return out;
+}
+function fail(name,error){
+  const message=error instanceof Error?error.message:String(error);
+  return text(`Error: ${name}: ${message}`,true,{status:'error',tool:name,error:message});
+}
+
+function rootEntries(runtime){
+  const roots=runtime?.policy?.roots??{};
+  return Object.entries(roots).map(([id,r])=>[id,path.resolve(r.real_path)]);
+}
+function resolveRdcPath(runtime,input){
+  if(typeof input!=='string'||!input) throw new Error('path must be a non-empty string');
+  const absolute=path.resolve(input);
+  for(const [rootId,root] of rootEntries(runtime)){
+    const relative=path.relative(root,absolute);
+    if(relative===''||(!relative.startsWith('..'+path.sep)&&relative!=='..'&&!path.isAbsolute(relative))){
+      return {rootId,relativePath:relative||'.'};
+    }
+  }
+  throw new Error('path is outside all configured DEADBYTE roots');
+}
+function rootFor(runtime,rootId){
+  const roots=runtime?.policy?.roots??{};
+  const root=roots[rootId];
+  if(!root) throw new Error(`DEADBYTE root not found: ${rootId}`);
+  return path.resolve(root.real_path);
+}
+function absoluteFor(runtime,rootId,relativePath){
+  const root=rootFor(runtime,rootId);
+  return path.resolve(root,relativePath);
+}
+function linesFrom(bytes){
+  return Buffer.from(bytes,'base64').toString('utf8').replaceAll('\\r\\n','\\n').replaceAll('\\r','\\n').split('\\n');
+}
+function rdcFileResult(pathname,data){
+  return {
+    path:pathname,content:data.content,mimeType:data.mime_type,
+    isImage:data.isImage??false,isPdf:data.isPdf??false,
+    ...(data.fileSha256!==undefined?{fileSha256:data.fileSha256}:{}),
+    ...(data.lineOffset!==undefined?{lineOffset:data.lineOffset}:{}),
+    ...(data.lineCount!==undefined?{lineCount:data.lineCount}:{})
+  };
+}
+function richFormat(pathname){
+  const ext=path.extname(pathname).toLowerCase();
+  return {
+    '.png':'image/png','.jpg':'image/jpeg','.jpeg':'image/jpeg','.gif':'image/gif','.webp':'image/webp',
+    '.pdf':'application/pdf','.docx':'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xlsx':'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet','.xls':'application/vnd.ms-excel','.xlsm':'application/vnd.ms-excel.sheet.macroEnabled.12'
+  }[ext]??null;
+}
+
+export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime=null,searchRuntime=null,extendedRuntime=null}={}){
+  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');
+    }
+    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');
+    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 imageMime={'.png':'image/png','.jpg':'image/jpeg','.jpeg':'image/jpeg','.gif':'image/gif','.webp':'image/webp'}[ext];
+    if(imageMime) {
+      const content=raw.data_base64;
+      return text(content,false,{path:args.path,content,mimeType:imageMime,isImage:true,isPdf:false,fileSha256});
+    }
+    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`);
+    }
+    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});
+  }
+
+  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}));
+        }
+      }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});
+  }
+
+  async function writeFile(args){
+    const target=resolveRdcPath(machineFsRuntime,args.path);
+    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;
+    }catch(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});
+    return text(`Successfully wrote ${args.path}`,false,{path:args.path,mode:args.mode,status:'committed',...result});
+  }
+
+  async function createDirectory(args){
+    const target=resolveRdcPath(machineFsRuntime,args.path);
+    const result=await machineFsRuntime.mkdir({rootId:target.rootId,relativePath:target.relativePath});
+    return text(`Successfully created directory ${args.path}`,false,{path:args.path,status:'committed',...result});
+  }
+
+  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});
+  }
+
+  async function moveFile(args){
+    const source=resolveRdcPath(machineFsRuntime,args.source);
+    const destination=resolveRdcPath(machineFsRuntime,args.destination);
+    const info=await machineFsRuntime.stat({rootId:source.rootId,relativePath:source.relativePath,hash:true});
+    const result=await machineFsRuntime.move({rootId:source.rootId,sourcePath:source.relativePath,destinationPath:destination.relativePath,expectedSourceIdentity:info.identity_sha256});
+    return text(`Successfully moved ${args.source} to ${args.destination}`,false,{source:args.source,destination:args.destination,status:'committed',...result});
+  }
+
+  async function getFileInfo(args){
+    const target=resolveRdcPath(machineFsRuntime,args.path);
+    const result=await machineFsRuntime.stat({rootId:target.rootId,relativePath:target.relativePath,hash:true});
+    return text(JSON.stringify(result,null,2),false,result);
+  }
+
+  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 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');
+    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});
+    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 defaultProcessRoot(){
+    const id=process.env.DEADBYTE_COMMANDER_COMPAT_ROOT;
+    if(id) return id;
+    const ids=processRuntime?.policy?.roots?Object.keys(processRuntime.policy.roots):[];
+    if(ids.length===1) return ids[0];
+    throw new Error('RDC start_process requires DEADBYTE_COMMANDER_COMPAT_ROOT when multiple process roots exist');
+  }
+  const pidMap=new Map();
+
+  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});
+    const compatPid=native.child_pid??0;
+    if(!Number.isInteger(compatPid)||compatPid<=0) throw new Error('native process did not expose a usable child PID');
+    pidMap.set(compatPid,native.session_id);
+    return text(`Process started with PID ${compatPid} (DEADBYTE session ${native.session_id})\\n`,false,{pid:compatPid,session_id:native.session_id});
+  }
+  function sessionForPid(pid){
+    const sessionId=pidMap.get(pid);
+    if(!sessionId) throw new Error(`unknown RDC pid ${pid}`);
+    return sessionId;
+  }
+  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});
+  }
+  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});
+  }
+  async function terminateProcess(args){
+    const sessionId=sessionForPid(args.pid);
+    const native=await processRuntime.terminate({sessionId});
+    pidMap.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 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??{}}});
+    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';
+    }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
+    });
+  }
+
+  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};
+    searchSessions.set(id,state);
+    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;}
+    })();
+    return {sessionId:id,isComplete:false,isError:false,results:[],totalResults:0};
+  }
+  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};
+  }
+  async function stopSearch(args){
+    const s=searchSessions.get(args.sessionId);
+    if(!s) return false;
+    s.cancelled=true;
+    return true;
+  }
+  async function listSearches(){
+    return [...searchSessions.values()].map(s=>({id:s.id,searchType:s.args.searchType,pattern:s.args.pattern,isComplete:s.isComplete,isError:s.isError,runtime:Date.now()-s.created,totalResults:s.results.length}));
+  }
+
+  const handlers={read_file:readFile,read_multiple_files:readMultipleFiles,write_file:writeFile,create_directory:createDirectory,list_directory:listDirectory,move_file:moveFile,get_file_info:getFileInfo,edit_block:editBlock,write_pdf:writePdf,start_process:startProcess,read_process_output:readProcessOutput,interact_with_process:interactProcess,force_terminate:terminateProcess,list_sessions:listSessions,list_processes:listProcesses,kill_process:killProcess,start_search:startSearch,get_more_search_results:getMoreSearchResults,stop_search:stopSearch,list_searches:listSearches};
+  return Object.freeze({schemas:RDC,handlers});
+}

package/src/machine-fs.mjs

@@ -5,7 +5,7 @@ import { lstat, mkdir as fsMkdir, open, readFile, readdir, realpath, rename, rm,
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { canonicalJson } from './canonical-json.mjs';
-import { assertCodingArmed, recheckCodingAuthority } from './coding-plane.mjs';
+import { assertCodingArmed, assertCodingReadAllowed, recheckCodingAuthority, recheckCodingReadAuthority } from './coding-plane.mjs';
 import { isInside, validatePortableRelativePath } from './path-policy.mjs';
 import { decodeUtf8Strict } from './text-policy.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
@@ -343,7 +343,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
   if (!signingKeyPath || !verifyKeyPath) throw new Error('machine fs runtime requires trust key paths');
 
   async function statPath({ rootId, relativePath = '.', hash = false }) {
-    const grant = await assertCodingArmed(policy, rootId);
+    const grant = await assertCodingReadAllowed(policy, rootId);
     const found = await resolveExisting(policy, grant, rootId, relativePath, 'read', true);
     const info = await lstat(found.resolved);
     const kind = kindOf(info);
@@ -367,7 +367,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
   }
   async function listPage({ rootId, relativePath = '.', cursor = null, limit = 100, hashFiles = false }) {
     if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIST_LIMIT) throw new Error(`machine fs list limit must be in [1, ${MAX_LIST_LIMIT}]`);
-    const grant = await assertCodingArmed(policy, rootId);
+    const grant = await assertCodingReadAllowed(policy, rootId);
     const found = await resolveExisting(policy, grant, rootId, relativePath, 'read', true);
     const info = found.targetInfo;
     if (!info?.isDirectory()) throw new Error('machine fs list path must be a directory');
@@ -398,18 +398,18 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
     if (!Number.isInteger(offset) || offset < -policy.max_read_bytes || offset > policy.max_read_bytes) throw new Error(`machine fs read offset must be in [-${policy.max_read_bytes}, ${policy.max_read_bytes}]`);
     if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > policy.max_read_bytes) throw new Error(`machine fs max_bytes must be in [1, ${policy.max_read_bytes}]`);
     if (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 180000) throw new Error('machine fs read timeout_ms must be in [100, 180000]');
-    const grant = await assertCodingArmed(policy, rootId);
+    const grant = await assertCodingReadAllowed(policy, rootId);
     const found = await resolveExisting(policy, grant, rootId, relativePath, 'read', false);
     const info = await lstat(found.resolved);
     if (!info.isFile()) throw new Error('machine fs read target must be a regular file');
     const effectiveOffset = offset < 0 ? Math.max(0, info.size + offset) : offset;
     if (effectiveOffset > info.size) throw new Error('machine fs read offset exceeds file size');
     const length = Math.min(maxBytes, info.size - effectiveOffset);
-    await recheckCodingAuthority(policy, grant, rootId);
+    await recheckCodingReadAuthority(policy, grant, rootId);
     const worker = await boundedReadWorker({ file: found.resolved, offset: effectiveOffset, length, hashFile, timeoutMs, workerPath: readWorkerPath });
     const buffer = Buffer.from(worker.data_base64, 'base64');
     if (buffer.length !== worker.bytes_read || buffer.length > length) throw new Error('machine fs read worker byte count mismatch');
-    await recheckCodingAuthority(policy, grant, rootId);
+    await recheckCodingReadAuthority(policy, grant, rootId);
     return {
       status: 'ok', root_id: rootId, path: found.relative,
       offset: effectiveOffset, requested_offset: offset, next_offset: effectiveOffset + buffer.length, file_size: info.size,

package/src/mcp-server.mjs

@@ -51,6 +51,9 @@ import { registerAutonomousTools } from './autonomous-mcp-tools.mjs';
 import { createToolAudit, installToolAudit } from './tool-audit.mjs';
 import { createAuditContextProvider } from './audit-context.mjs';
 import { registerOperatorSurface } from './operator-surface.mjs';
+import { createOperationHistory } from './operation-history.mjs';
+import { createCommanderObservability } from './commander-observability.mjs';
+import { registerCommanderExtendedBridge } from './commander-extended-bridge-r47.mjs';
 import { createCommanderExtendedRuntime } from './commander-extended-runtime.mjs';
 import { registerCommanderCoreBridge } from './commander-core-bridge.mjs';
 import { registerCommanderRemoteBridge } from './commander-remote-bridge-r47.mjs';
@@ -242,17 +245,13 @@ const toolAudit = auditRuntimeMode === '1' ? await createToolAudit({
 const skillRoot=path.join(runtimeStateRoot,'skills');
 await mkdir(skillRoot,{recursive:true});
 const skillRuntime=await createSkillPlane({root:skillRoot,verifyKeyPath});
-
+const commanderExtendedRuntime=createCommanderExtendedRuntime({stateRoot:runtimeStateRoot});
+const commanderHistory=createOperationHistory({maxEvents:1024,maxBytes:1024*1024});
+const commanderObservability=createCommanderObservability({history:commanderHistory});
 const remoteRelayEndpoint=process.env.DEADBYTE_REMOTE_RELAY_ENDPOINT||process.env.DEADBYTE_REMOTE_ENDPOINT||'';
-const remoteRelayCapabilities=new Set(String(process.env.DEADBYTE_REMOTE_CAPABILITIES||'').split(',').map(value=>value.trim()).filter(Boolean));
-const remoteRelay=remoteRelayEndpoint ? await createCommanderRemoteRelayR47({endpoint:remoteRelayEndpoint}) : null;
-const remoteDevicePlane=remoteRelay
-  ? await createRemoteDevicePlaneR44({
-      stateDir:path.join(runtimeStateRoot,'remote-device-r44'),
-      relay:remoteRelay,
-      authorizeCapability:async({capabilityId})=>remoteRelayCapabilities.has(capabilityId)
-    })
-  : null;
+const remoteCapabilities=new Set(String(process.env.DEADBYTE_REMOTE_CAPABILITIES??'').split(',').map(x=>x.trim()).filter(Boolean));
+const remoteRelay=remoteRelayEndpoint?await createCommanderRemoteRelayR47({endpoint:remoteRelayEndpoint}):null;
+const remoteDevicePlane=remoteRelay?await createRemoteDevicePlaneR44({stateDir:path.join(runtimeStateRoot,'remote-device-r44'),relay:remoteRelay,authorizeCapability:async capability=>remoteCapabilities.has(capability)}):null;
 
 installStdioConsoleGuard();
 if (process.env.DEADBYTE_STDIO_CONSOLE_GUARD_PROBE === '1') console.log('DEADBYTE_STDIO_CONSOLE_GUARD_PROBE');
@@ -292,83 +291,9 @@ serveStdio(() => {
     return server.registerTool(name,...args);
   }};
   registerOperatorSurface(server,{packageRoot,surfaceProfile,compactToolLimit:COMPACT_SURFACE_TOOL_LIMIT});
-  const commanderExtendedRuntime=createCommanderExtendedRuntime({
-    stateRoot:runtimeStateRoot,
-    history:null,
-    prompts:[
-      {name:'deadbyte.review',title:'Review'},
-      {name:'deadbyte.patch',title:'Patch'},
-      {name:'deadbyte.diagnose',title:'Diagnose'},
-      {name:'deadbyte.run-tests',title:'Run tests'}
-    ],
-    resources:[
-      {uri:'deadbyte://context',mime_type:'text/markdown'},
-      {uri:'deadbyte://architecture',mime_type:'text/markdown'},
-      {uri:'deadbyte://surface-profile',mime_type:'application/json'}
-    ]
-  });
   if (toolAudit) installToolAudit(server,toolAudit);
 
   if (surfaceProfile === 'full') {
-  toolServer.registerTool('get_config',{
-    description:'Read bounded DEADBYTE Commander-compatible configuration.',
-    inputSchema:z.strictObject({key:z.string().min(1).max(128).nullable().default(null)})
-  },async args=>commanderExtendedRuntime.getConfig(args));
-
-  toolServer.registerTool('set_config_value',{
-    description:'Atomically update one bounded configuration scalar with an exact hash precondition.',
-    inputSchema:z.strictObject({key:z.string().min(1).max(128),value:z.union([z.string().max(16384),z.number(),z.boolean(),z.null()]),expected_sha256:z.string().regex(/^[0-9a-f]{64}$/)})
-  },async args=>commanderExtendedRuntime.setConfigValue(args));
-
-  toolServer.registerTool('give_feedback_to_desktop_commander',{
-    description:'Persist bounded operator feedback locally; no external network transmission.',
-    inputSchema:z.strictObject({message:z.string().min(1).max(4096),category:z.string().min(1).max(64).default('general')})
-  },async args=>commanderExtendedRuntime.feedback(args));
-
-  toolServer.registerTool('get_prompts',{
-    description:'Return the bounded native prompt catalog.',
-    inputSchema:z.strictObject({})
-  },async()=>commanderExtendedRuntime.getPrompts());
-
-  toolServer.registerTool('resources',{
-    description:'Return the bounded native resource catalog.',
-    inputSchema:z.strictObject({})
-  },async()=>commanderExtendedRuntime.getResources());
-
-  toolServer.registerTool('file_preview',{
-    description:'Return a bounded preview slice from an explicitly rooted file.',
-    inputSchema:z.strictObject({root_id:z.string().min(1).max(512),path:z.string().min(1).max(512),offset:z.number().int().min(0).default(0),max_bytes:z.number().int().min(1).max(65536).default(65536),mime_type:z.string().max(128).default('text/plain')})
-  },async({root_id,path:relativePath,offset,max_bytes,mime_type})=>commanderExtendedRuntime.filePreview({rootId:root_id,path:relativePath,offset,maxBytes:max_bytes,mimeType:mime_type}));
-
-  toolServer.registerTool('write_pdf',{
-    description:'Generate a bounded self-contained PDF document from text.',
-    inputSchema:z.strictObject({text:z.string().max(65536),metadata:z.record(z.string(),z.unknown()).default({})})
-  },async args=>commanderExtendedRuntime.writePdf(args));
-
-  toolServer.registerTool('markdown_editor',{
-    description:'Hash-preconditioned bounded Markdown exact edit using the native machine filesystem transaction.',
-    inputSchema:z.strictObject({root_id:z.string().min(1).max(64),path:z.string().min(1).max(512),expected_sha256:z.string().regex(/^[0-9a-f]{64}$/),old_string:z.string().min(1).max(262144),new_string:z.string().max(524288),expected_replacements:z.number().int().min(1).max(64).default(1)})
-  },async args=>{
-    if(!machineFsRuntime) return textResult(z.any(),{status:'denied',error:'machine filesystem runtime is disabled'},true);
-    return machineFsRuntime.editExact({rootId:args.root_id,relativePath:args.path,expectedSha256:args.expected_sha256,oldString:args.old_string,newString:args.new_string,expectedReplacements:args.expected_replacements});
-  });
-
-  toolServer.registerTool('get_usage_stats',{
-    description:'Return bounded audit/runtime usage status.',
-    inputSchema:z.strictObject({})
-  },async()=>{
-    if(!toolAudit) return {status:'unavailable',reason:'audit runtime is disabled'};
-    return {status:'ok',audit:await toolAudit.status()};
-  });
-
-  toolServer.registerTool('get_recent_tool_calls',{
-    description:'Return a bounded, cursorable recent signed audit event window.',
-    inputSchema:z.strictObject({limit:z.number().int().min(1).max(256).default(50),after_seq:z.number().int().min(0).default(0)})
-  },async({limit,after_seq})=>{
-    if(!toolAudit) return {status:'unavailable',reason:'audit runtime is disabled'};
-    return {status:'ok',audit:await toolAudit.recent({limit,after_seq})};
-  });
-
   toolServer.registerTool(
     'workspace_open',
     {
@@ -549,8 +474,7 @@ serveStdio(() => {
 
   registerCompactGatewayTools(toolServer,{
     profile:surfaceProfile,ledger:R36_CAPABILITY_LEDGER,codingRuntime,semanticRuntime,machineFsRuntime,
-    processRuntime,observationRuntime,machineRuntime,desktopRuntime,skillRuntime,autonomousRuntime,hostPolicy,
-    catalogProvider:()=>[...registeredToolNames]
+    processRuntime,observationRuntime,machineRuntime,desktopRuntime,catalogProvider:()=>[...registeredToolNames]
   });
 
   if (hostPolicy) {
@@ -680,8 +604,10 @@ serveStdio(() => {
   }
 
   if (surfaceProfile === 'full') {
-    registerCommanderCoreBridge(toolServer,{machineFsRuntime,processRuntime,searchRuntime:codingRuntime?.search??null});
+    registerCommanderCoreBridge(toolServer,{machineFsRuntime,processRuntime,searchRuntime:codingRuntime?.search??null,extendedRuntime:commanderExtendedRuntime,includeMarkdownEditor:true});
+    registerCommanderExtendedBridge(toolServer,{extendedRuntime:commanderExtendedRuntime,observability:commanderObservability,skillPlane:skillRuntime});
     registerCommanderRemoteBridge(toolServer,{remoteDevicePlane});
   }
+
   return server;
 }, { legacy: 'reject' });