deadbyte-mcp 0.15.22 → 0.15.24

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'));
+});

package/test/output-schema.test.mjs

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 import { Client } from '@modelcontextprotocol/client';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
 import { generateTrustKeypair } from '../src/trust.mjs';
-import { structuredToolResult, workspaceOpenOutputSchema } from '../src/output-contracts.mjs';
+import { hostFileWriteOutputSchema, structuredToolResult, workspaceOpenOutputSchema } from '../src/output-contracts.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(here, '..');
@@ -85,3 +85,22 @@ test('DEADBYTE validates structured output locally even on isError paths', () =>
     /DEADBYTE output contract violation/
   );
 });
+
+test('host mutation contract preserves explicit post-effect uncertainty', () => {
+  const expected = 'a'.repeat(64);
+  const parsed = hostFileWriteOutputSchema.parse({
+    status: 'failed',
+    error: 'post-commit observation failed',
+    outcome: 'FAILED_AFTER_UNKNOWN_EFFECT',
+    side_effect_state: 'unknown',
+    expected_after_sha256: expected
+  });
+  assert.equal(parsed.expected_after_sha256, expected);
+  assert.throws(() => hostFileWriteOutputSchema.parse({
+    status: 'failed',
+    error: 'post-commit observation failed',
+    outcome: 'FAILED_AFTER_UNKNOWN_EFFECT',
+    side_effect_state: 'unknown',
+    expected_after_sha256: 'not-a-hash'
+  }));
+});

package/test/r48-release-contract.test.mjs

@@ -6,37 +6,43 @@ import { DEADBYTE_VERSION } from '../src/version.mjs';
 const root=new URL('../',import.meta.url);
 const read=rel=>readFile(new URL(rel,root),'utf8');
 
