deadbyte-mcp 0.9.0 → 0.11.0

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 { createLiveTimelineTracker, formatCompactAuditEvent, formatRemoteLifecycle, formatRuntimeDiagnosticLine } 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({
@@ -33,9 +34,8 @@ function printHelp(){
   process.stdout.write([
     'DEADBYTE MCP CLI','',
     '  npx deadbyte-mcp@latest mcp                 # stdio MCP server for local clients',
-    '  npx deadbyte-mcp@latest remote              # compact foreground device session',
-    '  npx deadbyte-mcp@latest remote --verbose    # detailed audit + bridge logs',
-    '  npx deadbyte-mcp@latest remote --resume <cursor> # replay missed compact results, then reconnect',
+    '  npx deadbyte-mcp@latest remote              # unified foreground device session + live timeline',
+    '  npx deadbyte-mcp@latest remote --resume <cursor> # replay missed results, then reconnect',
     '  npx deadbyte-mcp@latest remote status',
     '  npx deadbyte-mcp@latest remote restart',
     '  npx deadbyte-mcp@latest supervisor status',
@@ -77,39 +77,15 @@ async function listLogFiles(root){
   }
   return files;
 }
-function formatLogLine(file,line,{verbose=false}={}){
+function formatLogLine(file,line,{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}`;
-      }
-      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}`:'';
-      let marker='';
-      if(event.event_type==='tool.request') marker='📥 ';
-      else if(event.event_type==='tool.result'){
-        if(event.outcome?.is_error===true) marker='📤❌ ';
-        else if(event.outcome?.is_error===false) marker='📤✅ ';
-        else marker='📤 ';
-      }
-      return `${marker}[AUDIT ${seq}] ${event.event_type||'event'}${tool}${request}`;
-    }catch{return verbose?`[AUDIT] ${line}`:null;}
+      return activityTracker?activityTracker.observe(event):formatCompactAuditEvent(event);
+    }catch{return null;}
   }
-  if(!verbose) return null;
-  const label=path.basename(file).replace(/\.log$/i,'').toUpperCase();
-  let marker='';
-  if(/\[TOOL IN \]/.test(line)) marker='📥 ';
-  else if(/\[TOOL OUT\]/.test(line)){
-    if(/"is_error"\s*:\s*true/.test(line)) marker='📤❌ ';
-    else if(/"is_error"\s*:\s*false/.test(line)) marker='📤✅ ';
-    else marker='📤 ';
-  }
-  return `${marker}[${label}] ${line}`;
+  return formatRuntimeDiagnosticLine(file,line);
 }
 function remoteResultJournalPath(root,sessionId){return path.join(root,'runtime','remote-results',`${sessionId}.json`);}
 function auditTerminalResult(file,line){
@@ -120,7 +96,7 @@ function auditTerminalResult(file,line){
   return {request_id:event.request_id,tool:event.tool,status:event.outcome?.is_error===true?'error':'ok',observed_at_utc:observed,
     payload_sha256:createHash('sha256').update(Buffer.from(line,'utf8')).digest('hex')};
 }
-async function replayRemoteResults(root,cursor,{verbose=false}={}){
+async function replayRemoteResults(root,cursor){
   const parsed=parseRemoteResultCursor(cursor);
   const file=remoteResultJournalPath(root,parsed.session_id);
   await requireRegular(file,'remote result journal');
@@ -130,7 +106,7 @@ async function replayRemoteResults(root,cursor,{verbose=false}={}){
     const page=await journal.replayAfter(next,{limit:200});
     for(const event of page.events){
       const marker=event.status==='error'?'[ERR]':'[OK]';
-      process.stdout.write(`${verbose?'[REPLAY] ': '[REPLAY] '}${marker} ${event.tool} [cursor r1:${event.session_id}:${event.seq}]\n`);
+      process.stdout.write(`[REPLAY] ${marker} ${event.tool} [cursor r1:${event.session_id}:${event.seq}]\n`);
     }
     next=page.next_cursor;
     if(!page.has_more) return next;
@@ -147,39 +123,39 @@ 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{}
   }
-  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');
+  return offsets;
+}
+async function tailRemoteLogs(root,signal,{journal=null,offsets=null,activityTracker=null}={}){
+  process.stdout.write('[LOG] Unified live timeline. 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});
+        if(recorded?.duplicate) continue;
+        const formatted=formatLogLine(file,line,{activityTracker});
         if(!formatted) continue;
-        if(!verbose&&recorded) process.stdout.write(`${formatted} [cursor ${recorded.cursor}]\n`);
+        if(recorded) process.stdout.write(`${formatted} [cursor ${recorded.cursor}]\n`);
         else process.stdout.write(`${formatted}\n`);
       }
     }
     try{await sleep(250,null,{signal});}catch(error){if(error?.name!=='AbortError') throw error;}
   }
 }
-async function cleanupRemoteSession(ctx,{verbose=false}={}){
+async function cleanupRemoteSession(ctx){
   for(const command of SESSION_CLEANUP){
     try{
-      const result=invokeController(ctx,command,verbose
-        ?{allowFailure:true}
-        :{allowFailure:true,capture:true,echoCaptured:false});
+      const result=invokeController(ctx,command,{allowFailure:true,capture:true,echoCaptured:false});
       if(result.status!==0) process.stderr.write(`⚠️ [WARN] cleanup ${command} exit=${result.status}\n`);
     }
     catch(error){process.stderr.write(`⚠️ [WARN] cleanup ${command}: ${String(error?.message||error)}\n`);}
@@ -258,62 +234,70 @@ async function releaseRemoteSession(ctx,marker){
   const same=current?.schema==='deadbyte.remote-session.v2'&&current.owner_pid===marker.owner_pid&&current.session_nonce===marker.session_nonce;
   if(same) await rm(remoteSessionMarker(ctx.root),{force:true});
 }
-async function runRemoteSession({verbose=false,resumeCursor=null}={}){
+async function runRemoteSession({resumeCursor=null}={}){
   const ctx=await remoteContext();
-  if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{verbose});
+  if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor);
   await recoverRemoteSession(ctx);
   const marker=await claimRemoteSession(ctx);
   const resultJournal=await openRemoteResultJournal({
     filePath:remoteResultJournalPath(ctx.root,marker.result_session_id),sessionId:marker.result_session_id,maxEntries:2048
   });
+  const activityTracker=createLiveTimelineTracker();
   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}));
-      const startText=started[0]?.stdout||'';
-      const url=startText.match(/^URL\s*:\s*(\S+)/m)?.[1]||'';
-      process.stdout.write('[OK] ONLINE\n');
-      if(url) process.stdout.write(`URL: ${url}\n`);
+    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,{journal:resultJournal,offsets:logOffsets,activityTracker});
+    process.stdout.write('[BOOT] Starting local + remote runtime...\n');
+    const started=[];
+    for(const command of SESSION_START){
+      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,{capture:true,echoCaptured:false});
+      started.push(controllerResult);
+      if(command==='start'){
+        process.stdout.write(`${formatRemoteLifecycle('bridge_connected')}\n`);
+        process.stdout.write(`${formatRemoteLifecycle('cloud_connected')}\n`);
+      }
     }
