deadbyte-mcp 0.15.23 → 0.15.25

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

@@ -2,8 +2,9 @@ import * as z from 'zod/v4';
 import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { readCommanderUrl } from './commander-url-reader-r48.mjs';
-import { readDocxBytes, createDocxBytes, editDocxBytes, readXlsxBytes, editXlsxBytes, createXlsxBytes, appendXlsxBytes } from './commander-office-reader-r48.mjs';
+import { readDocxBytes, searchDocxTextBytes, createDocxBytes, editDocxBytes, readXlsxBytes, editXlsxBytes, createXlsxBytes, appendXlsxBytes } from './commander-office-reader-r48.mjs';
 import { editDeadbytePdf, parseDeadbytePdf, readPdfText } from './commander-pdf-r48.mjs';
+import { decodeUtf8Strict } from './text-policy.mjs';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
 const RDC_PROCESS_READ_CHUNK=256*1024;
@@ -122,6 +123,19 @@ function absoluteFor(runtime,rootId,relativePath){
 function linesFrom(bytes){
   return Buffer.from(bytes,'base64').toString('utf8').replaceAll('\\r\\n','\\n').replaceAll('\\r','\\n').split('\\n');
 }
+function isUnknownBinary(bytes){
+  if(bytes.includes(0)) return true;
+  try{decodeUtf8Strict(bytes);return false;}catch{return true;}
+}
+function directoryRows(entries,baseRelative){
+  const base=String(baseRelative??'.').replaceAll('\\','/').replace(/^\.\//,'').replace(/\/$/,'');
+  return entries.map(entry=>{
+    const raw=String(entry.path??'').replaceAll('\\','/').replace(/^\.\//,'');
+    const relative=base&&base!=='.'&&raw.startsWith(`${base}/`)?raw.slice(base.length+1):raw;
+    const display=process.platform==='win32'?relative.replaceAll('/','\\'):relative;
+    return `${(entry.kind??entry.type)==='directory'?'[DIR]':'[FILE]'} ${display}`;
+  });
+}
 function rdcFileResult(pathname,data){
   return {
     path:pathname,content:data.content,mimeType:data.mime_type,
@@ -171,6 +185,17 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     }
     if(!machineFsRuntime) throw new Error('machine filesystem runtime is disabled');
     const target=resolveRdcPath(machineFsRuntime,args.path);
+    if(typeof machineFsRuntime.stat==='function'){
+      const info=await machineFsRuntime.stat({rootId:target.rootId,relativePath:target.relativePath,hash:false});
+      if(info?.kind==='directory'){
+        const listing=await listDirectory({path:args.path,depth:2});
+        const entries=listing.structuredContent?.entries??[];
+        const rows=directoryRows(entries,target.relativePath);
+        const content=`This is a directory, not a file. Use the list_directory tool instead of read_file for directories.\n\n${rows.join('\n')}`;
+        return text(content,false,{path:args.path,content,mimeType:'text/plain',isImage:false,isPdf:false,isDirectory:true,
+          entries,truncated:listing.structuredContent?.truncated===true,entryCount:entries.length});
+      }
+    }
     const ext=path.extname(args.path).toLowerCase();
     const richDocument=ext==='.docx'||ext==='.xlsx'||ext==='.xlsm'||ext==='.pdf';
     const imageMime={'.png':'image/png','.jpg':'image/jpeg','.jpeg':'image/jpeg','.gif':'image/gif','.webp':'image/webp'}[ext];
@@ -238,6 +263,10 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     if(ext==='.xls') {
       throw new Error('format .xls requires a native BIFF adapter; request rejected rather than returned as plain text');
     }
+    if(isUnknownBinary(bytes)){
+      const content=`Cannot read binary file as text: ${path.basename(args.path)}\n\nUse start_process + interact_with_process to analyze binary files with appropriate tools (Node.js or Python libraries, command-line utilities, etc.).\n\nThe read_file tool only handles text files, images, and Excel files.`;
+      return text(content,false,{path:args.path,content,mimeType:'text/plain',isImage:false,isPdf:false,isBinary:true,fileSha256,...optionMeta});
+    }
     const all=linesFrom(raw.data_base64);
     const start=requestedOffset<0?Math.max(0,all.length+requestedOffset):Math.min(requestedOffset,all.length);
     const end=requestedOffset<0?all.length:Math.min(all.length,start+requestedLength);
@@ -381,7 +410,7 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
       }
       frontier=next;
     }
-    const rows=all.map(e=>`${(e.kind??e.type)==='directory'?'[DIR]':'[FILE]'} ${e.path}`);
+    const rows=directoryRows(all,target.relativePath);
     return text(rows.join('\n'),false,{path:args.path,depth,entries:all,truncated,entryCount:all.length});
   }
 
@@ -552,6 +581,19 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     }
     return null;
   }