-test('R48 0.15.22 successor binds active 0.15.21 parent and native Windows observation release evidence',async()=>{
-  const [pkg,lock,release,provenance]=await Promise.all([
+test('R48 0.15.24 successor binds exact active 0.15.23 parent and Commander differential evidence',async()=>{
+  const [pkg,lock,release,provenance,matrix]=await Promise.all([
     read('package.json').then(JSON.parse),
     read('package-lock.json').then(JSON.parse),
     read('RELEASE.json').then(JSON.parse),
-    read('PROVENANCE.json').then(JSON.parse)
+    read('PROVENANCE.json').then(JSON.parse),
+    read('TEST-MATRIX.json').then(JSON.parse)
   ]);
-  assert.equal(pkg.version,'0.15.22');
-  assert.equal(lock.version,'0.15.22');
-  assert.equal(lock.packages[''].version,'0.15.22');
-  assert.equal(DEADBYTE_VERSION,'0.15.22');
-  assert.equal(release.version,'0.15.22');
-  assert.equal(provenance.version,'0.15.22');
+  assert.equal(pkg.version,'0.15.24');
+  assert.equal(lock.version,'0.15.24');
+  assert.equal(lock.packages[''].version,'0.15.24');
+  assert.equal(DEADBYTE_VERSION,'0.15.24');
+  assert.equal(release.version,'0.15.24');
+  assert.equal(provenance.version,'0.15.24');
+  assert.equal(matrix.version,'0.15.24');
   assert.equal(release.train,'R48');
-  assert.equal(release.label,'NATIVE WINDOWS OBSERVATION + MACHINE FS RESILIENCE');
-  assert.equal(release.parent.release_id,'v0.15.21-7c2735e0b1c6cc8d');
-  assert.equal(release.parent.manifest_sha256,'7c2735e0b1c6cc8dac6581c47b6b557d8d0157a324b67efd4df058e67cdb289f');
-  assert.equal(release.parent.generation_manifest_sha256,'b376e7fc450f44edddb0d0e1d596014c463f603e4917c56a68906b7f66f99dc7');
-  assert.equal(release.source_predecessor.version,'0.15.21');
-  assert.equal(release.source_predecessor.tarball_sha256,'3439f5f4435632e4cde385a6937e3e3d2ffcfb777295dd56aafbf3b036be7493');
-  assert.equal(release.source_predecessor.manifest_file_sha256,'7c2735e0b1c6cc8dac6581c47b6b557d8d0157a324b67efd4df058e67cdb289f');
+  assert.equal(release.label,'COMMANDER DIFFERENTIAL + PROTOCOL HARDENING BASELINE');
+  assert.equal(release.parent.release_id,'v0.15.23-c97e3d21e792420e');
+  assert.equal(release.parent.manifest_sha256,'c97e3d21e792420ea90dada3c1360cd56e4c1f221daa86596d611b0d1ac351ec');
+  assert.equal(release.parent.generation_manifest_sha256,'4d2d3a4dc103576c39171c52db3436366e62d8b872bcafa4c55f2adb6d3a1126');
+  assert.equal(release.source_predecessor.version,'0.15.23');
+  assert.equal(release.source_predecessor.tarball_sha256,'8c8711805bd05b9d4f61a7c9e123d888eb65121a10c85247807a723154416af4');
+  assert.equal(release.source_predecessor.manifest_file_sha256,'c97e3d21e792420ea90dada3c1360cd56e4c1f221daa86596d611b0d1ac351ec');
   assert.equal(release.source_predecessor.reference_server_sha256,'dfc303bb7dd2e8d01debac50fc43bb8644d00089bffdf2887e149497cff8b305');
   assert.equal(release.source_predecessor.reference_schemas_sha256,'f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140');
   assert.equal(release.capabilities.full_tool_count,116);
-  assert.equal(release.capabilities.full_tool_catalog.path,'docs/R48-FULL-TOOL-CATALOG.json');
-  assert.deepEqual(release.capabilities.windows_queries,['registry','services','drivers','sockets','volumes','usb','wsl']);
-  assert.equal(release.capabilities.machine_fs_list_entry_fault_isolation,true);
-  assert.equal(release.capabilities.capability_manifest_authority_truth,true);
-  assert.equal(release.capabilities.capability_manifest_host_grant_truth,true);
+  assert.equal(release.capabilities.commander_incremental_pdf_revisions,true);
+  assert.equal(release.capabilities.commander_docx_header_footer_search,true);
+  assert.equal(release.capabilities.commander_directory_read_fallback,true);
+  assert.equal(release.capabilities.commander_binary_detection,true);
+  assert.equal(release.capabilities.commander_protocol_adversarial,true);
+  assert.equal(release.capabilities.atomic_mutation_unknown_effect,true);
   assert.equal(provenance.parent_release_id,release.parent.release_id);
   assert.equal(provenance.parent_manifest_sha256,release.parent.manifest_sha256);
   assert.equal(provenance.parent_generation_manifest_sha256,release.parent.generation_manifest_sha256);
   assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+  assert.equal(matrix.full_regression_partition_proof.files,211);
+  assert.equal(matrix.full_regression_partition_proof.fail,0);
+  assert.equal(matrix.full_regression_partition_proof.task_receipt_sha256,'7711039e4807f6c2af02bbda897d0032b067e0a6631f789fd3bf801258160d3f');
 });

package/test/remote-live-log-r37.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { createLiveTimelineTracker, formatRemoteLifecycle, formatRuntimeDiagnosticLine, summarizeLiveToolArgs, truncateUtf8 } from '../src/remote-live-log.mjs';
+import * as live from '../src/remote-live-log.mjs';
+const {createLiveTimelineTracker,formatRemoteLifecycle,formatRuntimeDiagnosticLine,summarizeLiveToolArgs,truncateUtf8}=live;
 
 test('R40 human live timeline suppresses noisy read request and emits one categorized terminal line',()=>{
   let now=1000;
@@ -43,7 +44,7 @@ test('R40 heartbeat burst folds repeated status calls instead of printing every
     else assert.match(line,/^📡  .*#39  machine_ping ×5  avg 3ms  ✓$/);
     now+=10;
   }
-  assert.match(tracker.summary(),/5 calls \| 0 errors .*folded 4 heartbeat lines.*machine_ping×5/);
+  assert.match(tracker.summary(),/5 calls \| 5 ok \| 0 errors \| 0 unknown \| 0 mutations .*folded 4 heartbeat lines.*machine_ping×5/);
 });
 
 test('R40 transport IN/OUT echo is hidden by default and available only in verbose diagnostics',()=>{
@@ -64,14 +65,19 @@ test('R40 interrupted spans remain correlated and session summary is available',
     args:{root_id:'core',path:'x.txt',content:'x'}},{sequence:50});
   const lines=tracker.reconcileInterrupted('recovery');
   assert.deepEqual(lines,['⚠ [pending-] OUTCOME_UNKNOWN coding_file_write — recovery ended before terminal result; inspect state before retry']);
-  assert.match(tracker.summary(),/^📊 \[SUMMARY\] 0 calls \| 0 errors/);
+  assert.match(tracker.summary(),/^📊 \[SUMMARY\] 0 calls \| 0 ok \| 0 errors \| 0 unknown \| 0 mutations/);
 });
 
 test('R40 CLI exposes explicit verbose mode while keeping default live mode compact',async()=>{
   const {readFile}=await import('node:fs/promises');
   const src=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
-  assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode\}\)/);
-  assert.match(src,/args\.includes\('--verbose'\)/);
+  assert.match(src,/readLiveRootPaths\(ctx\.root\)/);
+  assert.match(src,/createLiveTimelineTracker\(\{verbose,displayMode,rootPaths,trace\}\)/);
+  assert.match(src,/createLiveTimelineFilter\(filterExpression\)/);
+  assert.match(src,/createLiveTimelineWriter\(\{stream:process\.stdout,displayMode,rewrite:!verbose\}\)/);
+  assert.match(src,/arg==='--verbose'\|\|arg==='-v'/);
+  assert.match(src,/arg==='--trace'/);
+  assert.match(src,/arg==='--filter'/);
   assert.match(src,/Transport IN\/OUT hidden/);
   assert.doesNotMatch(src,/\[cursor \$\{recorded\.cursor\}\]/);
 });
@@ -88,13 +94,13 @@ test('R40 ASCII display fallback contains no non-ASCII bytes and preserves termi
   assert.equal(formatRemoteLifecycle('device_start',{displayMode:'ascii'}),'[DEVICE] Starting DEADBYTE MCP...');
 });
 