+    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');
     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`);
+      const result=invokeController(ctx,command,{capture:true,echoCaptured:false});
+      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});
+    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(()=>{});
+    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');
-    await cleanupRemoteSession(ctx,{verbose});
+    process.stdout.write(`${formatRemoteLifecycle('cleanup')}\n`);
+    if(ready||!wasAborted) process.stdout.write('[INFO] Disconnecting; revoking authority...\n');
+    await cleanupRemoteSession(ctx);
     await releaseRemoteSession(ctx,marker);
   }
 }
 async function runRemote(args){
   if(args.length===0){await runRemoteSession();return;}
-  if(args.length===1&&args[0]==='--verbose'){await runRemoteSession({verbose:true});return;}
   if(args.length===2&&args[0]==='--resume'){await runRemoteSession({resumeCursor:args[1]});return;}
-  if(args.length===3&&args[0]==='--verbose'&&args[1]==='--resume'){
-    await runRemoteSession({verbose:true,resumeCursor:args[2]});return;
-  }
-  if(args.length===3&&args[0]==='--resume'&&args[2]==='--verbose'){
-    await runRemoteSession({verbose:true,resumeCursor:args[1]});return;
-  }
-  if(args.length>1) throw new Error('remote accepts one controller command, --verbose, or --resume <cursor>');
+  if(args.length>1) throw new Error('remote accepts one controller command or --resume <cursor>');
   const command=args[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);
   const ctx=await remoteContext();
   const result=invokeController(ctx,command,{allowFailure:true});

package/src/effect-ledger.mjs

@@ -0,0 +1,47 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const EFFECT_LEDGER_SCHEMA='deadbyte.effect-ledger.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,128}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+
+function assertHex(name,value){if(!HEX64.test(value??'')) throw new Error(`${name} must be sha256`);}
+function assertId(name,value){if(!ID.test(value??'')) throw new Error(`${name} invalid`);}
+
+export function effectIdentity({goalId,planId,stepId,mutationEpoch,action,observationHeadSha256=null}){
+  assertHex('goalId',goalId);
+  assertHex('planId',planId);
+  assertId('stepId',stepId);
+  if(!Number.isInteger(mutationEpoch)||mutationEpoch<0) throw new Error('mutationEpoch invalid');
+  if(!action||typeof action!=='object'||Array.isArray(action)||typeof action.kind!=='string') throw new Error('action invalid');
+  if(observationHeadSha256!==null) assertHex('observationHeadSha256',observationHeadSha256);
+  const effectShape={schema:EFFECT_LEDGER_SCHEMA,kind:action.kind,mutation_epoch:mutationEpoch,
+    observation_head_sha256:observationHeadSha256,action};
+  const fingerprint=sha(effectShape);
+  const identity={schema:EFFECT_LEDGER_SCHEMA,goal_id:goalId,plan_id:planId,step_id:stepId,
+    mutation_epoch:mutationEpoch,fingerprint};
+  return Object.freeze({...identity,effect_id:sha(identity)});
+}
+
+export function loopGuardDisposition(events,candidate,{maxRepeats=3,window=24}={}){
+  if(!Array.isArray(events)) throw new Error('effect events must be array');
+  if(!candidate||!HEX64.test(candidate.fingerprint??'')) throw new Error('effect candidate invalid');
+  if(!Number.isInteger(maxRepeats)||maxRepeats<1) throw new Error('maxRepeats invalid');
+  if(!Number.isInteger(window)||window<1) throw new Error('window invalid');
+  const recent=events.slice(-window);
+  const started=recent.filter(event=>event?.type==='effect_started'&&event.payload?.fingerprint===candidate.fingerprint);
+  const terminal=new Set(recent.filter(event=>['effect_completed','effect_failed'].includes(event?.type)&&HEX64.test(event.payload?.effect_id??''))
+    .map(event=>event.payload.effect_id));
+  const repeated=started.filter(event=>terminal.has(event.payload?.effect_id)).length;
+  return Object.freeze({allowed:repeated<maxRepeats,reason:repeated<maxRepeats?'allowed':'effect_repeat_limit',
+    repeated_count:repeated,max_repeats:maxRepeats,fingerprint:candidate.fingerprint});
+}
+
+export function bindEffectCompletion(effect,outcome){
+  if(!effect||!HEX64.test(effect.effect_id??'')||!HEX64.test(effect.fingerprint??'')) throw new Error('effect identity invalid');
+  if(!outcome||typeof outcome!=='object'||Array.isArray(outcome)) throw new Error('effect outcome invalid');
+  const result_sha256=sha(outcome);
+  return Object.freeze({schema:'deadbyte.effect-completion.v1',effect_id:effect.effect_id,
+    fingerprint:effect.fingerprint,result_sha256});
+}

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',