deadbyte-mcp 0.15.23 → 0.15.25

package/test/atomic-mutation.test.mjs

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {atomicMutation} from '../src/atomic-mutation.mjs';
+
+const digest=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+test('post-rename observation failure is explicit unknown effect and committed bytes are not replayed',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-atomic-unknown-'));
+  const target=path.join(root,'value.txt');
+  await writeFile(target,'old');
+  let reads=0;
+  const readState=async file=>{
+    reads++;
+    if(reads===3)throw new Error('injected post-rename observation loss');
+    const bytes=await readFile(file);
+    return {exists:true,sha256:digest(bytes)};
+  };
+  try{
+    const error=await atomicMutation({
+      target,bytes:Buffer.from('new'),expected:digest(Buffer.from('old')),readState,
+      assertExpected(state,expected){assert.equal(state.sha256,expected);}
+    }).then(()=>null,error=>error);
+    assert.equal(error?.outcome,'FAILED_AFTER_UNKNOWN_EFFECT');
+    assert.equal(error?.side_effect_state,'unknown');
+    assert.equal(error?.expected_after_sha256,digest(Buffer.from('new')));
+    assert.equal(await readFile(target,'utf8'),'new');
+    assert.equal(reads,3);
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('pre-effect authority denial remains failed-before-effect',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-atomic-before-'));
+  const target=path.join(root,'value.txt');await writeFile(target,'old');
+  const readState=async file=>{const bytes=await readFile(file);return {exists:true,sha256:digest(bytes)};};
+  try{
+    const error=await atomicMutation({target,bytes:Buffer.from('new'),expected:digest(Buffer.from('old')),readState,
+      assertExpected(state,expected){assert.equal(state.sha256,expected);},authorityCheck:async()=>{throw new Error('revoked');}
+    }).then(()=>null,error=>error);
+    assert.equal(error.message,'revoked');
+    assert.equal(error.side_effect_state,undefined);
+    assert.equal(await readFile(target,'utf8'),'old');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('postcondition verifier loss after exact commit is explicit unknown effect',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-atomic-verify-'));
+  const target=path.join(root,'value.txt');await writeFile(target,'old');
+  const readState=async file=>{const bytes=await readFile(file);return {exists:true,sha256:digest(bytes)};};
+  try{
+    const error=await atomicMutation({target,bytes:Buffer.from('new'),expected:digest(Buffer.from('old')),readState,
+      assertExpected(state,expected){assert.equal(state.sha256,expected);},verifyPostcondition:async()=>{throw new Error('verifier lost');}
+    }).then(()=>null,error=>error);
+    assert.equal(error.outcome,'FAILED_AFTER_UNKNOWN_EFFECT');
+    assert.equal(error.side_effect_state,'unknown');
+    assert.equal(await readFile(target,'utf8'),'new');
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/coding-catalog-consistency.test.mjs

@@ -16,9 +16,17 @@ function extract(source){
   assert.ok(m,'coding catalog array missing');
   return [...m[1].matchAll(/'([^']+)'/g)].map(x=>x[1]).sort();
 }
-for(const rel of ['src/machine-fs-smoke-client.mjs','src/observation-smoke-client.mjs','src/remote-mcp-coding-smoke-client.mjs','src/remote-mcp-smoke-client.mjs']){
+for(const rel of ['src/remote-mcp-coding-smoke-client.mjs','src/remote-mcp-smoke-client.mjs']){
   test(`${rel} uses the exact R36 25-tool coding catalog`,async()=>{
     const source=await readFile(path.join(root,...rel.split('/')),'utf8');
     assert.deepEqual(extract(source),expected);
   });
 }
+for(const rel of ['src/machine-fs-smoke-client.mjs','src/observation-smoke-client.mjs']){
+  test(`${rel} derives its exact R48 catalog from the canonical runtime catalog`,async()=>{
+    const source=await readFile(path.join(root,...rel.split('/')),'utf8');
+    assert.match(source,/expectedFullCatalogForEnv/);
+    assert.match(source,/assertExactCatalog/);
+    assert.doesNotMatch(source,/const (?:codingTools|coding)\s*=\s*\[/);
+  });
+}

package/test/coding-mcp-unknown-effect.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { registerCodingTools } from '../src/coding-mcp-tools.mjs';
+
+class FakeServer {
+  constructor() { this.tools = new Map(); }
+  registerTool(name, spec, handler) { this.tools.set(name, { spec, handler }); }
+}
+
+function unknownEffectError() {
+  const error = new Error('post-commit verification unavailable');
+  error.outcome = 'FAILED_AFTER_UNKNOWN_EFFECT';
+  error.side_effect_state = 'unknown';
+  error.expected_after_sha256 = 'a'.repeat(64);
+  return error;
+}
+
+test('coding mutation uncertainty survives the public structured error boundary', async () => {
+  const server = new FakeServer();
+  registerCodingTools(server, {
+    codingRuntime: { async fileWrite() { throw unknownEffectError(); } },
+    taskRuntime: {},
+    semanticRuntime: {}
+  });
+
+  const response = await server.tools.get('coding_file_write').handler({
+    root_id: 'core',
+    path: 'a.txt',
+    content: 'x',
+    encoding: 'utf8',
+    expected_sha256: 'absent'
+  });
+
+  assert.equal(response.isError, true);
+  assert.deepEqual(response.structuredContent, {
+    status: 'failed',
+    error: 'Error: post-commit verification unavailable',
+    outcome: 'FAILED_AFTER_UNKNOWN_EFFECT',
+    side_effect_state: 'unknown',
+    expected_after_sha256: 'a'.repeat(64)
+  });
+});

package/test/commander-biff-reference-r48.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {createRequire} from 'node:module';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+const oracleRoot='C:\\Users\\DEADBYTE\\.deadbyte-mcp\\evidence\\commander-biff-oracle';
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+test('pinned reference rejects a real BIFF8 workbook and writes OOXML bytes under .xls',async()=>{
+  const require=createRequire(import.meta.url);
+  const XLSX=require(path.join(oracleRoot,'node_modules','xlsx'));
+  const workbook=XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook,XLSX.utils.aoa_to_sheet([['name','value'],['alpha',42]]),'Data');
+  const biff=Buffer.from(XLSX.write(workbook,{type:'buffer',bookType:'biff8'}));
+  assert.equal(biff.subarray(0,8).toString('hex'),'d0cf11e0a1b11ae1');
+  assert.equal(biff.length,3584);
+  assert.equal(sha256(biff),'096168376d0abf282546749fdf6765309f895d12fe81d45c52a2c54bb6c0d139');
+
+  const ExcelJS=require(path.join(oracleRoot,'node_modules','exceljs'));
+  const temp=await mkdtemp(path.join(os.tmpdir(),'deadbyte-biff-reference-'));
+  try{
+    const input=path.join(temp,'real-biff8.xls');
+    await writeFile(input,biff);
+    const reader=new ExcelJS.Workbook();
+    await assert.rejects(()=>reader.xlsx.readFile(input),/central directory|zip file/i);
+
+    const output=path.join(temp,'reference-output.xls');
+    const writer=new ExcelJS.Workbook();
+    writer.addWorksheet('Sheet1').addRows([['name','value'],['alpha',42]]);
+    await writer.xlsx.writeFile(output);
+    const emitted=await readFile(output);
+    assert.equal(emitted.subarray(0,2).toString('ascii'),'PK');
+    assert.notEqual(emitted.subarray(0,8).toString('hex'),'d0cf11e0a1b11ae1');
+  }finally{await rm(temp,{recursive:true,force:true});}
+});

package/test/commander-core-bridge-r47.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { registerCommanderCoreBridge } from '../src/commander-core-bridge.mjs';
+import { createDocxBytes } from '../src/commander-office-reader-r48.mjs';
 
 test('search adapter drains bounded native pages instead of silently losing later matches',async()=>{
  const tools=new Map(), cursors=[];
@@ -58,3 +59,21 @@ test('search adapter timeout aborts native work, completes cleanly, and rejects
  page=await tools.get('get_more_search_results').handler({sessionId:started.sessionId,offset:0,length:100});
  assert.equal(page.results.length,0);
 });
+
+test('search adapter natively searches DOCX document and header parts when the reference file pattern enables it',async()=>{
+ const tools=new Map(),doc=createDocxBytes('Needle body').bytes;
+ const machineFsRuntime={
+  policy:{roots:{project:{real_path:'D:\\RDC'}},max_read_bytes:64*1024*1024},
+  async list(){return {entries:[{path:'sample.docx',kind:'file'}],next_cursor:null};},
+  async read(){return {data_base64:doc.toString('base64'),file_sha256:'a'.repeat(64),eof:true};}
+ };
+ const searchRuntime=async()=>({matches:[],next_cursor:null});
+ registerCommanderCoreBridge({registerTool(name,config,handler){tools.set(name,{config,handler});}},{searchRuntime,machineFsRuntime});
+ const started=await tools.get('start_search').handler({path:'D:\\RDC',pattern:'needle',searchType:'content',ignoreCase:true,literalSearch:true,filePattern:'*.docx',maxResults:10});
+ let page;
+ for(let i=0;i<20;i++){page=await tools.get('get_more_search_results').handler({sessionId:started.sessionId,offset:0,length:10});if(page.isComplete)break;await new Promise(r=>setTimeout(r,1));}
+ assert.equal(page.isError,false,page.error);
+ assert.equal(page.totalResults,1);
+ assert.match(page.results[0].file,/sample\.docx$/);
+ assert.equal(page.results[0].match,'Needle body');
+});

package/test/commander-office-reader-r48.test.mjs

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { readDocxBytes, editDocxBytes, readXlsxBytes, editXlsxBytes, createXlsxBytes, appendXlsxBytes } from '../src/commander-office-reader-r48.mjs';
+import { readDocxBytes, searchDocxTextBytes, editDocxBytes, readXlsxBytes, editXlsxBytes, createXlsxBytes, appendXlsxBytes } from '../src/commander-office-reader-r48.mjs';
 
 function crc32(buf){
   let c=0xffffffff;
@@ -29,7 +29,9 @@ function zipStored(entries){
 }
 
 const DOCX=zipStored({
-  'word/document.xml':'<?xml version="1.0"?><w:document xmlns:w="x"><w:body><w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>Hello &amp; world</w:t></w:r></w:p><w:p><w:r><w:t>Second</w:t></w:r><w:tab/><w:r><w:t>line</w:t></w:r></w:p><w:tbl><w:tr><w:tc><w:p><w:r><w:t>A</w:t></w:r></w:p></w:tc><w:tc><w:p><w:r><w:t>B</w:t></w:r></w:p></w:tc></w:tr></w:tbl></w:body></w:document>'
+  'word/document.xml':'<?xml version="1.0"?><w:document xmlns:w="x"><w:body><w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>Hello &amp; world</w:t></w:r></w:p><w:p><w:r><w:t>Second</w:t></w:r><w:tab/><w:r><w:t>line</w:t></w:r></w:p><w:p><w:r><w:t>Caption</w:t></w:r><w:drawing/></w:p><w:tbl><w:tr><w:tc><w:p><w:r><w:t>A</w:t></w:r></w:p></w:tc><w:tc><w:p><w:r><w:t>B</w:t></w:r></w:p></w:tc></w:tr></w:tbl></w:body></w:document>',
+  'word/header1.xml':'<w:hdr xmlns:w="x"><w:p><w:r><w:t>Header text</w:t></w:r></w:p></w:hdr>',
+  'word/footer1.xml':'<w:ftr xmlns:w="x"><w:p><w:r><w:t>Footer text</w:t></w:r></w:p></w:ftr>'
 });
 
 const XLSX=zipStored({
@@ -47,12 +49,26 @@ test('R48 native DOCX reader produces text-bearing outline and paged raw XML',()
   assert.match(outline.content,/Second\tline/);
   assert.match(outline.content,/w:tbl/);
   assert.match(outline.content,/A \| B/);
+  assert.match(outline.content,/drawing\/image/);
+  assert.match(outline.content,/Headers\/Footers:/);
+  assert.match(outline.content,/header1\.xml: "Header text"/);
+  assert.match(outline.content,/footer1\.xml: "Footer text"/);
   const raw=readDocxBytes(DOCX,{path:'demo.docx',offset:1,length:3});
   assert.equal(raw.mimeType,'application/xml');
   assert.match(raw.content,/\[DOCX XML: lines 1-/);
   assert.equal(raw.metadata.isDocx,true);
 });
 
+test('R48 native DOCX search covers document headers and footers with literal bounded semantics',()=>{
+  assert.deepEqual(searchDocxTextBytes(DOCX,{pattern:'text',ignoreCase:true,maxResults:10}),[
+    {part:'word/footer1.xml',line:1,match:'Footer text'},
+    {part:'word/header1.xml',line:1,match:'Header text'}
+  ]);
+  assert.deepEqual(searchDocxTextBytes(DOCX,{pattern:'Hello & world',ignoreCase:false,maxResults:1}),[
+    {part:'word/document.xml',line:1,match:'Hello & world'}
+  ]);
+});
+
 test('R48 native XLSX reader preserves types, sheet selection, A1 range, and row pagination',()=>{
   const range=readXlsxBytes(XLSX,{path:'book.xlsx',sheet:'Data',range:'A1:B2',offset:0,length:100});
   assert.deepEqual(range.data,[['Name','Count'],['Alpha',42]]);

package/test/commander-pdf-r48.test.mjs

@@ -5,6 +5,41 @@ import path from 'node:path';
 import {pathToFileURL} from 'node:url';
 import { createDeadbytePdf, parseDeadbytePdf, editDeadbytePdf, readPdfText } from '../src/commander-pdf-r48.mjs';
 
+function incrementalPdf(){
+  const nl='\n',objects=new Map([
+    [1,'<< /Type /Catalog /Pages 2 0 R >>'],
+    [2,'<< /Type /Pages /Kids [3 0 R] /Count 1 >>'],
+    [3,'<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 300] /Contents 4 0 R >>'],
+    [4,'<< /Length 20 >>\nstream\nBT (old) Tj ET\nendstream']
+  ]);
+  let out=`%PDF-1.4${nl}`,offsets=[];
+  for(const [id,body] of objects){offsets[id]=Buffer.byteLength(out,'latin1');out+=`${id} 0 obj${nl}${body}${nl}endobj${nl}`;}
+  const baseXref=Buffer.byteLength(out,'latin1');
+  out+=`xref${nl}0 5${nl}0000000000 65535 f ${nl}`;
+  for(let id=1;id<=4;id++)out+=`${String(offsets[id]).padStart(10,'0')} 00000 n ${nl}`;
+  out+=`trailer${nl}<< /Size 5 /Root 1 0 R >>${nl}startxref${nl}${baseXref}${nl}%%EOF${nl}`;
+  const revisedPage=Buffer.byteLength(out,'latin1');
+  out+=`3 0 obj${nl}<< /Type /Page /Parent 2 0 R /MediaBox [0 0 321 456] /Contents 5 0 R >>${nl}endobj${nl}`;
+  const newContent=Buffer.byteLength(out,'latin1');
+  out+=`5 0 obj${nl}<< /Length 20 >>${nl}stream${nl}BT (new) Tj ET${nl}endstream${nl}endobj${nl}`;
+  const incrementalXref=Buffer.byteLength(out,'latin1');
+  out+=`xref${nl}3 1${nl}${String(revisedPage).padStart(10,'0')} 00000 n ${nl}5 1${nl}${String(newContent).padStart(10,'0')} 00000 n ${nl}`;
+  out+=`trailer${nl}<< /Size 6 /Root 1 0 R /Prev ${baseXref} >>${nl}startxref${nl}${incrementalXref}${nl}%%EOF${nl}`;
+  return Buffer.from(out,'latin1');
+}
+
+test('R48 valid incremental update selects the latest object revision and survives oracle reload',async()=>{
+  const oracle=process.env.DEADBYTE_PDF_TEST_ORACLE??path.join(os.homedir(),'.deadbyte-mcp','evidence','commander-oracle','node_modules','pdf-lib','cjs','index.js');
+  const {PDFDocument}=await import(pathToFileURL(oracle).href);
+  const fixture=incrementalPdf();
+  const loaded=await PDFDocument.load(fixture);
+  assert.equal(loaded.getPage(0).getWidth(),321);
+  assert.match(readPdfText(fixture).pages[0],/new/);
+  const edited=await editDeadbytePdf(fixture,[]);
+  const reloaded=await PDFDocument.load(edited.bytes);
+  assert.equal(reloaded.getPage(0).getWidth(),321);
+});
+
 test('R48 ordinary PDF with compressed object streams preserves pages through independent oracle reload',async()=>{
   const oracle=process.env.DEADBYTE_PDF_TEST_ORACLE??path.join(os.homedir(),'.deadbyte-mcp','evidence','commander-oracle','node_modules','pdf-lib','cjs','index.js');
   const {PDFDocument}=await import(pathToFileURL(oracle).href);

package/test/commander-protocol-adversarial-r48.test.mjs

@@ -0,0 +1,166 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+
+function isolatedEnv(){
+  return {
+    ...getDefaultEnvironment(),
+    DEADBYTE_MACHINE_RUNTIME:'0',
+    DEADBYTE_MACHINE_FS_RUNTIME:'0',
+    DEADBYTE_OBSERVATION_RUNTIME:'0',
+    DEADBYTE_CODING_RUNTIME:'0',
+    DEADBYTE_PROCESS_RUNTIME:'0',
+    DEADBYTE_AUTONOMOUS_RUNTIME:'0',
+    DEADBYTE_DESKTOP_RUNTIME:'0',
+    DEADBYTE_AUDIT_RUNTIME:'0'
+  };
+}
+
+async function fixture(){
+  const child=spawn(process.execPath,[serverPath],{
+    cwd:repoRoot,
+    env:isolatedEnv(),
+    stdio:['pipe','pipe','pipe'],
+    windowsHide:true
+  });
+
+  const messages=[];
+  let stdoutBuffer='';
+  let stderr='';
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  child.stdout.on('data',chunk=>{
+    stdoutBuffer+=chunk;
+    const lines=stdoutBuffer.split('\n');
+    stdoutBuffer=lines.pop()??'';
+    for(const line of lines){
+      if(!line.trim()) continue;
+      try{ messages.push(JSON.parse(line)); }
+      catch{ messages.push({__raw:line}); }
+    }
+  });
+  child.stderr.on('data',chunk=>{
+    if(stderr.length<65536) stderr+=chunk;
+  });
+
+  const meta={
+    'io.modelcontextprotocol/protocolVersion':'2026-07-28',
+    'io.modelcontextprotocol/clientInfo':{name:'deadbyte-protocol-adversarial-r48',version:'0.15.23'},
+    'io.modelcontextprotocol/clientCapabilities':{}
+  };
+  const request=(id,method,params={})=>({jsonrpc:'2.0',id,method,params:{...params,_meta:meta}});
+  const send=value=>{
+    assert.equal(child.exitCode,null,`server exited before send: ${stderr}`);
+    child.stdin.write(typeof value==='string'?value+'\n':JSON.stringify(value)+'\n');
+  };
+  const waitFor=async(predicate,timeoutMs=5000)=>{
+    const deadline=Date.now()+timeoutMs;
+    while(Date.now()<deadline){
+      const found=messages.find(predicate);
+      if(found) return found;
+      if(child.exitCode!==null) assert.fail(`server exited code=${child.exitCode}; stderr=${stderr}; messages=${JSON.stringify(messages)}`);
+      await new Promise(resolve=>setTimeout(resolve,10));
+    }
+    assert.fail(`timed out waiting for raw protocol response; stderr=${stderr}; messages=${JSON.stringify(messages)}`);
+  };
+  const close=async()=>{
+    if(child.exitCode!==null) return;
+    try{ child.stdin.end(); }catch{}
+    await Promise.race([
+      new Promise(resolve=>child.once('close',resolve)),
+      new Promise(resolve=>setTimeout(resolve,500))
+    ]);
+    if(child.exitCode===null){
+      try{ child.kill(); }catch{}
+      await Promise.race([
+        new Promise(resolve=>child.once('close',resolve)),
+        new Promise(resolve=>setTimeout(resolve,500))
+      ]);
+    }
+  };
+
+  send(request(1,'tools/list'));
+  const pinned=await waitFor(message=>message?.id===1);
+  assert.equal(pinned.error,undefined,JSON.stringify(pinned));
+  assert.ok(Array.isArray(pinned.result?.tools));
+  messages.length=0;
+
+  return {child,messages,request,send,waitFor,close};
+}
+
+test('R48 raw stdio returns JSON-RPC parse error and remains usable after malformed JSON',async()=>{
+  const f=await fixture();
+  try{
+    f.send('{"jsonrpc":"2.0","id":700,"method":');
+    const parseError=await f.waitFor(message=>message?.error?.code===-32700);
+    assert.equal(parseError.jsonrpc,'2.0');
+    assert.equal(parseError.id,null);
+    assert.equal(parseError.error.message,'Parse error');
+
+    f.send(f.request(701,'tools/list'));
+    const control=await f.waitFor(message=>message?.id===701);
+    assert.equal(control.error,undefined,JSON.stringify(control));
+    assert.ok(Array.isArray(control.result?.tools));
+    assert.equal(f.child.exitCode,null);
+  }finally{
+    await f.close();
+  }
+});
+
+test('R48 raw stdio returns Invalid Request for valid JSON outside MCP message schema and remains usable',async()=>{
+  const f=await fixture();
+  try{
+    f.send({jsonrpc:'2.0',id:710,params:{}});
+    const invalid=await f.waitFor(message=>message?.error?.code===-32600);
+    assert.equal(invalid.jsonrpc,'2.0');
+    assert.equal(invalid.id,null);
+    assert.equal(invalid.error.message,'Invalid Request');
+
+    f.send(f.request(711,'prompts/list'));
+    const control=await f.waitFor(message=>message?.id===711);
+    assert.equal(control.error,undefined,JSON.stringify(control));
+    assert.ok(Array.isArray(control.result?.prompts));
+    assert.equal(f.child.exitCode,null);
+  }finally{
+    await f.close();
+  }
+});
+
+test('R48 raw stdio preserves method/tool errors and request correlation under duplicate/concurrent ids',async()=>{
+  const f=await fixture();
+  try{
+    f.send(f.request(720,'deadbyte/unknown'));
+    f.send(f.request(721,'tools/call',{name:'definitely_missing_tool',arguments:{}}));
+    f.send(f.request(722,'tools/list'));
+    f.send(f.request(722,'prompts/list'));
+    f.send(f.request(723,'resources/list'));
+    f.send(f.request(724,'prompts/list'));
+
+    const unknownMethod=await f.waitFor(message=>message?.id===720);
+    assert.equal(unknownMethod.error?.code,-32601);
+
+    const unknownTool=await f.waitFor(message=>message?.id===721);
+    assert.equal(unknownTool.error?.code,-32602);
+
+    await f.waitFor(()=>f.messages.filter(message=>message?.id===722).length===2);
+    const duplicate=f.messages.filter(message=>message?.id===722);
+    assert.equal(duplicate.length,2);
+    assert.equal(duplicate.some(message=>Array.isArray(message.result?.tools)),true);
+    assert.equal(duplicate.some(message=>Array.isArray(message.result?.prompts)),true);
+
+    const resources=await f.waitFor(message=>message?.id===723);
+    const prompts=await f.waitFor(message=>message?.id===724);
+    assert.ok(Array.isArray(resources.result?.resources));
+    assert.ok(Array.isArray(prompts.result?.prompts));
+    assert.equal(f.child.exitCode,null);
+  }finally{
+    await f.close();
+  }
+});

package/test/commander-real-parity-r47.test.mjs

@@ -9,6 +9,7 @@ import { loadCodingPolicy } from '../src/coding-plane.mjs';
 import { createMachineFsRuntime, verifyMachineFsReceiptFile } from '../src/machine-fs.mjs';
 import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
 import { createProcessRuntime } from '../src/process-runtime.mjs';
+import { createCommanderWireAdapter } from '../src/commander-wire-adapter-r47.mjs';
 
 const sha=b=>createHash('sha256').update(b).digest('hex');
 const sleep=ms=>new Promise(r=>setTimeout(r,ms));
@@ -31,15 +32,17 @@ async function processFixture(){
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-commander-real-process-'));
   const project=path.join(root,'project'),trust=path.join(root,'trust'); await mkdir(project); await mkdir(trust);
   const host=path.resolve('bin/deadbyte-process-host.exe'), exe='C:\\Windows\\System32\\cmd.exe';
-  const h=sha(await readFile(host)), e=sha(await readFile(exe));
+  const powershell='C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+  const h=sha(await readFile(host)), e=sha(await readFile(exe)),ps=sha(await readFile(powershell));
   const grantFile=path.join(root,'grant.json'), stateDir=path.join(root,'state'), policyPath=path.join(root,'policy.json');
   await writeFile(policyPath,JSON.stringify({schema:PROCESS_POLICY_SCHEMA,enabled:true,grant_file:grantFile,state_dir:stateDir,
     native_host:{path:host,sha256:h},roots:{core:{path:project,deny_paths:[]}},profiles:{
       echo:{executable:exe,executable_sha256:e,root_ids:['core'],prefix_args:['/d','/c'],max_args:4,max_arg_bytes:256,max_sessions:2,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}},
-      hold:{executable:exe,executable_sha256:e,root_ids:['core'],transport:'pipe',prefix_args:['/d','/q'],max_args:0,max_arg_bytes:256,max_sessions:2,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}
+      hold:{executable:exe,executable_sha256:e,root_ids:['core'],transport:'pipe',prefix_args:['/d','/q'],max_args:0,max_arg_bytes:256,max_sessions:2,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}},
+      powershell_repl:{executable:powershell,executable_sha256:ps,root_ids:['core'],transport:'pipe',prefix_args:['-NoLogo','-NoProfile','-NonInteractive','-Command','-'],allow_raw_input:true,max_args:0,max_arg_bytes:256,max_sessions:2,max_input_bytes:8192,max_retained_output_bytes:2*1024*1024,env_allow:['PATH','TEMP','TMP'],input_actions:{}}
     }}));
   const policy=await loadProcessPolicy(policyPath);
-  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'a'.repeat(64),profile_ids:['echo','hold'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
+  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'a'.repeat(64),profile_ids:['echo','hold','powershell_repl'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
   const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
   return {root,policy,keys,runtime:createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
 }
@@ -59,10 +62,45 @@ test('real Commander-parity filesystem lifecycle is transactional and signed',as
     assert.equal(m.status,'committed'); assert.equal(final.sha256,w.sha256); assert.equal(proof.ok,true);
     assert.deepEqual(page.entries.map(x=>x.path),['x/a.txt']);
     assert.equal(Buffer.from(r.data_base64,'base64').toString(),'alpha');
+    const adapter=createCommanderWireAdapter({machineFsRuntime:f.runtime});
+    const directory=await adapter.handlers.read_file({path:path.join(f.project,'x'),isUrl:false,offset:0,length:100});
+    assert.equal(directory.structuredContent.isDirectory,true);
+    assert.match(directory.structuredContent.content,/\[FILE\] b\.txt/);
+    assert.doesNotMatch(directory.structuredContent.content,/\[FILE\] x[\\/]b\.txt/);
     assert.ok(performance.now()-t0>=0);
   } finally { await rm(f.root,{recursive:true,force:true}); }
 });
 
+test('real Commander adapter preserves PowerShell command bytes through the bounded REPL', {skip:process.platform!=='win32'}, async()=>{
+  const f=await processFixture();
+  let adapter=null,pid=null;
+  try{
+    adapter=createCommanderWireAdapter({processRuntime:f.runtime});
+    const command=`[Console]::OutputEncoding=[Text.UTF8Encoding]::new(); $x='a b'; "DB:$x"; 'pipe' | ForEach-Object { "P:$_" }; "U:สวัสดี"`;
+    const started=await adapter.handlers.start_process({command,timeout_ms:10000});
+    pid=started.structuredContent.pid;
+    let output='';
+    for(let i=0;i<50&&!(output.includes('DB:a b')&&output.includes('P:pipe')&&output.includes('U:สวัสดี'));i++){
+      const page=await adapter.handlers.read_process_output({pid,offset:0,length:100,timeout_ms:100});
+      output+=page.content[0].text;
+    }
+    assert.match(output,/DB:a b/);
+    assert.match(output,/P:pipe/);
+    assert.match(output,/U:สวัสดี/);
+    const large=await adapter.handlers.interact_with_process({
+      pid,input:"[Console]::Out.Write(('X'*1100000)); [Console]::Out.WriteLine('END')",timeout_ms:10000,wait_for_prompt:true
+    });
+    const largeText=large.content[0].text;
+    assert.ok(Buffer.byteLength(largeText,'utf8')>1024*1024);
+    assert.match(largeText,/END/);
+    const ended=await adapter.handlers.force_terminate({pid});
+    assert.equal(ended.structuredContent.termination.verified,true);
+  }finally{
+    if(adapter&&pid!==null) await adapter.handlers.force_terminate({pid}).catch(()=>{});
+    await rm(f.root,{recursive:true,force:true});
+  }
+});
+
 test('real stale mutation is rejected before commit and leaves source intact',async()=>{
   const f=await fsFixture();
   try{

package/test/commander-schema-differential-r48.test.mjs

@@ -5,7 +5,7 @@ import {readFile} from 'node:fs/promises';
 import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
 import {registerCommanderExtendedBridge} from '../src/commander-extended-bridge-r47.mjs';
 
-const referencePath='D:\\Projects\\deadbyte-mcp\\desktop-commander\\dist\\tools\\schemas.js';
+const referencePath='D:\\Projects\\desktop-commander-stage-20260922\\desktop-commander\\dist\\tools\\schemas.js';
 const expectedHash='f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140';
 async function referenceSchemas(){
   let source=await readFile(referencePath,'utf8');

package/test/commander-wire-contract-r47.test.mjs

@@ -146,6 +146,38 @@ test('R48 RDC read_file preserves image/text wire behavior and natively reads DO
   assert.equal(withOptions.isError,undefined,JSON.stringify(withOptions));
   assert.deepEqual(withOptions.structuredContent.ignoredOptions,['includeImages','mode']);
 });
+
+test('R48 read_file preserves the reference directory-listing fallback',async()=>{
+  let reads=0;
+  const fs={
+    policy:{roots:{project:{real_path:'D:\\RDC-COMPAT-TEST'}},max_read_bytes:64*1024*1024},
+    async stat(){return {kind:'directory'};},
+    async list({relativePath}){return relativePath==='folder'?{entries:[
+      {path:'folder/a.txt',kind:'file'},
+      {path:'folder/nested',kind:'directory'}
+    ],next_cursor:null}:{entries:[{path:'folder/nested/b.txt',kind:'file'}],next_cursor:null};},
+    async read(){reads++;throw new Error('directory must not enter file read');}
+  };
+  const a=createCommanderWireAdapter({machineFsRuntime:fs});
+  const result=await a.handlers.read_file({path:'D:\\RDC-COMPAT-TEST\\folder',isUrl:false,offset:0,length:100});
+  assert.equal(reads,0);
+  assert.equal(result.structuredContent.isDirectory,true);
+  assert.equal(result.structuredContent.content,
+    'This is a directory, not a file. Use the list_directory tool instead of read_file for directories.\n\n[FILE] a.txt\n[DIR] nested\n[FILE] nested\\b.txt');
+});
+
+test('R48 read_file identifies unknown binary content instead of lossy UTF-8 decoding',async()=>{
+  const bytes=Buffer.from([0,255,1,2,0,3]);
+  const fs={
+    policy:{roots:{project:{real_path:'D:\\RDC-COMPAT-TEST'}},max_read_bytes:65536},
+    async read(){return {data_base64:bytes.toString('base64'),file_sha256:'9'.repeat(64),eof:true};}
+  };
+  const a=createCommanderWireAdapter({machineFsRuntime:fs});
+  const result=await a.handlers.read_file({path:'D:\\RDC-COMPAT-TEST\\payload.bin',isUrl:false,offset:0,length:100});
+  assert.equal(result.structuredContent.isBinary,true);
+  assert.match(result.structuredContent.content,/Cannot read binary file as text: payload\.bin/);
+  assert.doesNotMatch(result.structuredContent.content,/�/u);
+});
 test('R48 read_multiple_files reuses rich read_file semantics per path',async()=>{
   const multiPdf=createDeadbytePdf(['multi page']);
   const fs={

package/test/contained.test.mjs

@@ -456,13 +456,11 @@ test('receipt and verifier bind contained worker, launcher and independent trans
   assert.match(verifier, /contained transform semantic mismatch/);
 });
 
-test('MCP protocol smoke accepts only the base or base-plus-host catalog and excludes agent tools', async () => {
+test('MCP protocol smoke derives the exact full catalog and explicitly disables Host', async () => {
   const smoke = await readFile(fileURLToPath(new URL('../src/mcp-smoke-client.mjs', import.meta.url)), 'utf8');
-  for (const name of ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'workspace_open']) assert.match(smoke, new RegExp(name));
-  for (const name of ['host_exec', 'host_file_read', 'host_file_write']) assert.match(smoke, new RegExp(name));
-  assert.match(smoke, /allowedCatalogs/);
-  assert.match(smoke, /baseTools/);
-  assert.match(smoke, /privilegedTools/);
+  assert.match(smoke, /expectedFullCatalogForEnv/);
+  assert.match(smoke, /assertExactCatalog/);
+  assert.match(smoke, /DEADBYTE_PRIVILEGED_POLICY: ''/);
   assert.doesNotMatch(smoke, /agent_task_/);
 });
 

package/test/controller.test.mjs

@@ -83,7 +83,8 @@ test('controller keeps privileged policy optional and propagates it only to the
 test('Windows host policy bootstrap pins executables and creates only explicit local roots', async () => {
   const init = await readFile(fileURLToPath(new URL('../scripts/init-host-policy.ps1', import.meta.url)), 'utf8');
   assert.match(init, /deadbyte\.host-policy\.v2/);
-  assert.match(init, /Get-FileHash/);
+  assert.match(init, /System\.Security\.Cryptography\.SHA256/);
+  assert.match(init, /System\.IO\.File.*OpenRead/);
   assert.match(init, /powershell_script/);
   assert.match(init, /cmd_script/);
   assert.match(init, /node_script/);

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

@@ -49,3 +49,15 @@ test('R31 machine filesystem schemas expose root-relative IDs/preconditions only
   assert.equal(move.safeParse({ root_id:'core', source_path:'a', destination_path:'b', pid:1234, expected_source_identity:hex('a') }).success, false);
   assert.equal(del.safeParse({ root_id:'core', path:'a', expected_source_identity:hex('a') }).success, true);
 });
+
+test('post-effect mutation uncertainty survives the public structured error boundary',async()=>{
+  const server=new FakeServer(),fake=runtime();
+  fake.write=async()=>{const error=new Error('post-commit verifier lost');error.outcome='FAILED_AFTER_UNKNOWN_EFFECT';error.side_effect_state='unknown';error.expected_after_sha256=hex('e');throw error;};
+  registerMachineFsTools(server,{runtime:fake});
+  const result=await server.tools.get('machine_fs_write').handler({root_id:'core',path:'a.txt',content:'x',encoding:'utf8',expected_sha256:'absent'});
+  assert.equal(result.isError,true);
+  assert.equal(result.structuredContent.status,'failed');
+  assert.equal(result.structuredContent.outcome,'FAILED_AFTER_UNKNOWN_EFFECT');
+  assert.equal(result.structuredContent.side_effect_state,'unknown');
+  assert.equal(result.structuredContent.expected_after_sha256,hex('e'));
+});