+  async function waitForStreamQuiescence(sessionId,observed,timeoutMs,settleMs=100){
+    const deadline=Date.now()+timeoutMs;
+    let current=observed;
+    while(current.state==='running'&&Date.now()<deadline){
+      const baseline=current.stream_head;
+      const waitMs=Math.min(settleMs,Math.max(1,deadline-Date.now()));
+      const next=await processRuntime.read({sessionId,offset:baseline,maxBytes:1,waitMs});
+      if(next.state!=='running') return next;
+      if(next.stream_head>baseline){ current=next; continue; }
+      return next;
+    }
+    return current;
+  }
   async function readProcessRange(sessionId,start,end){
     if(!Number.isInteger(start)||!Number.isInteger(end)||start<0||end<start) throw new Error('native process range invalid');
     if(end-start>RDC_PROCESS_SNAPSHOT_MAX) throw new Error(`RDC process response exceeds ${RDC_PROCESS_SNAPSHOT_MAX} byte compatibility bound`);
@@ -681,6 +723,9 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
     if((observed.stream_head??before.stream_head)<=before.stream_head&&observed.state==='running'&&waitMs>0){
       observed=await waitForStreamAdvance(sessionId,before.stream_head,waitMs)??observed;
     }
+    if((observed.stream_head??before.stream_head)>before.stream_head&&observed.state==='running'&&waitMs>0){
+      observed=await waitForStreamQuiescence(sessionId,observed,waitMs);
+    }
     const streamHead=Number.isInteger(observed.stream_head)?observed.stream_head:before.stream_head;
     const earliest=Number.isInteger(observed.earliest_offset)?observed.earliest_offset:observed.offset;
     const start=Math.max(before.stream_head,earliest);
@@ -803,6 +848,31 @@ export function createCommanderWireAdapter({machineFsRuntime=null,processRuntime
             seenCursors.add(query.cursor);
           }
         }while(query.cursor!==null&&state.results.length<query.maxResults);
+        const docxSearchEnabled=String(args.filePattern??'').toLowerCase().includes('.docx')||String(args.path).toLowerCase().endsWith('.docx');
+        if(args.searchType==='content'&&machineFsRuntime&&docxSearchEnabled&&state.results.length<query.maxResults){
+          let docxEntries=[];
+          if(typeof machineFsRuntime.stat==='function'){
+            const info=await machineFsRuntime.stat({rootId:target.rootId,relativePath:target.relativePath,hash:false});
+            if(info?.kind==='file'&&target.relativePath.toLowerCase().endsWith('.docx'))docxEntries=[{path:target.relativePath,kind:'file'}];
+          }
+          if(docxEntries.length===0){
+            const listing=await listDirectory({path:args.path,depth:10});
+            docxEntries=(listing.structuredContent?.entries??[]).filter(entry=>(entry.kind??entry.type)==='file'&&String(entry.path).toLowerCase().endsWith('.docx'));
+          }
+          for(const entry of docxEntries){
+            if(state.cancelled||state.timedOut||state.results.length>=query.maxResults)break;
+            const raw=await machineFsRuntime.read({rootId:target.rootId,relativePath:entry.path,offset:0,
+              maxBytes:Math.min(64*1024*1024,machineFsRuntime.policy.max_read_bytes??64*1024*1024),hashFile:true});
+            if(raw.eof===false)continue;
+            const matches=searchDocxTextBytes(Buffer.from(raw.data_base64,'base64'),{
+              pattern:args.pattern,ignoreCase:args.ignoreCase!==false,maxResults:query.maxResults-state.results.length
+            });
+            for(const match of matches)state.results.push({
+              file:absoluteFor(machineFsRuntime,target.rootId,entry.path)+(match.part==='word/document.xml'?'':`:${match.part.slice('word/'.length)}`),
+              line:match.line,match:match.match,type:'content'
+            });
+          }
+        }
         if(!state.cancelled&&!state.timedOut) state.isComplete=true;
       }catch(error){if(!state.cancelled&&!state.timedOut){state.isError=true;state.error=String(error?.message??error);}state.isComplete=true;}
       finally{if(timeoutHandle!==null) clearTimeout(timeoutHandle);}