-test('R40 interrupted side effect is explicit OUTCOME_UNKNOWN instead of implying failure or replay safety',()=>{
+test('R40 interrupted side effect is explicit failed-after-unknown-effect instead of implying replay safety',()=>{
   const tracker=createLiveTimelineTracker({clock:()=>1000});
   tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'unknown-12345678',
     args:{root_id:'core',path:'x.txt',content:'x'}},{sequence:70});
   const line=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'unknown-12345678',
     outcome:{status:'interrupted',is_error:true,duration_ms:0,side_effect_state:'unknown',recovery:{reason:'runtime_restart'}}},{sequence:71});
-  assert.match(line,/OUTCOME_UNKNOWN — runtime_restart$/);
+  assert.match(line,/FAILED_AFTER_UNKNOWN_EFFECT — runtime_restart$/);
   assert.doesNotMatch(line,/\s[✓✗]\s/);
 });
 
@@ -105,3 +111,96 @@ test('R40 UTF-8 truncation never splits Thai or emoji into replacement character
   assert.equal(clipped.includes('\uFFFD'),false);
   assert.ok(clipped.endsWith('…'));
 });
+
+
+test('visual opcode projection resolves multiplexed machine_fs operation and exposes terminal evidence',()=>{
+  let now=1000;
+  const receipt='1'.repeat(64);
+  const tracker=createLiveTimelineTracker({clock:()=>now,rootPaths:{projects:'D:\\Projects'}});
+  const start=tracker.observe({event_type:'tool.request',tool:'machine_fs',request_id:'machinefs-12345678',
+    ts:'1970-01-01T00:00:01.000Z',args:{op:'write',root_id:'projects',path:'S3CORE01-R2/STATUS.txt',content:'x'}},{sequence:80});
+  assert.match(start,/^📝 .*machine_fs\.write /);
+  assert.ok(start.includes('D:\\Projects\\S3CORE01-R2\\STATUS.txt [root=projects]'));
+  now=1007;
+  const done=tracker.observe({event_type:'tool.result',tool:'machine_fs',request_id:'machinefs-12345678',
+    ts:'1970-01-01T00:00:01.007Z',outcome:{status:'committed',is_error:false,duration_ms:7,receipt_sha256s:[receipt]}},{sequence:81});
+  assert.match(done,/^📝 .*machine_fs\.write .*7ms  ✅ SUCCEEDED  🧾 receipt=11111111…$/);
+});
+
+test('visual opcode projection reserves warning semantics for explicitly unknown side effects',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000});
+  tracker.observe({event_type:'tool.request',tool:'host_exec',request_id:'unknown-host-1234',
+    args:{root_id:'core',command_id:'powershell_inline',mode:'inline'}},{sequence:90});
+  const done=tracker.observe({event_type:'tool.result',tool:'host_exec',request_id:'unknown-host-1234',
+    outcome:{status:'interrupted',is_error:true,duration_ms:4,side_effect_state:'unknown',recovery:{reason:'runtime_restart'}}},{sequence:91});
+  assert.match(done,/^⚠️ .*host_exec .*4ms  FAILED_AFTER_UNKNOWN_EFFECT — runtime_restart$/);
+  assert.doesNotMatch(done,/❌|🚫/);
+});
+
+
+test('absolute Windows root rendering shows the operator the real host path and root identity',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,rootPaths:{local_c:'C:\\'}});
+  tracker.observe({event_type:'tool.request',tool:'machine_fs',request_id:'localc-123456789',
+    args:{op:'read',root_id:'local_c',path:'Users/DEADBYTE/.deadbyte-mcp/active-release.json'}},{sequence:100});
+  const line=tracker.observe({event_type:'tool.result',tool:'machine_fs',request_id:'localc-123456789',
+    outcome:{is_error:false,duration_ms:1}},{sequence:101});
+  assert.ok(line.includes('C:\\Users\\DEADBYTE\\.deadbyte-mcp\\active-release.json [root=local_c]'));
+  assert.match(line,/^📖 .*machine_fs\.read /);
+});
+
+
+test('trace mode exposes deterministic trace/span hierarchy without payload bytes',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,trace:true});
+  const start=tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'span-1234567890abcdef',
+    context:{parent_span_id:'parent-abcdef123456',job_id:'job-112233445566'},args:{root_id:'core',path:'x.txt',content:'SECRET'}},{sequence:110});
+  assert.match(start,/trace=job-1122… span=span-123… parent=parent-a…/);
+  assert.doesNotMatch(start,/SECRET/);
+  const done=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'span-1234567890abcdef',
+    outcome:{is_error:false,duration_ms:2}},{sequence:111});
+  assert.match(done,/trace=job-1122… span=span-123… parent=parent-a…/);
+});
+
+test('timeline filter keeps audit observation complete while selecting presentation by category status and trace',()=>{
+  const filter=live.createLiveTimelineFilter('category=write,status=error,trace=goal-1234');
+  const request={event_type:'tool.request',tool:'machine_fs',request_id:'filter-span-1',
+    args:{op:'write',root_id:'projects',path:'x.txt',goal_id:'goal-1234'}};
+  assert.equal(filter.accept(request),false,'status-constrained request start is deferred');
+  assert.equal(filter.accept({event_type:'tool.result',tool:'machine_fs',request_id:'filter-span-1',
+    outcome:{is_error:true,duration_ms:1}}),true);
+  const other={event_type:'tool.request',tool:'coding_file_read',request_id:'filter-span-2',
+    args:{root_id:'projects',path:'x.txt',goal_id:'goal-1234'}};
+  assert.equal(filter.accept(other),false);
+  assert.equal(filter.accept({event_type:'tool.result',tool:'coding_file_read',request_id:'filter-span-2',
+    outcome:{is_error:true,duration_ms:1}}),false);
+});
+
+test('TTY writer rewrites matching visible start in place and never rewrites unrelated output',()=>{
+  const writes=[];const stream={isTTY:true,write(value){writes.push(value);return true;}};
+  const writer=live.createLiveTimelineWriter({stream,displayMode:'unicode'});
+  writer.write('RUNNING',{event_type:'tool.call',request_id:'a'});
+  writer.write('DONE',{event_type:'tool.result',request_id:'a'});
+  assert.deepEqual(writes,['RUNNING','\r\x1b[2KDONE\n']);
+  writes.length=0;
+  writer.write('RUN-A',{event_type:'tool.call',request_id:'a'});
+  writer.write('OTHER',{event_type:'tool.result',request_id:'b'});
+  assert.deepEqual(writes,['RUN-A','\n','OTHER\n']);
+});
+
+test('expanded session summary reports outcome classes latency and slowest tool',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000});
+  const events=[
+    ['a','coding_file_read',10,false,false],
+    ['b','coding_file_write',50,false,false],
+    ['c','coding_command_run',100,true,false],
+    ['d','host_exec',200,true,true]
+  ];
+  for(const [id,tool,duration,isError,unknown] of events){
+    tracker.observe({event_type:'tool.request',tool,request_id:id,args:{root_id:'core',path:'x'}});
+    tracker.observe({event_type:'tool.result',tool,request_id:id,outcome:{is_error:isError,duration_ms:duration,
+      ...(unknown?{side_effect_state:'unknown'}:{})}});
+  }
+  const summary=tracker.summary();
+  assert.match(summary,/4 calls \| 2 ok \| 1 error \| 1 unknown \| 3 mutations/);
+  assert.match(summary,/p50 75ms \| p95 200ms/);
+  assert.match(summary,/slowest host_exec 200ms/);
+});

