deadbyte-mcp 0.9.0 → 0.10.0

package/src/compact-gateway-mcp-tools.mjs

@@ -0,0 +1,128 @@
+import * as z from 'zod/v4';
+import { compactGatewayOutputSchema, compactGatewayResult } from './compact-gateway-output-contracts.mjs';
+
+const id=z.string().regex(/^[A-Za-z0-9._-]{1,64}$/);
+const rel=z.string().min(1).max(2048);
+const rel512=z.string().min(1).max(512);
+const hex64=z.string().regex(/^[0-9a-f]{64}$/);
+const cursor=z.string().max(4096).nullable().default(null);
+const nonneg=z.number().int().nonnegative();
+const symbolName=z.string().regex(/^[A-Za-z_$][A-Za-z0-9_$]{0,127}$/);
+
+export const codingInspectInputSchema=z.discriminatedUnion('op',[
+  z.strictObject({op:z.literal('stat'),root_id:id,path:rel512.default('.'),hash:z.boolean().default(false)}),
+  z.strictObject({op:z.literal('search'),root_id:id,path:rel512.default('.'),pattern:z.string().min(1).max(256),target:z.enum(['content','path']).default('content'),mode:z.enum(['literal','regex']).default('literal'),case_sensitive:z.boolean().default(false),max_results:z.number().int().min(1).max(1000).default(200),max_file_bytes:z.number().int().min(1).max(4*1024*1024).default(262144),max_scan_bytes:z.number().int().min(1).max(64*1024*1024).default(4*1024*1024),page_size:z.number().int().min(1).max(500).default(100),cursor}),
+  z.strictObject({op:z.literal('files_read'),root_id:id,files:z.array(z.strictObject({path:rel512,encoding:z.enum(['utf8','base64']).default('utf8')})).min(1).max(32),max_total_bytes:z.number().int().min(1).max(2097152).default(1048576)}),
+  z.strictObject({op:z.literal('symbol_outline'),root_id:id,path:rel512,max_symbols:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({op:z.literal('symbol_definition'),root_id:id,path:rel512,line:nonneg,column:nonneg,max_results:z.number().int().min(1).max(200).default(50)}),
+  z.strictObject({op:z.literal('symbol_references'),root_id:id,path:rel512,line:nonneg,column:nonneg,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({op:z.literal('symbol_diagnostics'),root_id:id,path:rel512,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({op:z.literal('symbol_implementations'),root_id:id,path:rel512,line:nonneg,column:nonneg,max_results:z.number().int().min(1).max(500).default(200)}),
+  z.strictObject({op:z.literal('symbol_rename_preview'),root_id:id,path:rel512,line:nonneg,column:nonneg,new_name:symbolName})
+]);
+
+export const machineFsGatewayInputSchema=z.discriminatedUnion('op',[
+  z.strictObject({op:z.literal('stat'),root_id:id,path:rel.default('.'),hash:z.boolean().default(false)}),
+  z.strictObject({op:z.literal('list'),root_id:id,path:rel.default('.'),cursor,limit:z.number().int().min(1).max(1000).default(100),hash_files:z.boolean().default(false)}),
+  z.strictObject({op:z.literal('read'),root_id:id,path:rel,offset:nonneg.default(0),max_bytes:z.number().int().min(1).max(4*1024*1024).default(65536),hash_file:z.boolean().default(false)}),
+  z.strictObject({op:z.literal('write'),root_id:id,path:rel,content:z.string().max(12*1024*1024),encoding:z.enum(['utf8','base64']).default('utf8'),expected_sha256:z.string().regex(/^(?:absent|[0-9a-f]{64})$/)}),
+  z.strictObject({op:z.literal('edit_exact'),root_id:id,path:rel,expected_sha256:hex64,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)}),
+  z.strictObject({op:z.literal('mkdir'),root_id:id,path:rel}),
+  z.strictObject({op:z.literal('move'),root_id:id,source_path:rel,destination_path:rel,expected_source_identity:hex64}),
+  z.strictObject({op:z.literal('delete'),root_id:id,path:rel,expected_source_identity:hex64})
+]);
+
+export const processSessionGatewayInputSchema=z.discriminatedUnion('op',[
+  z.strictObject({op:z.literal('start'),profile_id:id,root_id:id,cwd:rel.default('.'),args:z.array(z.string().max(8192)).max(64).default([])}),
+  z.strictObject({op:z.literal('read'),session_id:hex64,offset:nonneg.default(0),max_bytes:z.number().int().min(1).max(262144).default(65536)}),
+  z.strictObject({op:z.literal('status'),session_id:hex64}),
+  z.strictObject({op:z.literal('list')}),
+  z.strictObject({op:z.literal('action'),session_id:hex64,action_id:id}),
+  z.strictObject({op:z.literal('terminate'),session_id:hex64})
+]);
+
+export const machineObserveInputSchema=z.discriminatedUnion('op',[
+  z.strictObject({op:z.literal('machine_list')}),
+  z.strictObject({op:z.literal('machine_status')}),
+  z.strictObject({op:z.literal('machine_ping'),nonce:z.string().min(1).max(256)}),
+  z.strictObject({op:z.literal('search_start'),root_id:id,path:rel512.default('.'),pattern:z.string().min(1).max(256),case_sensitive:z.boolean().default(false),max_results:z.number().int().min(1).max(1000).default(200),max_files:z.number().int().min(1).max(10000).default(2000),max_bytes:z.number().int().min(1).max(64*1024*1024).default(4*1024*1024),max_file_bytes:z.number().int().min(1).max(4*1024*1024).default(262144)}),
+  z.strictObject({op:z.literal('search_page'),search_id:hex64,limit:z.number().int().min(1).max(500).default(100),cursor:z.string().max(512).nullable().default(null)}),
+  z.strictObject({op:z.literal('search_status'),search_id:hex64}),
+  z.strictObject({op:z.literal('search_cancel'),search_id:hex64}),
+  z.strictObject({op:z.literal('process_list'),limit:z.number().int().min(1).max(256).default(100),include_external:z.boolean().default(false),cursor:z.string().max(512).nullable().default(null)}),
+  z.strictObject({op:z.literal('system_status')})
+]);
+
+const capabilityManifestInputSchema=z.strictObject({});
+
+function unavailable(op,name){return compactGatewayResult({status:'unavailable',op,error:`${name} runtime unavailable`},true);}
+async function invoke(op,runtime,name,call){
+  if(!runtime) return unavailable(op,name);
+  try{return compactGatewayResult({status:'ok',op,result:await call(runtime)},false);}
+  catch(error){return compactGatewayResult({status:'denied',op,error:String(error)},true);}
+}
+
+async function codingInspect(args,codingRuntime,semanticRuntime){
+  switch(args.op){
+    case 'stat': return invoke(args.op,codingRuntime,'coding',r=>r.stat({rootId:args.root_id,relativePath:args.path,hash:args.hash}));
+    case 'search': return invoke(args.op,codingRuntime,'coding',r=>r.search({rootId:args.root_id,path:args.path,pattern:args.pattern,target:args.target,mode:args.mode,caseSensitive:args.case_sensitive,maxResults:args.max_results,maxFileBytes:args.max_file_bytes,maxScanBytes:args.max_scan_bytes,pageSize:args.page_size,cursor:args.cursor}));
+    case 'files_read': return invoke(args.op,codingRuntime,'coding',r=>r.filesRead({rootId:args.root_id,files:args.files,maxTotalBytes:args.max_total_bytes}));
+    case 'symbol_outline': return invoke(args.op,semanticRuntime,'semantic',r=>r.outline({rootId:args.root_id,relativePath:args.path,maxSymbols:args.max_symbols}));
+    case 'symbol_definition': return invoke(args.op,semanticRuntime,'semantic',r=>r.definition({rootId:args.root_id,relativePath:args.path,line:args.line,column:args.column,maxResults:args.max_results}));
+    case 'symbol_references': return invoke(args.op,semanticRuntime,'semantic',r=>r.references({rootId:args.root_id,relativePath:args.path,line:args.line,column:args.column,maxResults:args.max_results}));
+    case 'symbol_diagnostics': return invoke(args.op,semanticRuntime,'semantic',r=>r.diagnostics({rootId:args.root_id,relativePath:args.path,maxResults:args.max_results}));
+    case 'symbol_implementations': return invoke(args.op,semanticRuntime,'semantic',r=>{if(typeof r.implementations!=='function') throw new Error('semantic implementations unavailable');return r.implementations({rootId:args.root_id,relativePath:args.path,line:args.line,column:args.column,maxResults:args.max_results});});
+    case 'symbol_rename_preview': return invoke(args.op,semanticRuntime,'semantic',r=>{if(typeof r.renamePreview!=='function') throw new Error('semantic rename preview unavailable');return r.renamePreview({rootId:args.root_id,relativePath:args.path,line:args.line,column:args.column,newName:args.new_name});});
+  }
+}
+
+async function machineFs(args,runtime){
+  const map={
+    stat:r=>r.stat({rootId:args.root_id,relativePath:args.path,hash:args.hash}),
+    list:r=>r.list({rootId:args.root_id,relativePath:args.path,cursor:args.cursor,limit:args.limit,hashFiles:args.hash_files}),
+    read:r=>r.read({rootId:args.root_id,relativePath:args.path,offset:args.offset,maxBytes:args.max_bytes,hashFile:args.hash_file}),
+    write:r=>r.write({rootId:args.root_id,relativePath:args.path,content:args.content,encoding:args.encoding,expectedSha256:args.expected_sha256}),
+    edit_exact:r=>r.editExact({rootId:args.root_id,relativePath:args.path,expectedSha256:args.expected_sha256,oldString:args.old_string,newString:args.new_string,expectedReplacements:args.expected_replacements}),
+    mkdir:r=>r.mkdir({rootId:args.root_id,relativePath:args.path}),
+    move:r=>r.move({rootId:args.root_id,sourcePath:args.source_path,destinationPath:args.destination_path,expectedSourceIdentity:args.expected_source_identity}),
+    delete:r=>r.delete({rootId:args.root_id,relativePath:args.path,expectedSourceIdentity:args.expected_source_identity})
+  };
+  return invoke(args.op,runtime,'machine_fs',map[args.op]);
+}
+
+async function processSession(args,runtime){
+  const map={
+    start:r=>r.start({profileId:args.profile_id,rootId:args.root_id,cwd:args.cwd,args:args.args}),
+    read:r=>r.read({sessionId:args.session_id,offset:args.offset,maxBytes:args.max_bytes}),
+    status:r=>r.status({sessionId:args.session_id}),
+    list:r=>r.list(),
+    action:r=>r.action({sessionId:args.session_id,actionId:args.action_id}),
+    terminate:r=>r.terminate({sessionId:args.session_id})
+  };
+  return invoke(args.op,runtime,'process',map[args.op]);
+}
+
+async function machineObserve(args,machineRuntime,observationRuntime){
+  if(args.op==='machine_list') return invoke(args.op,machineRuntime,'machine',r=>r.list());
+  if(args.op==='machine_status') return invoke(args.op,machineRuntime,'machine',r=>r.status());
+  if(args.op==='machine_ping') return invoke(args.op,machineRuntime,'machine',r=>r.ping({nonce:args.nonce}));
+  const map={
+    search_start:r=>r.searchStart({rootId:args.root_id,relativePath:args.path,pattern:args.pattern,caseSensitive:args.case_sensitive,maxResults:args.max_results,maxFiles:args.max_files,maxBytes:args.max_bytes,maxFileBytes:args.max_file_bytes}),
+    search_page:r=>r.searchPage({searchId:args.search_id,limit:args.limit,cursor:args.cursor}),
+    search_status:r=>r.searchStatus({searchId:args.search_id}),
+    search_cancel:r=>r.searchCancel({searchId:args.search_id}),
+    process_list:r=>r.processList({limit:args.limit,includeExternal:args.include_external,cursor:args.cursor}),
+    system_status:r=>r.systemStatus()
+  };
+  return invoke(args.op,observationRuntime,'observation',map[args.op]);
+}
+
+export function registerCompactGatewayTools(server,{profile,ledger,codingRuntime,semanticRuntime,machineFsRuntime,processRuntime,observationRuntime,machineRuntime}){
+  if(!server) throw new Error('compact gateway registration requires server');
+  if(profile!=='compact') return;
+  server.registerTool('capability_manifest',{description:'Read the canonical R36 capability ledger and active compact profile.',inputSchema:capabilityManifestInputSchema,outputSchema:compactGatewayOutputSchema},async()=>compactGatewayResult({status:'ok',op:'manifest',result:{schema:'deadbyte.capability-manifest.v1',profile,ledger_sha256:ledger?.ledger_sha256??null,capabilities:ledger?.entries??[]}},false));
+  server.registerTool('coding_inspect',{description:'Typed compact coding inspection and semantic navigation gateway. No arbitrary tool dispatch.',inputSchema:codingInspectInputSchema,outputSchema:compactGatewayOutputSchema},args=>codingInspect(args,codingRuntime,semanticRuntime));
+  server.registerTool('machine_fs',{description:'Typed compact machine filesystem gateway preserving root policy and mutation preconditions.',inputSchema:machineFsGatewayInputSchema,outputSchema:compactGatewayOutputSchema},args=>machineFs(args,machineFsRuntime));
+  server.registerTool('process_session',{description:'Typed compact DEADBYTE-owned process session gateway. No raw stdin or PID authority.',inputSchema:processSessionGatewayInputSchema,outputSchema:compactGatewayOutputSchema},args=>processSession(args,processRuntime));
+  server.registerTool('machine_observe',{description:'Typed compact machine identity and read-only observation gateway. Revoke is intentionally excluded.',inputSchema:machineObserveInputSchema,outputSchema:compactGatewayOutputSchema},args=>machineObserve(args,machineRuntime,observationRuntime));
+}

package/src/compact-gateway-output-contracts.mjs

@@ -0,0 +1,16 @@
+import * as z from 'zod/v4';
+import { structuredToolResult } from './output-contracts.mjs';
+
+export const compactGatewayOutputSchema=z.strictObject({
+  status:z.enum(['ok','denied','failed','unavailable']),
+  op:z.string().min(1).max(64),
+  result:z.json().optional(),
+  error:z.string().max(4096).optional()
+}).superRefine((value,ctx)=>{
+  if(value.status==='ok'&&value.result===undefined) ctx.addIssue({code:'custom',path:['result'],message:'result is required for status=ok'});
+  if(value.status!=='ok'&&value.error===undefined) ctx.addIssue({code:'custom',path:['error'],message:'error is required for non-ok status'});
+});
+
+export function compactGatewayResult(value,isError=false){
+  return structuredToolResult(compactGatewayOutputSchema,value,isError);
+}

package/src/deadbyte-cli.mjs

@@ -9,18 +9,19 @@ import { fileURLToPath } from 'node:url';
 import { defaultPublicKeyPath } from './trust.mjs';
 import { verifyAuditChain } from './audit-verify.mjs';
 import { openRemoteResultJournal, parseRemoteResultCursor } from './remote-result-journal.mjs';
+import { createLiveActivityTracker, formatCompactAuditEvent, formatRemoteLifecycle } from './remote-live-log.mjs';
 
 const REMOTE_COMMANDS=new Set([
   'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
   'armprocess','disarmprocess','processstatus','armhost','disarmhost','hoststatus','hosttest',
   'armcoding','disarmcoding','codingstatus','codingtest','armautonomous','disarmautonomous','autonomousstatus','autonomoustest'
 ]);
-const SESSION_START=['start','armprocess','armcoding','armautonomous','armhost'];
+const SESSION_START=['start','armprocess','armcoding','armautonomous'];
 const SESSION_STATUS=[
   ['processstatus',/^Process plane\s*:\s*ARMED\b/m],
   ['codingstatus',/^Coding plane\s*:\s*ARMED\b/m],
   ['autonomousstatus',/^Autonomous\s*:\s*ARMED\b/m],
-  ['hoststatus',/^Host plane\s*:\s*ARMED\b/m]
+  ['hoststatus',/^Host plane\s*:\s*DISARMED\b/m]
 ];
 const SESSION_CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park'];
 const SUPERVISOR_COMMANDS=Object.freeze({
@@ -77,16 +78,12 @@ async function listLogFiles(root){
   }
   return files;
 }
-function formatLogLine(file,line,{verbose=false}={}){
+function formatLogLine(file,line,{verbose=false,activityTracker=null}={}){
   if(!line) return null;
   if(/^segment-\d{8}\.jsonl$/.test(path.basename(file))){
     try{
       const event=JSON.parse(line);
-      if(!verbose){
-        if(event.event_type!=='tool.result') return null;
-        const tool=typeof event.tool==='string'&&event.tool?event.tool:'tool';
-        return `${event.outcome?.is_error===true?'[ERR]':'[OK]'} ${tool}`;
-      }
+      if(!verbose) return activityTracker?activityTracker.observe(event):formatCompactAuditEvent(event);
       const seq=Number.isInteger(event.seq)?`#${event.seq}`:'#?';
       const request=typeof event.request_id==='string'?` ${event.request_id.slice(0,8)}`:'';
       const tool=typeof event.tool==='string'?` ${event.tool}`:'';
@@ -147,25 +144,29 @@ async function readAppend(file,offset){
   try{await handle.read(buffer,0,length,start);}finally{await handle.close();}
   return {offset:info.size,text:buffer.toString('utf8')};
 }
-async function tailRemoteLogs(root,signal,{verbose=false,journal=null}={}){
+async function snapshotRemoteLogOffsets(root){
   const offsets=new Map();
   for(const file of await listLogFiles(root)){
     try{offsets.set(file,(await stat(file)).size);}catch{}
   }
+  return offsets;
+}
+async function tailRemoteLogs(root,signal,{verbose=false,journal=null,offsets=null,activityTracker=null}={}){
   process.stdout.write(verbose
     ?'📜 [LOG] Live logs active. Press Ctrl+C to disconnect and revoke authority.\n'
-    :'[LOG] Live tool results. Ctrl+C disconnects and revokes authority.\n');
+    :'[LOG] Live activity. Ctrl+C disconnects and revokes authority.\n');
+  const activeOffsets=offsets??await snapshotRemoteLogOffsets(root);
   while(!signal.aborted){
     for(const file of await listLogFiles(root)){
-      const prior=offsets.has(file)?offsets.get(file):0;
+      const prior=activeOffsets.has(file)?activeOffsets.get(file):0;
       const next=await readAppend(file,prior);
-      offsets.set(file,next.offset);
+      activeOffsets.set(file,next.offset);
       for(const line of next.text.split(/\r?\n/)){
         const terminal=auditTerminalResult(file,line);
         let recorded=null;
         if(terminal&&journal) recorded=await journal.recordTerminal(terminal);
         if(recorded?.duplicate&&!verbose) continue;
-        const formatted=formatLogLine(file,line,{verbose});
+        const formatted=formatLogLine(file,line,{verbose,activityTracker});
         if(!formatted) continue;
         if(!verbose&&recorded) process.stdout.write(`${formatted} [cursor ${recorded.cursor}]\n`);
         else process.stdout.write(`${formatted}\n`);
@@ -266,39 +267,61 @@ async function runRemoteSession({verbose=false,resumeCursor=null}={}){
   const resultJournal=await openRemoteResultJournal({
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
+  const activityTracker=createLiveActivityTracker();
   const aborter=new AbortController();
   const abort=()=>aborter.abort();
   const watchStdin=!process.stdin.isTTY;
   process.once('SIGINT',abort);process.once('SIGTERM',abort);
   if(watchStdin){process.stdin.once('end',abort);process.stdin.once('close',abort);process.stdin.resume();}
   let ready=false;
+  let logTask=null;
   try{
-    if(verbose){
-      process.stdout.write('DEADBYTE MCP DEVICE SESSION\n');
-      process.stdout.write('[INFO] Starting local + remote runtime...\n');
-      for(const command of SESSION_START) invokeController(ctx,command);
-      process.stdout.write('🛡️ [AUTHORITY] Verifying runtime planes...\n');
-    }else{
-      process.stdout.write('DEADBYTE MCP\n');
-      const started=[];
-      for(const command of SESSION_START) started.push(invokeController(ctx,command,{capture:true,echoCaptured:false}));
+    if(verbose) process.stdout.write('DEADBYTE MCP DEVICE SESSION\n');
+    else process.stdout.write('DEADBYTE MCP\n');
+    process.stdout.write(`${formatRemoteLifecycle('device_start')}\n`);
+    process.stdout.write(`${formatRemoteLifecycle(resumeCursor!==null?'session_restored':'session_new')}\n`);
+    const logOffsets=await snapshotRemoteLogOffsets(ctx.root);
+    logTask=tailRemoteLogs(ctx.root,aborter.signal,{verbose,journal:resultJournal,offsets:logOffsets,activityTracker});
+    if(verbose) process.stdout.write('[INFO] Starting local + remote runtime...\n');
+    else process.stdout.write('[BOOT] Starting local + remote runtime...\n');
+    const started=[];
+    for(const command of SESSION_START){
+      if(!verbose){
+        if(command==='start') process.stdout.write('[BOOT] Starting bridge/runtime...\n');
+        else process.stdout.write(`🔐 [AUTH] Arming ${command.slice(3)}...\n`);
+      }
+      const controllerResult=invokeController(ctx,command,verbose?{}:{capture:true,echoCaptured:false});
+      started.push(controllerResult);
+      if(command==='start'){
+        process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);
+        process.stdout.write(`${formatRemoteLifecycle('cloud_connected')}\n`);
+      }
+    }
+    if(!verbose){
       const startText=started[0]?.stdout||'';
       const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
       process.stdout.write('[OK] ONLINE\n');
+      process.stdout.write(`${formatRemoteLifecycle('ready')}\n`);
       if(url) process.stdout.write(`URL: ${url}\n`);
-    }
+      process.stdout.write('🔐 [AUTH] Verifying process, coding, autonomous; host must stay DISARMED...\n');
+    }else process.stdout.write('🛡️ [AUTHORITY] Verifying runtime planes; host must stay DISARMED...\n');
     for(const [command,pattern] of SESSION_STATUS){
       const result=invokeController(ctx,command,{capture:true,echoCaptured:verbose});
-      if(!pattern.test(result.stdout)) throw new Error(`remote session authority verification failed: ${command} did not report ARMED`);
+      if(!pattern.test(result.stdout)) throw new Error(`remote session authority verification failed: ${command} state mismatch`);
     }
     ready=true;
-    if(verbose) process.stdout.write('[DEVICE] DEADBYTE MCP online; all authority planes ARMED.\n');
-    else process.stdout.write('[OK] Authority ARMED: process, coding, autonomous, host\n');
-    await tailRemoteLogs(ctx.root,aborter.signal,{verbose,journal:resultJournal});
+    if(verbose) process.stdout.write('[DEVICE] DEADBYTE MCP online; process/coding/autonomous ARMED; host DISARMED.\n');
+    else process.stdout.write('🔐 [AUTH] ARMED: process, coding, autonomous | host DISARMED\n');
+    await logTask;
   }finally{
+    const wasAborted=aborter.signal.aborted;
+    aborter.abort();
+    if(logTask) await logTask.catch(()=>{});
+    if(!verbose){for(const line of activityTracker.reconcileInterrupted('session_end')) process.stdout.write(`${line}\n`);}
     process.removeListener('SIGINT',abort);process.removeListener('SIGTERM',abort);
     if(watchStdin){process.stdin.removeListener('end',abort);process.stdin.removeListener('close',abort);process.stdin.pause();}
-    if(ready||!aborter.signal.aborted) process.stdout.write(verbose?'[INFO] Closing remote device session and revoking authority...\n':'[INFO] Disconnecting; revoking authority...\n');
+    process.stdout.write(`${formatRemoteLifecycle('cleanup')}\n`);
+    if(ready||!wasAborted) process.stdout.write(verbose?'[INFO] Closing remote device session and revoking authority...\n':'[INFO] Disconnecting; revoking authority...\n');
     await cleanupRemoteSession(ctx,{verbose});
     await releaseRemoteSession(ctx,marker);
   }

package/src/machine-fs-smoke-client.mjs

@@ -60,7 +60,7 @@ const baseTools = ['contained_transform','evidence_verify','file_read','proof_ex
 const codingTools = [
   'coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_files_read',
   'coding_receipt_verify','coding_search','coding_session_status','coding_stat',
-  'coding_symbol_definition','coding_symbol_outline','coding_symbol_references','coding_symbol_replace',
+  'coding_symbol_definition','coding_symbol_diagnostics','coding_symbol_implementations','coding_symbol_outline','coding_symbol_references','coding_symbol_rename_preview','coding_symbol_replace',
   'coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run',
   'coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree'
 ];

package/src/machine-fs.mjs

@@ -168,9 +168,10 @@ function decodeCursor(cursor) {
 
 function encodeCursor(name) { return Buffer.from(name, 'utf8').toString('base64url'); }
 
-async function signReceipt(policy, signingKeyPath, grant, operation, requestSha256, body) {
+async function signReceipt(policy, signingKeyPath, grant, operation, requestSha256, body, requestedReceiptId = null) {
   await fsMkdir(path.join(policy.evidence_dir, 'machine-fs'), { recursive: true });
-  const receiptId = randomBytes(12).toString('hex');
+  const receiptId = requestedReceiptId ?? randomBytes(12).toString('hex');
+  if (!RECEIPT_ID_RE.test(receiptId)) throw new Error('machine fs receipt id must be 24 lowercase hex characters');
   const core = {
     schema: MACHINE_FS_RECEIPT_SCHEMA, receipt_id: receiptId,
     policy_sha256: policy.policy_sha256, grant_instance_nonce: grant.instance_nonce,
@@ -311,7 +312,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath }
     };
   }
 
-  async function writePath({ rootId, relativePath, content, encoding = 'utf8', expectedSha256 }) {
+  async function writePath({ rootId, relativePath, content, encoding = 'utf8', expectedSha256, receiptId = null }) {
     const grant = await assertCodingArmed(policy, rootId);
     const target = await resolveTarget(policy, grant, rootId, relativePath, 'write');
     const bytes = decodeContent(content, encoding);
@@ -325,7 +326,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath }
     const signed = await signReceipt(policy, signingKeyPath, grant, 'machine_fs_write', request, {
       root_id: rootId, path: target.relative, started_at_utc: started, completed_at_utc: nowUtc(),
       before_sha256: before.sha256, after_sha256: after.sha256, bytes: after.bytes
-    });
+    }, receiptId);
     return {
       status: 'committed', root_id: rootId, path: target.relative,
       previous_sha256: before.sha256, sha256: after.sha256, bytes: after.bytes,
@@ -368,7 +369,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath }
       receipt_id: signed.receipt.receipt_id, receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request
     };
   }
-  async function mkdirPath({ rootId, relativePath }) {
+  async function mkdirPath({ rootId, relativePath, receiptId = null }) {
     const grant = await assertCodingArmed(policy, rootId);
     const target = await resolveTarget(policy, grant, rootId, relativePath, 'write');
     try { await lstat(target.lexical); throw new Error('machine fs mkdir precondition mismatch: expected absent'); }
@@ -382,7 +383,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath }
       const signed = await signReceipt(policy, signingKeyPath, grant, 'machine_fs_mkdir', request, {
         root_id: rootId, path: target.relative, started_at_utc: started, completed_at_utc: nowUtc(),
         before_identity_sha256: null, after_identity_sha256: identity.identity_sha256
-      });
+      }, receiptId);
       return {
         status: 'committed', root_id: rootId, path: target.relative, identity_sha256: identity.identity_sha256,
         receipt_id: signed.receipt.receipt_id, receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request
@@ -392,7 +393,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath }
       throw error;
     }
   }
-  async function movePath({ rootId, sourcePath, destinationPath, expectedSourceIdentity }) {
+  async function movePath({ rootId, sourcePath, destinationPath, expectedSourceIdentity, receiptId = null }) {
     if (!SHA256_RE.test(expectedSourceIdentity ?? '')) throw new Error('machine fs expected_source_identity must be lowercase SHA-256');
     const grant = await assertCodingArmed(policy, rootId);
     const source = await resolveExisting(policy, grant, rootId, sourcePath, 'write', false);
@@ -415,7 +416,7 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath }
       const signed = await signReceipt(policy, signingKeyPath, grant, 'machine_fs_move', request, {
         root_id: rootId, source_path: source.relative, destination_path: destination.relative,
         started_at_utc: started, completed_at_utc: nowUtc(), source_identity_sha256: expectedSourceIdentity
-      });
+      }, receiptId);
       return {
         status: 'committed', root_id: rootId, source_path: source.relative, destination_path: destination.relative,
         identity_sha256: expectedSourceIdentity, receipt_id: signed.receipt.receipt_id,
@@ -460,6 +461,46 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath }
     }
   }
 
+  async function statePath({ rootId, relativePath }) {
+    try {
+      const value = await statPath({ rootId, relativePath, hash: true });
+      return { exists: true, root_id: rootId, path: value.path, kind: value.kind, bytes: value.bytes,
+        sha256: value.sha256, identity_sha256: value.identity_sha256 };
+    } catch (error) {
+      if (error?.code === 'ENOENT') return { exists: false, root_id: rootId, path: relativePath, kind: null, bytes: 0, sha256: null, identity_sha256: null };
+      throw error;
+    }
+  }
+
+  async function removeEmptyDir({ rootId, relativePath, expectedSourceIdentity, receiptId = null }) {
+    if (!SHA256_RE.test(expectedSourceIdentity ?? '')) throw new Error('machine fs expected_source_identity must be lowercase SHA-256');
+    const grant = await assertCodingArmed(policy, rootId);
+    const source = await resolveExisting(policy, grant, rootId, relativePath, 'write', false);
+    const before = await objectIdentity(source.resolved);
+    if (before.kind !== 'directory' || before.entries.length !== 0) throw new Error('machine fs rmdir requires an empty directory');
+    if (before.identity_sha256 !== expectedSourceIdentity) throw new Error(`machine fs source identity mismatch: expected ${expectedSourceIdentity}, found ${before.identity_sha256}`);
+    const request = requestSha('machine_fs_rmdir_empty', { root_id: rootId, path: source.relative, expected_source_identity: expectedSourceIdentity });
+    const started = nowUtc();
+    const race = await objectIdentity(source.resolved);
+    if (race.kind !== 'directory' || race.entries.length !== 0 || race.identity_sha256 !== expectedSourceIdentity) {
+      throw new Error('machine fs rmdir precondition changed before commit');
+    }
+    await rmdir(source.lexical);
+    try {
+      try { await lstat(source.lexical); throw new Error('machine fs rmdir post-commit path still exists'); }
+      catch (error) { if (error?.code !== 'ENOENT') throw error; }
+      const signed = await signReceipt(policy, signingKeyPath, grant, 'machine_fs_rmdir_empty', request, {
+        root_id: rootId, path: source.relative, started_at_utc: started, completed_at_utc: nowUtc(),
+        before_identity_sha256: expectedSourceIdentity, after_identity_sha256: null
+      }, receiptId);
+      return { status: 'committed', root_id: rootId, path: source.relative, identity_sha256: expectedSourceIdentity,
+        receipt_id: signed.receipt.receipt_id, receipt_sha256: signed.receipt.receipt_sha256, request_sha256: request };
+    } catch (error) {
+      await fsMkdir(source.lexical, { recursive: false }).catch(() => {});
+      throw error;
+    }
+  }
+
   return Object.freeze({
     policy,
     stat: statPath,
@@ -470,6 +511,8 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath }
     move: movePath,
     mkdir: mkdirPath,
     delete: deletePath,
+    state: statePath,
+    removeEmptyDir,
     verifyReceipt: receiptId => verifyMachineFsReceiptFile({ policy, verifyKeyPath, receiptId })
   });
 }

package/src/mcp-server.mjs

@@ -39,6 +39,8 @@ 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 { capabilityProfileFromEnv, COMPACT_SURFACE_TOOL_LIMIT, R36_CAPABILITY_LEDGER } from './capability-ledger.mjs';
+import { registerCompactGatewayTools } from './compact-gateway-mcp-tools.mjs';
 import {
   containedTransformOutputSchema,
   evidenceVerifyOutputSchema,
@@ -58,6 +60,7 @@ const verifyKeyPath = process.env.DEADBYTE_VERIFY_KEY ?? defaultPublicKeyPath();
 const auditRuntimeMode = process.env.DEADBYTE_AUDIT_RUNTIME ?? '0';
 if (!['0','1'].includes(auditRuntimeMode)) throw new Error('DEADBYTE_AUDIT_RUNTIME must be 0 or 1');
 const runtimeStateRoot = path.resolve(process.env.DEADBYTE_STATE_ROOT || path.join(os.homedir(),'.deadbyte-mcp'));
+const surfaceProfile = capabilityProfileFromEnv(process.env);
 const localPrivilegedPolicyPath = path.join(packageRoot, 'controller', 'deadbyte-host-policy.json');
 let privilegedPolicyPath = process.env.DEADBYTE_PRIVILEGED_POLICY ?? '';
 if (!privilegedPolicyPath) {
@@ -106,7 +109,7 @@ const semanticLspBinding = semanticConfigBindingFromEnv(process.env);
 const semanticLsp = codingRuntime && semanticLspBinding
   ? await loadSemanticLspBackends({ ...semanticLspBinding, codingRuntime })
   : { backends: [], required_ids: [] };
-const semanticRuntime = codingRuntime ? createSemanticCodeRuntime({ codingRuntime, backends: semanticLsp.backends }) : null;
+let semanticRuntime = null;
 const machineFsRuntimeMode = process.env.DEADBYTE_MACHINE_FS_RUNTIME ?? '0';
 if (!['0','1'].includes(machineFsRuntimeMode)) throw new Error('DEADBYTE_MACHINE_FS_RUNTIME must be 0 or 1');
 if (machineFsRuntimeMode === '1' && !codingPolicy) throw new Error('DEADBYTE_MACHINE_FS_RUNTIME=1 requires DEADBYTE_CODING_RUNTIME=1');
@@ -137,9 +140,10 @@ if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) {
 }
 if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME=1 requires an autonomous policy');
 const autonomousPolicy = autonomousRuntimeMode === '1' ? await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy) : null;
-const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,signingKeyPath,verifyKeyPath }) : null;
+const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath }) : null;
+semanticRuntime = codingRuntime ? createSemanticCodeRuntime({ codingRuntime, backends: semanticLsp.backends, nativeDiffRuntime }) : null;
 const autonomousRuntime = autonomousPolicy ? createAutonomousRuntime({ policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,
-  machineFsRuntime,observationRuntime,processRuntime,signingKeyPath,verifyKeyPath }) : null;
+  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,signingKeyPath,verifyKeyPath }) : null;
 const autonomousSupervisor = autonomousRuntime && autonomousPolicy.planner.backend === 'openai_compatible' &&
   autonomousSupervisorMode === 'in_process'
   ? startAutonomousSupervisor({ runtime: autonomousRuntime, policy: autonomousPolicy })
@@ -169,11 +173,22 @@ function textResult(schema, object, isError = false) {
   return structuredToolResult(schema, object, isError);
 }
 
+const COMPACT_CODING_DIRECT_TOOLS=new Set([
+  'coding_session_status','coding_tree','coding_symbol_replace','coding_file_read','coding_file_write',
+  'coding_text_replace','coding_command_run','coding_benchmark_run','coding_receipt_verify',
+  'coding_task_submit','coding_task_run','coding_task_status','coding_task_events','coding_task_cancel',
+  'coding_task_approve','coding_task_verify'
+]);
+function filteredToolServer(server,allowed){
+  return {registerTool(name,...args){if(allowed.has(name)) return server.registerTool(name,...args);}};
+}
+
 serveStdio(() => {
   const server = new McpServer({ name: 'deadbyte-mcp', version: DEADBYTE_VERSION });
-  registerOperatorSurface(server,{packageRoot});
+  registerOperatorSurface(server,{packageRoot,surfaceProfile,compactToolLimit:COMPACT_SURFACE_TOOL_LIMIT});
   if (toolAudit) installToolAudit(server,toolAudit);
 
+  if (surfaceProfile === 'full') {
   server.registerTool(
     'workspace_open',
     {
@@ -289,6 +304,8 @@ serveStdio(() => {
     }
   );
 
+  }
+
   server.registerTool(
     'evidence_verify',
     {
@@ -319,23 +336,24 @@ serveStdio(() => {
     });
   }
 
-  if (agentRuntime) {
+  if (agentRuntime && surfaceProfile === 'full') {
     registerAgentTools(server, { runtime: agentRuntime, workspacePathFromId });
   }
 
-  if (processRuntime) {
+  if (processRuntime && surfaceProfile === 'full') {
     registerProcessTools(server, { runtime: processRuntime });
   }
 
   if (codingRuntime && codingTaskRuntime && semanticRuntime) {
-    registerCodingTools(server, { codingRuntime, taskRuntime: codingTaskRuntime, semanticRuntime });
+    const codingServer=surfaceProfile==='full'?server:filteredToolServer(server,COMPACT_CODING_DIRECT_TOOLS);
+    registerCodingTools(codingServer, { codingRuntime, taskRuntime: codingTaskRuntime, semanticRuntime });
   }
 
-  if (machineFsRuntime) {
+  if (machineFsRuntime && surfaceProfile === 'full') {
     registerMachineFsTools(server, { runtime: machineFsRuntime });
   }
 
-  if (observationRuntime) {
+  if (observationRuntime && surfaceProfile === 'full') {
     registerObservationTools(server, { runtime: observationRuntime });
   }
 
@@ -343,6 +361,11 @@ serveStdio(() => {
     registerAutonomousTools(server, { autonomousRuntime, nativeDiffRuntime });
   }
 
+  registerCompactGatewayTools(server,{
+    profile:surfaceProfile,ledger:R36_CAPABILITY_LEDGER,codingRuntime,semanticRuntime,machineFsRuntime,
+    processRuntime,observationRuntime,machineRuntime
+  });
+
   if (hostPolicy) {
     server.registerTool(
       'host_file_read',