package/src/host-plane.mjs

@@ -1,19 +1,16 @@
-import { createHash, randomBytes } from 'node:crypto';
-import { constants as fsConstants } from 'node:fs';
+import { createHash } from 'node:crypto';
 import {
   lstat,
   mkdir,
-  open,
   readFile,
   realpath,
-  rename,
-  rm,
   stat
 } from 'node:fs/promises';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { decodeUtf8Strict } from './text-policy.mjs';
 import { isInside, validatePortableRelativePath } from './path-policy.mjs';
+import { atomicMutation } from './atomic-mutation.mjs';
 
 export const HOST_POLICY_SCHEMA = 'deadbyte.host-policy.v1';
 export const HOST_POLICY_SCHEMA_V2 = 'deadbyte.host-policy.v2';
@@ -315,32 +312,14 @@ export async function hostFileWrite(policy, { rootId, relativePath, content, enc
   const bytes = decodeWriteContent(content, encoding);
   if (bytes.length > policy.max_write_bytes) throw new Error(`host write exceeds ${policy.max_write_bytes} byte limit`);
 
-  const before = await currentTargetState(lexical);
-  checkExpectedState(before, expectedSha256);
-
-  const temp = path.join(path.dirname(lexical), `.${path.basename(lexical)}.deadbyte-${process.pid}-${randomBytes(8).toString('hex')}.tmp`);
-  let handle;
-  try {
-    await authorityCheck();
-    handle = await open(temp, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY, 0o600);
-    await handle.writeFile(bytes);
-    await handle.sync();
-    await handle.close();
-    handle = null;
-
-    const raceCheck = await currentTargetState(lexical);
-    checkExpectedState(raceCheck, expectedSha256);
-    await authorityCheck();
-    await rename(temp, lexical);
-  } catch (error) {
-    if (handle) await handle.close().catch(() => {});
-    await rm(temp, { force: true }).catch(() => {});
-    throw error;
-  }
-
-  const after = await currentTargetState(lexical);
-  const expectedAfter = sha256Bytes(bytes);
-  if (!after.exists || after.sha256 !== expectedAfter) throw new Error('host write post-commit hash mismatch');
+  const { before, after } = await atomicMutation({
+    target: lexical,
+    bytes,
+    expected: expectedSha256,
+    readState: currentTargetState,
+    assertExpected: checkExpectedState,
+    authorityCheck
+  });
   return {
     previous_sha256: before.sha256,
     sha256: after.sha256,

package/src/machine-fs-mcp-tools.mjs

@@ -10,7 +10,13 @@ const rel = z.string().min(1).max(2048);
 const hex64 = z.string().regex(/^[0-9a-f]{64}$/);
 const expectedFile = z.string().regex(/^(?:absent|[0-9a-f]{64})$/);
 const ok = (schema, value) => machineFsStructuredResult(schema, value, false);
-const fail = (schema, error) => machineFsStructuredResult(schema, { status:'denied', error:String(error) }, true);
+const fail = (schema, error) => {
+  const unknown=error?.side_effect_state==='unknown'&&error?.outcome==='FAILED_AFTER_UNKNOWN_EFFECT';
+  return machineFsStructuredResult(schema, {
+    status:unknown?'failed':'denied',error:String(error),
+    ...(unknown?{outcome:error.outcome,side_effect_state:'unknown',expected_after_sha256:error.expected_after_sha256}: {})
+  }, true);
+};
 
 export function registerMachineFsTools(server, { runtime }) {
   if (!server || !runtime) throw new Error('machine fs tool registration requires server/runtime');

package/src/machine-fs-output-contracts.mjs

@@ -7,6 +7,11 @@ const pathText = z.string().min(1).max(2048);
 const statusOk = z.enum(['ok','denied','failed']);
 const statusCommit = z.enum(['committed','denied','failed']);
 const error = z.string().min(1).max(4096).optional();
+const unknownEffect = {
+  outcome: z.literal('FAILED_AFTER_UNKNOWN_EFFECT').optional(),
+  side_effect_state: z.literal('unknown').optional(),
+  expected_after_sha256: hex64.optional()
+};
 
 export const machineFsStatOutputSchema = z.strictObject({
   status: statusOk, error,
@@ -38,6 +43,7 @@ export const machineFsReadOutputSchema = z.strictObject({
 
 const commitBase = {
   status: statusCommit, error,
+  ...unknownEffect,
   root_id: z.string().min(1).max(64).optional(),
   receipt_id: receiptId.optional(), receipt_sha256: hex64.optional(), request_sha256: hex64.optional()
 };

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

@@ -8,6 +8,7 @@ import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotoc
 import { CODING_GRANT_SCHEMA, loadCodingPolicy } from './coding-plane.mjs';
 import { verifyMachineFsReceiptFile } from './machine-fs.mjs';
 import { generateTrustKeypair } from './trust.mjs';
+import { assertExactCatalog, expectedFullCatalogForEnv } from './runtime-catalog-expectation.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(here, '..');
@@ -51,24 +52,13 @@ const client = new Client({ name: 'deadbyte-machine-fs-smoke', version: '0.8.0'
 const transport = new StdioClientTransport({
   command: process.execPath, args: [serverPath], cwd: repoRoot,
   env: { ...getDefaultEnvironment(), DEADBYTE_CODING_RUNTIME: '1', DEADBYTE_MACHINE_FS_RUNTIME: '1',
+    DEADBYTE_PRIVILEGED_POLICY: '',
     DEADBYTE_CODING_POLICY: policyPath, DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
     DEADBYTE_VERIFY_KEY: keys.publicKeyPath }, stderr: 'pipe'
 });
 const stderrChunks = [];
 transport.stderr?.on('data', chunk => stderrChunks.push(Buffer.from(chunk)));
-const baseTools = ['contained_transform','evidence_verify','file_read','host_exec','host_file_read','host_file_write','proof_execute','skill_catalog','workspace_open'];
-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_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'
-];
-const machineFsTools = [
-  'machine_fs_delete','machine_fs_edit_exact','machine_fs_list','machine_fs_mkdir',
-  'machine_fs_move','machine_fs_read','machine_fs_stat','machine_fs_write'
-];
-const expectedCatalog = [...baseTools, ...codingTools, ...machineFsTools].sort();
+const expectedCatalog = await expectedFullCatalogForEnv({DEADBYTE_CODING_RUNTIME:'1',DEADBYTE_MACHINE_FS_RUNTIME:'1'});
 const receipts = [];
 const remember = (operation, result) => {
   if (result.status !== 'committed' || !/^[0-9a-f]{24}$/.test(result.receipt_id ?? '')) throw new Error(`${operation} missing committed receipt`);
@@ -79,10 +69,9 @@ try {
   await client.connect(transport);
   const listed = await client.listTools();
   const names = listed.tools.map(tool => tool.name).sort();
-  if (JSON.stringify(names) !== JSON.stringify(expectedCatalog)) throw new Error(`machine fs smoke catalog mismatch: ${JSON.stringify(names)}`);
-  for (const tool of listed.tools) {
-    if (tool.outputSchema?.type !== 'object' || tool.outputSchema?.additionalProperties !== false) throw new Error(`tool ${tool.name} missing strict output schema`);
-  }
+  assertExactCatalog(names,expectedCatalog,'machine fs smoke');
+  for (const tool of listed.tools) if (tool.outputSchema !== undefined &&
+      (tool.outputSchema?.type !== 'object' || tool.outputSchema?.additionalProperties !== false)) throw new Error(`tool ${tool.name} has non-strict output schema`);
   const rootStat = structured(await client.callTool({ name:'machine_fs_stat', arguments:{ root_id:'core', path:'.', hash:false } }), 'machine_fs_stat(root)');
   if (rootStat.status !== 'ok' || rootStat.kind !== 'directory') throw new Error('machine fs root stat malformed');
   const made = remember('machine_fs_mkdir', structured(await client.callTool({

package/src/mcp-host-smoke-client.mjs

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { Client } from '@modelcontextprotocol/client';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
 import { generateTrustKeypair } from './trust.mjs';
+import { assertExactCatalog, expectedFullCatalogForEnv } from './runtime-catalog-expectation.mjs';
 
 const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
 const here = path.dirname(fileURLToPath(import.meta.url));
@@ -84,8 +85,8 @@ function structured(result, label) {
 try {
   await client.connect(transport);
   const names = (await client.listTools()).tools.map(t => t.name).sort();
-  const expected = ['contained_transform', 'evidence_verify', 'file_read', 'host_exec', 'host_file_read', 'host_file_write', 'proof_execute', 'skill_catalog', 'workspace_open'];
-  if (JSON.stringify(names) !== JSON.stringify(expected)) throw new Error(`privileged catalog mismatch: ${JSON.stringify(names)}`);
+  const expected = await expectedFullCatalogForEnv({DEADBYTE_PRIVILEGED_POLICY:policyPath});
+  assertExactCatalog(names,expected,'privileged smoke');
 
   const writeText = structured(await client.callTool({
     name: 'host_file_write',

package/src/mcp-server.mjs

@@ -5,6 +5,7 @@ import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { McpServer } from '@modelcontextprotocol/server';
 import { serveStdio } from '@modelcontextprotocol/server/stdio';
+import { DeadbyteStdioServerTransport } from './stdio-protocol-guard.mjs';
 import * as z from 'zod/v4';
 import { executeProof } from './executor.mjs';
 import { CONTAINED_TRANSFORM_OPERATIONS, executeContainedTransform } from './contained-executor.mjs';
@@ -529,7 +530,18 @@ serveStdio(() => {
           });
           return textResult(hostFileWriteOutputSchema, { status: 'committed', root_id, path: relativePath, ...result });
         } catch (error) {
-          return textResult(hostFileWriteOutputSchema, { status: 'denied', error: String(error) }, true);
+          const unknown = error?.outcome === 'FAILED_AFTER_UNKNOWN_EFFECT'
+            && error?.side_effect_state === 'unknown'
+            && /^[0-9a-f]{64}$/.test(error?.expected_after_sha256 ?? '');
+          return textResult(hostFileWriteOutputSchema, {
+            status: unknown ? 'failed' : 'denied',
+            error: String(error),
+            ...(unknown ? {
+              outcome: error.outcome,
+              side_effect_state: error.side_effect_state,
+              expected_after_sha256: error.expected_after_sha256
+            } : {})
+          }, true);
         }
       }
     );
@@ -618,4 +630,4 @@ serveStdio(() => {
   }
 
   return server;
-}, { legacy: 'reject' });
+}, { legacy: 'reject', transport: new DeadbyteStdioServerTransport() });

package/src/mcp-smoke-client.mjs

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { Client } from '@modelcontextprotocol/client';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
 import { generateTrustKeypair } from './trust.mjs';
+import { assertExactCatalog, expectedFullCatalogForEnv } from './runtime-catalog-expectation.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(here, '..');
@@ -39,6 +40,7 @@ const transport = new StdioClientTransport({
     DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
     DEADBYTE_SIGNING_KEY: keys.privateKeyPath,
     DEADBYTE_VERIFY_KEY: keys.publicKeyPath,
+    DEADBYTE_PRIVILEGED_POLICY: '',
     DEADBYTE_STDIO_CONSOLE_GUARD_PROBE: '1'
   },
   stderr: 'pipe'
@@ -67,15 +69,8 @@ try {
   const names = listed.tools.map(tool => tool.name).sort();
   const guardStderr = Buffer.concat(serverStderr).toString('utf8');
   if (!guardStderr.includes('DEADBYTE MCP LOG DEADBYTE_STDIO_CONSOLE_GUARD_PROBE')) throw new Error('stdio console guard probe did not reach stderr');
-  const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'skill_catalog', 'workspace_open'];
-  const privilegedTools = ['host_exec', 'host_file_read', 'host_file_write'];
-  const allowedCatalogs = [
-    baseTools,
-    [...baseTools, ...privilegedTools]
-  ].map(items => [...items].sort());
-  if (!allowedCatalogs.some(expected => JSON.stringify(names) === JSON.stringify(expected))) {
-    throw new Error(`tool catalog mismatch: ${JSON.stringify(names)}`);
-  }
+  const expected=await expectedFullCatalogForEnv({});
+  assertExactCatalog(names,expected,'MCP smoke');
 
   const opened = structured(await client.callTool({
     name: 'workspace_open',

package/src/observation-smoke-client.mjs

@@ -8,6 +8,7 @@ import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotoc
 import { loadCodingPolicy } from './coding-plane.mjs';
 import { verifyObservationReceiptFile } from './observation-runtime.mjs';
 import { generateTrustKeypair } from './trust.mjs';
+import { assertExactCatalog, expectedFullCatalogForEnv } from './runtime-catalog-expectation.mjs';
 
 const here=path.dirname(fileURLToPath(import.meta.url));
 const repoRoot=path.resolve(here,'..');
@@ -49,21 +50,15 @@ const client=new Client({name:'deadbyte-observation-smoke',version:'0.8.0'},
   {versionNegotiation:{mode:{pin:'2026-07-28'}}});
 const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,
   env:{...getDefaultEnvironment(),DEADBYTE_MACHINE_RUNTIME:'1',DEADBYTE_CODING_RUNTIME:'1',DEADBYTE_OBSERVATION_RUNTIME:'1',
+    DEADBYTE_PRIVILEGED_POLICY:'',
     DEADBYTE_CODING_POLICY:policyPath,DEADBYTE_STATE_ROOT:state,DEADBYTE_SIGNING_KEY:keys.privateKeyPath,DEADBYTE_VERIFY_KEY:keys.publicKeyPath},stderr:'pipe'});
 const stderr=[]; transport.stderr?.on('data',chunk=>stderr.push(Buffer.from(chunk)));
-const base=['contained_transform','evidence_verify','file_read','host_exec','host_file_read','host_file_write','proof_execute','skill_catalog','workspace_open'];
-const machine=['machine_list','machine_ping','machine_revoke','machine_status'];
-const coding=['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_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'];
-const observation=['machine_hardware_query','machine_process_list','machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_system_status'];
-const expected=[...base,...machine,...coding,...observation].sort();
+const expected=await expectedFullCatalogForEnv({DEADBYTE_MACHINE_RUNTIME:'1',DEADBYTE_CODING_RUNTIME:'1',DEADBYTE_OBSERVATION_RUNTIME:'1'});
 try{
   await client.connect(transport);
   const listed=await client.listTools(); const names=listed.tools.map(tool=>tool.name).sort();
-  if(JSON.stringify(names)!==JSON.stringify(expected)) throw new Error(`observation smoke catalog mismatch: ${JSON.stringify(names)}`);
-  for(const tool of listed.tools) if(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false) throw new Error(`tool ${tool.name} missing strict output schema`);
+  assertExactCatalog(names,expected,'observation smoke');
+  for(const tool of listed.tools) if(tool.outputSchema!==undefined&&(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false)) throw new Error(`tool ${tool.name} has non-strict output schema`);
   const codingStatus=structured(await client.callTool({name:'coding_session_status',arguments:{}}),'coding_session_status');
   if(codingStatus.status!=='ok'||codingStatus.armed!==false) throw new Error('observation smoke requires coding mutation authority disarmed');
   const system=structured(await client.callTool({name:'machine_system_status',arguments:{}}),'machine_system_status');

package/src/output-contracts.mjs

@@ -217,13 +217,15 @@ export const hostFileReadOutputSchema = statusContract({
 });
 
 export const hostFileWriteOutputSchema = statusContract({
-  statuses: ['committed', 'denied'],
+  statuses: ['committed', 'denied', 'failed'],
   shape: {
     root_id: z.string().min(1).max(64).optional(), path: z.string().min(1).max(512).optional(),
     previous_sha256: hex64.nullable().optional(), sha256: hex64.optional(),
-    bytes: z.number().int().min(0).optional(), created: z.boolean().optional()
+    bytes: z.number().int().min(0).optional(), created: z.boolean().optional(),
+    outcome: z.literal('FAILED_AFTER_UNKNOWN_EFFECT').optional(),
+    side_effect_state: z.literal('unknown').optional(), expected_after_sha256: hex64.optional()
   },
-  successStatuses: ['committed'], successRequired: ['root_id', 'path', 'previous_sha256', 'sha256', 'bytes', 'created'], errorStatuses: ['denied']
+  successStatuses: ['committed'], successRequired: ['root_id', 'path', 'previous_sha256', 'sha256', 'bytes', 'created'], errorStatuses: ['denied', 'failed']
 });
 
 export const hostExecOutputSchema = z.strictObject({
@@ -265,4 +267,4 @@ export function structuredToolResult(schema, object, isError = false) {
     structuredContent: parsed.data,
     content: [{ type: 'text', text: JSON.stringify(parsed.data) }]
   };
-}
+}

package/src/process-smoke-client.mjs

@@ -8,6 +8,7 @@ import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotoc
 import { canonicalJson } from './canonical-json.mjs';
 import { loadProcessPolicy, PROCESS_GRANT_SCHEMA } from './process-policy.mjs';
 import { generateTrustKeypair, loadPublicVerifyKey } from './trust.mjs';
+import { assertExactCatalog, expectedFullCatalogForEnv } from './runtime-catalog-expectation.mjs';
 
 const EVENT_DOMAIN = Buffer.from('DEADBYTE-PROCESS-EVENT-V1\0', 'utf8');
 const ZERO_SHA256 = '0'.repeat(64);
@@ -58,9 +59,8 @@ try {
   await client.connect(transport);
   const listed = await client.listTools();
   const names = listed.tools.map(tool => tool.name).sort();
-  const expected = ['contained_transform','evidence_verify','file_read','proof_execute','skill_catalog','workspace_open',
-    'process_session_action','process_session_cancel','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate','process_session_write'].sort();
-  if (JSON.stringify(names) !== JSON.stringify(expected)) throw new Error(`process smoke catalog mismatch: ${JSON.stringify(names)}`);
+  const expected = await expectedFullCatalogForEnv({DEADBYTE_PROCESS_RUNTIME:'1'});
+  assertExactCatalog(names,expected,'process smoke');
   const started = structured(await client.callTool({ name: 'process_session_start', arguments: {
     profile_id: 'ping_hold', root_id: 'core', cwd: '.', args: []
   } }), 'process_session_start');

package/src/runtime-catalog-expectation.mjs

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { R36_CAPABILITY_LEDGER } from './capability-ledger.mjs';
+
+const packageRoot=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const catalogPath=path.join(packageRoot,'docs','R48-FULL-TOOL-CATALOG.json');
+const AGENT_TOOLS=new Set(['agent_task_approve','agent_task_cancel','agent_task_events','agent_task_run','agent_task_status','agent_task_submit','agent_task_verify']);
+
+export async function expectedFullCatalogForEnv(env){
+  const canonical=JSON.parse(await readFile(catalogPath,'utf8'));
+  if(canonical.schema!=='deadbyte.r48-full-catalog.v1'||canonical.tool_count!==canonical.tools?.length) throw new Error('canonical R48 full catalog is invalid');
+  const disabled=new Set();
+  for(const capability of R36_CAPABILITY_LEDGER.entries){
+    const flag=capability.runtime_flag;
+    const enabled=flag===null||(flag==='DEADBYTE_PRIVILEGED_POLICY'?Boolean(env[flag]):env[flag]==='1');
+    if(!enabled) disabled.add(capability.full_tool);
+  }
+  // The rename preview tool is registered by the coding surface even when its
+  // optional Native Diff backend is absent; only the apply path needs Autonomous.
+  if(env.DEADBYTE_CODING_RUNTIME==='1') disabled.delete('coding_symbol_rename_preview');
+  if(env.DEADBYTE_AGENT_RUNTIME!=='1') for(const name of AGENT_TOOLS) disabled.add(name);
+  if(env.DEADBYTE_PROCESS_RUNTIME!=='1') disabled.add('process_session_cancel');
+  return canonical.tools.filter(name=>!disabled.has(name));
+}
+
+export function assertExactCatalog(actual,expected,label='MCP'){
+  const names=[...actual].sort((a,b)=>a.localeCompare(b,'en'));
+  const wanted=[...expected].sort((a,b)=>a.localeCompare(b,'en'));
+  if(JSON.stringify(names)!==JSON.stringify(wanted)){
+    const actualSet=new Set(names); const expectedSet=new Set(wanted);
+    const missing=wanted.filter(name=>!actualSet.has(name));
+    const unexpected=names.filter(name=>!expectedSet.has(name));
+    throw new Error(`${label} catalog mismatch: missing=${JSON.stringify(missing)} unexpected=${JSON.stringify(unexpected)}`);
+  }
+  return names;
+}

package/src/stdio-protocol-guard.mjs

@@ -0,0 +1,71 @@
+import { deserializeMessage, STDIO_DEFAULT_MAX_BUFFER_SIZE } from '@modelcontextprotocol/server';
+import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
+
+const JSON_RPC_PARSE_ERROR=-32700;
+const JSON_RPC_INVALID_REQUEST=-32600;
+
+class StrictStdioReadBuffer {
+  constructor({maxBufferSize=STDIO_DEFAULT_MAX_BUFFER_SIZE}={}){
+    this._buffer=undefined;
+    this._maxBufferSize=maxBufferSize;
+  }
+
+  append(chunk){
+    if((this._buffer?.length??0)+chunk.length>this._maxBufferSize){
+      this.clear();
+      throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+    }
+    this._buffer=this._buffer?Buffer.concat([this._buffer,chunk]):chunk;
+  }
+
+  readMessage(){
+    if(!this._buffer) return null;
+    const index=this._buffer.indexOf('\n');
+    if(index===-1) return null;
+    const line=this._buffer.toString('utf8',0,index).replace(/\r$/,'');
+    this._buffer=this._buffer.subarray(index+1);
+    return deserializeMessage(line);
+  }
+
+  clear(){
+    this._buffer=undefined;
+  }
+}
+
+function decodeErrorReply(error){
+  if(error instanceof SyntaxError){
+    return {code:JSON_RPC_PARSE_ERROR,message:'Parse error'};
+  }
+  if(error?.name==='ZodError'){
+    return {code:JSON_RPC_INVALID_REQUEST,message:'Invalid Request'};
+  }
+  return null;
+}
+
+export class DeadbyteStdioServerTransport extends StdioServerTransport {
+  constructor(stdin,stdout,options){
+    super(stdin,stdout,options);
+    this._readBuffer=new StrictStdioReadBuffer({maxBufferSize:options?.maxBufferSize});
+  }
+
+  processReadBuffer(){
+    while(true){
+      try{
+        const message=this._readBuffer.readMessage();
+        if(message===null) break;
+        this.onmessage?.(message);
+      }catch(error){
+        const reply=decodeErrorReply(error);
+        if(reply){
+          void this.send({
+            jsonrpc:'2.0',
+            id:null,
+            error:reply
+          }).catch(sendError=>this.onerror?.(sendError));
+          continue;
+        }
+        this.onerror?.(error);
+      }
+    }
+  }
+}

package/src/tunnel-stdio-compat-smoke.mjs

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Client } from '@modelcontextprotocol/client';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { assertExactCatalog, expectedFullCatalogForEnv } from './runtime-catalog-expectation.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(here, '..');
@@ -11,6 +12,7 @@ const workspaceRoot = path.join(repoRoot, 'workspaces');
 const baseEnv = {
   ...process.env,
   DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
+  DEADBYTE_PRIVILEGED_POLICY: '',
   DEADBYTE_TUNNEL_STDIO_PROBE_COMPAT: '1'
 };
 
@@ -100,6 +102,7 @@ async function modernPassThrough() {
     env: {
       ...getDefaultEnvironment(),
       DEADBYTE_WORKSPACE_ROOT: workspaceRoot,
+      DEADBYTE_PRIVILEGED_POLICY: '',
       DEADBYTE_TUNNEL_STDIO_PROBE_COMPAT: '1'
     },
     stderr: 'pipe'
@@ -112,15 +115,8 @@ async function modernPassThrough() {
     if (era !== 'modern') throw new Error(`expected modern era through compat prefilter, got ${String(era)}`);
     const listed = await client.listTools();
     const names = listed.tools.map(tool => tool.name).sort();
-    const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'skill_catalog', 'workspace_open'];
-    const privilegedTools = ['host_exec', 'host_file_read', 'host_file_write'];
-    const allowedCatalogs = [
-      baseTools,
-      [...baseTools, ...privilegedTools]
-    ].map(items => [...items].sort());
-    if (!allowedCatalogs.some(expected => JSON.stringify(names) === JSON.stringify(expected))) {
-      throw new Error(`modern catalog changed through compat prefilter: ${JSON.stringify(names)}`);
-    }
+    const expected=await expectedFullCatalogForEnv({});
+    assertExactCatalog(names,expected,'modern tunnel compatibility');
     return { protocol_revision: '2026-07-28', protocol_era: era, tools: names };
   } catch (error) {
     const stderr = Buffer.concat(serverStderr).toString('utf8').trim();

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.23';
+export const DEADBYTE_VERSION = '0.15.25';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';