package/test/remote-session-cli.test.mjs

@@ -466,3 +466,43 @@ winTest('bare remote surfaces bounded controller-start-failure evidence instead
     assert.match(output.stderr,/controller-start-failure/i);
   }finally{await rm(fx.dir,{recursive:true,force:true});}
 });
+
+
+winTest('remote --trace --filter selects presentation without dropping journaled events',async()=>{
+  const fx=await fixture();
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote','--trace','--filter','category=write,status=error,trace=goal-1234'],{
+      env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true
+    });
+    const output=await collect(child);
+    await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
+    const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
+    const auditDir=path.join(fx.state,'audit');await mkdir(auditDir,{recursive:true});
+    const audit=[
+      {event_type:'tool.request',tool:'machine_fs',request_id:'filter-write-1234',created_at_utc:'2026-09-19T01:00:00.000Z',
+        args:{op:'write',root_id:'projects',path:'x.txt',goal_id:'goal-1234',content:'SECRET'}},
+      {event_type:'tool.result',tool:'machine_fs',request_id:'filter-write-1234',created_at_utc:'2026-09-19T01:00:00.010Z',
+        outcome:{is_error:true,duration_ms:10,reason:'denied'}},
+      {event_type:'tool.request',tool:'coding_file_read',request_id:'filter-read-12345',created_at_utc:'2026-09-19T01:00:00.020Z',
+        args:{root_id:'projects',path:'x.txt',goal_id:'goal-1234'}},
+      {event_type:'tool.result',tool:'coding_file_read',request_id:'filter-read-12345',created_at_utc:'2026-09-19T01:00:00.030Z',
+        outcome:{is_error:true,duration_ms:10,reason:'missing'}}
+    ];
+    await writeFile(path.join(auditDir,'segment-00000001.jsonl'),audit.map(JSON.stringify).join('\n')+'\n','utf8');
+    const deadline=Date.now()+4000;
+    while(Date.now()<deadline&&!/machine_fs\.write.*trace=goal-1234/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/machine_fs\.write.*trace=goal-123\.\.\. span=filter-w\.\.\..*10ms.*ERR - denied/);
+    assert.doesNotMatch(output.stdout,/coding_file_read.*missing/);
+    assert.doesNotMatch(output.stdout,/SECRET/);
+    const journal=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-results',marker.result_session_id+'.json'),'utf8'));
+    assert.equal(journal.events.length,4,'presentation filter must not remove journal evidence');
+    child.stdin.end();
+    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    assert.equal(ended.timeout,undefined);
+    assert.equal(ended.code,0,output.stderr);
+  }finally{
+    if(child?.exitCode===null) child.kill('SIGKILL');
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});

package/test/tool-audit.test.mjs

@@ -132,3 +132,20 @@ test('controller enables audit only for Bridge child and restores parent audit e
   assert.match(source,/if \(\$hadAuditRuntimeEnv\) \{ \$env:DEADBYTE_AUDIT_RUNTIME = \$previousAuditRuntimeEnv \}/);
   assert.match(source,/else \{ Remove-Item Env:DEADBYTE_AUDIT_RUNTIME -ErrorAction SilentlyContinue \}/);
 });
+
+
+test('audit outcome reason preserves ordinary letters and Windows paths while folding actual whitespace',async()=>{
+  const root=await temp();
+  try{
+    const k=await keys(root);
+    const audit=await createToolAudit({stateRoot:root,signingKeyPath:k.privateKeyPath,contextProvider:async()=>context()});
+    const server=fakeServer();installToolAudit(server,audit);
+    server.registerTool('broken_read',{},async()=>({
+      isError:true,
+      structuredContent:{status:'error',error:"Error:\tENOENT: no such file or directory,\nrealpath 'D:\\\\Projects\\\\runtime'"}
+    }));
+    await server.handlers.get('broken_read')({path:'x'});
+    const all=await events(root);
+    assert.equal(all.at(-1).outcome.reason,"Error: ENOENT: no such file or directory, realpath 'D:\\\\Projects\\\\runtime'");
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/tunnel-stdio-compat.test.mjs

@@ -76,7 +76,9 @@ test('probe adapter forwards malformed and unknown input unchanged', () => {
 
 test('strict MCP core still rejects legacy at the SDK serving boundary', async () => {
   const source = await readFile(fileURLToPath(new URL('../src/mcp-server.mjs', import.meta.url)), 'utf8');
-  assert.match(source, /serveStdio\([\s\S]*\{ legacy: 'reject' \}\)/);
+  assert.match(source, /serveStdio\(/);
+  assert.match(source, /legacy:\s*'reject'/);
+  assert.match(source, /transport:\s*new DeadbyteStdioServerTransport\(\)/);
   assert.match(source, /installTunnelStdioProbeCompat/);
 });