deadbyte-mcp 0.8.10 → 0.10.0

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

@@ -18,7 +18,7 @@ async function fixture({failCommand=''}={}){
   const trace=path.join(dir,'trace.txt');
   await mkdir(bin,{recursive:true});
   const launcher=path.join(bin,'DEADBYTE-MCP.ps1');
-  const ps1=`param([string]$Command)\nAdd-Content -LiteralPath $env:DEADBYTE_REMOTE_TEST_TRACE -Value $Command -Encoding UTF8\nif ($env:DEADBYTE_REMOTE_TEST_FAIL -and $Command -eq $env:DEADBYTE_REMOTE_TEST_FAIL) { Write-Error \"forced $Command failure\"; exit 9 }\nswitch ($Command) {\n  'start' { Write-Host 'DEADBYTE MCP = ONLINE' }\n  'processstatus' { Write-Host 'Process plane  : ARMED [standing-grant]' }\n  'codingstatus' { Write-Host 'Coding plane  : ARMED [standing-grant]' }\n  'autonomousstatus' { Write-Host 'Autonomous     : ARMED [standing-grant]' }\n  'hoststatus' { Write-Host 'Host plane    : ARMED [standing-grant]' }\n  'park' { Write-Host 'DEADBYTE MCP = PARKED' }\n  default { Write-Host \"$Command OK\" }\n}\nexit 0\n`;
+  const ps1=`param([string]$Command)\n$ErrorActionPreference='Stop'\nfor($i=0;$i -lt 20;$i++){ try { [IO.File]::AppendAllText($env:DEADBYTE_REMOTE_TEST_TRACE,(\"$Command\" + [Environment]::NewLine),[Text.Encoding]::UTF8); break } catch { if($i -eq 19){ throw }; Start-Sleep -Milliseconds 10 } }\nif ($env:DEADBYTE_REMOTE_TEST_FAIL -and $Command -eq $env:DEADBYTE_REMOTE_TEST_FAIL) { Write-Error \"forced $Command failure\"; exit 9 }\nswitch ($Command) {\n  'start' { Write-Host 'DEADBYTE MCP = ONLINE' }\n  'processstatus' { Write-Host 'Process plane  : ARMED [standing-grant]' }\n  'codingstatus' { Write-Host 'Coding plane  : ARMED [standing-grant]' }\n  'autonomousstatus' { Write-Host 'Autonomous     : ARMED [standing-grant]' }\n  'hoststatus' { Write-Host 'Host plane    : DISARMED [disarmed]' }\n  'park' { Write-Host 'DEADBYTE MCP = PARKED' }\n  default { Write-Host \"$Command OK\" }\n}\nexit 0\n`;
   await writeFile(launcher,ps1,'utf8');
   return {dir,state,trace,env:{...process.env,DEADBYTE_STATE_ROOT:state,DEADBYTE_REMOTE_TEST_TRACE:trace,DEADBYTE_REMOTE_TEST_FAIL:failCommand}};
 }
@@ -34,7 +34,7 @@ async function traceCommands(file,{read=readFile,retryDelayMs=10,maxAttempts=20}
   }
   return [];
 }
-async function waitFor(file,predicate,{timeoutMs=6000}={}){
+async function waitFor(file,predicate,{timeoutMs=12000}={}){
   const deadline=Date.now()+timeoutMs;
   while(Date.now()<deadline){
     const commands=await traceCommands(file);
@@ -65,31 +65,43 @@ async function collect(child){
 
 const winTest=isWindows?test:test.skip;
 
-winTest('bare remote arms every authority plane, verifies ARMED state, streams logs, then disarms and parks when the foreground session ends',async()=>{
+winTest('bare remote uses compact human logs by default, keeps authority semantics, then disarms and parks when the foreground session ends',async()=>{
   const fx=await fixture();
   let child=null;
   try{
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ready=await waitFor(fx.trace,commands=>commands.slice(0,9).join(',')==='start,armprocess,armcoding,armautonomous,armhost,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.deepEqual(ready.slice(0,9),[
-      'start','armprocess','armcoding','armautonomous','armhost',
+    const ready=await waitFor(fx.trace,commands=>commands.slice(0,8).join(',')==='start,armprocess,armcoding,armautonomous,processstatus,codingstatus,autonomousstatus,hoststatus');
+    assert.deepEqual(ready.slice(0,8),[
+      'start','armprocess','armcoding','armautonomous',
       'processstatus','codingstatus','autonomousstatus','hoststatus'
     ]);
     assert.equal(child.exitCode,null,'remote session must remain foreground after becoming ready');
     const tailDeadline=Date.now()+3000;
-    while(Date.now()<tailDeadline&&!/📜 \[LOG\] Live logs active/.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/📜 \[LOG\] Live logs active\. Press Ctrl\+C to disconnect and revoke authority\./);
-    assert.match(output.stdout,/🛡️ \[AUTHORITY\] Verifying runtime planes\.\.\./);
+    while(Date.now()<tailDeadline&&!/🔐 \[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/🚀 \[DEVICE\] Starting DEADBYTE MCP/);
+    assert.match(output.stdout,/🔌 \[BRIDGE\] Local bridge connected/);
+    assert.match(output.stdout,/🔌 \[CLOUD\] Remote MCP connected/);
+    assert.match(output.stdout,/\[SESSION\] New foreground session/);
+    assert.match(output.stdout,/\[BOOT\] Starting local \+ remote runtime/);
+    assert.match(output.stdout,/\[OK\] ONLINE/);
+    assert.match(output.stdout,/✅ \[READY\] DEADBYTE MCP online/);
+    assert.match(output.stdout,/🔐 \[AUTH\] ARMED: process, coding, autonomous \| host DISARMED/);
+    assert.match(output.stdout,/\[LOG\] Live activity\. Ctrl\+C disconnects and revokes authority\./);
+    assert.doesNotMatch(output.stdout,/Process plane\s*:/);
+    assert.doesNotMatch(output.stdout,/Coding plane\s*:/);
     const auditDir=path.join(fx.state,'audit');
     const runtimeLogs=path.join(fx.state,'runtime','logs');
     await mkdir(auditDir,{recursive:true});
     await mkdir(runtimeLogs,{recursive:true});
+    const marker=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8'));
+    assert.match(String(marker.result_session_id||''),/^[0-9a-f]{24}$/);
     const auditEvents=[
-      {seq:1,event_type:'tool.request',tool:'coding_tree',request_id:'abcdef1234567890'},
-      {seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false}},
-      {seq:3,event_type:'tool.request',tool:'coding_file_read',request_id:'fedcba9876543210'},
-      {seq:4,event_type:'tool.result',tool:'coding_file_read',request_id:'fedcba9876543210',outcome:{is_error:true}}
+      {seq:1,event_type:'tool.request',tool:'coding_tree',request_id:'abcdef1234567890',args:{root_id:'projects',path:'src',content:'DO_NOT_PRINT_PAYLOAD',token:'DO_NOT_PRINT_TOKEN'}},
+      {seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false,duration_ms:42}},
+      {seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false,duration_ms:42}},
+      {seq:3,event_type:'tool.request',tool:'coding_file_read',request_id:'fedcba9876543210',args:{root_id:'projects',path:'src/deadbyte-cli.mjs'}},
+      {seq:4,event_type:'tool.result',tool:'coding_file_read',request_id:'fedcba9876543210',outcome:{is_error:true,duration_ms:1734}}
     ];
     await writeFile(path.join(auditDir,'segment-00000001.jsonl'),`${auditEvents.map(event=>JSON.stringify(event)).join('\n')}\n`,'utf8');
     await writeFile(path.join(runtimeLogs,'bridge.stdout.log'),[
@@ -98,22 +110,32 @@ winTest('bare remote arms every authority plane, verifies ARMED state, streams l
       '[TOOL OUT] 2026-09-16T00:00:00.002Z #000002 coding_file_read {"is_error":true}'
     ].join('\n')+'\n','utf8');
     const logDeadline=Date.now()+3000;
-    while(Date.now()<logDeadline&&!/📤❌ \[BRIDGE\.STDOUT\] \[TOOL OUT\].*coding_file_read/.test(output.stdout)) await sleep(50);
-    assert.match(output.stdout,/📥 \[AUDIT #1\] tool\.request coding_tree abcdef12/);
-    assert.match(output.stdout,/📤✅ \[AUDIT #2\] tool\.result coding_tree abcdef12/);
-    assert.match(output.stdout,/📥 \[AUDIT #3\] tool\.request coding_file_read fedcba98/);
-    assert.match(output.stdout,/📤❌ \[AUDIT #4\] tool\.result coding_file_read fedcba98/);
-    assert.match(output.stdout,/📥 \[BRIDGE\.STDOUT\] \[TOOL IN \].*coding_tree/);
-    assert.match(output.stdout,/📤✅ \[BRIDGE\.STDOUT\] \[TOOL OUT\].*coding_tree/);
-    assert.match(output.stdout,/📤❌ \[BRIDGE\.STDOUT\] \[TOOL OUT\].*coding_file_read/);
+    while(Date.now()<logDeadline&&!/❌ ERR coding_file_read 1\.73s/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/▶ RUN coding_tree root=projects path=src/);
+    assert.match(output.stdout,/✅ OK coding_tree 42ms \[cursor r1:[0-9a-f]{24}:1\]/);
+    assert.match(output.stdout,/▶ RUN coding_file_read root=projects path=src\/deadbyte-cli\.mjs/);
+    assert.match(output.stdout,/❌ ERR coding_file_read 1\.73s \[cursor r1:[0-9a-f]{24}:2\]/);
+    assert.equal((output.stdout.match(/✅ OK coding_tree 42ms/g)||[]).length,1,'duplicate terminal result must print once');
+    const resultJournal=JSON.parse(await readFile(path.join(fx.state,'runtime','remote-results',`${marker.result_session_id}.json`),'utf8'));
+    assert.deepEqual(resultJournal.events.map(event=>event.seq),[1,2]);
+    assert.equal(resultJournal.events[0].request_id,'abcdef1234567890');
+    assert.ok(resultJournal.events.every(event=>/^[0-9a-f]{64}$/.test(event.payload_sha256)));
+    assert.doesNotMatch(JSON.stringify(resultJournal),/TOOL IN|TOOL OUT|stdout_excerpt|stderr_excerpt/);
+    assert.doesNotMatch(output.stdout,/abcdef12|fedcba98/);
+    assert.doesNotMatch(output.stdout,/DO_NOT_PRINT_PAYLOAD|DO_NOT_PRINT_TOKEN/);
+    assert.doesNotMatch(output.stdout,/BRIDGE\.STDOUT/);
+    assert.doesNotMatch(output.stdout,/\[TOOL IN \]|\[TOOL OUT\]/);
+    assert.doesNotMatch(output.stdout,/payload bytes=/);
     child.stdin.end();
     const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
     assert.equal(ended.timeout,undefined,'remote session did not exit after foreground input closed');
     const commands=await traceCommands(fx.trace);
     assert.deepEqual(commands.slice(-5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
-    assert.match(output.stdout,/DEADBYTE MCP DEVICE SESSION/i);
-    assert.match(output.stdout,/Live logs/i);
-    const withoutApprovedEmoji=output.stdout.replace(/[📜📥📤✅❌⚠♻🛡]/gu,'');
+    assert.match(output.stdout,/^DEADBYTE MCP$/m);
+    assert.match(output.stdout,/Live activity/i);
+    assert.match(output.stdout,/🔐 \[AUTH\] Revoking session authority/);
+    assert.doesNotMatch(output.stdout,/disarmautonomous OK|disarmcoding OK|disarmprocess OK|disarmhost OK|DEADBYTE MCP = PARKED/);
+    const withoutApprovedEmoji=output.stdout.replace(/[📜📥📤✅❌⚠♻🛡▶🔐🚀🔌]/gu,'');
     assert.doesNotMatch(withoutApprovedEmoji,/\p{Extended_Pictographic}/u,'human live stream may use only the approved semantic emoji set');
   }finally{
     if(child?.exitCode===null) child.kill();
@@ -121,15 +143,98 @@ winTest('bare remote arms every authority plane, verifies ARMED state, streams l
   }
 });
 
+winTest('remote --resume replays only terminal results after the cursor before starting a new live session',async()=>{
+  const fx=await fixture();
+  let first=null,second=null;
+  try{
+    first=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const firstOutput=await collect(first);
+    await waitFor(fx.trace,commands=>commands.includes('hoststatus'));
+    const liveDeadline=Date.now()+3000;
+    while(Date.now()<liveDeadline&&!/\[LOG\] Live activity/.test(firstOutput.stdout)) await sleep(50);
+    const auditDir=path.join(fx.state,'audit');await mkdir(auditDir,{recursive:true});
+    const auditFile=path.join(auditDir,'segment-00000001.jsonl');
+    await writeFile(auditFile,JSON.stringify({seq:1,event_type:'tool.result',tool:'coding_tree',request_id:'resume-request-1',outcome:{is_error:false}})+'\n','utf8');
+    let deadline=Date.now()+3000;
+    while(Date.now()<deadline&&!/coding_tree \[cursor r1:[0-9a-f]{24}:1\]/.test(firstOutput.stdout)) await sleep(50);
+    const cursor1=firstOutput.stdout.match(/coding_tree \[cursor (r1:[0-9a-f]{24}:1)\]/)?.[1];
+    assert.ok(cursor1,'first result cursor missing');
+    await writeFile(auditFile,JSON.stringify({seq:2,event_type:'tool.result',tool:'coding_file_read',request_id:'resume-request-2',outcome:{is_error:false}})+'\n',{encoding:'utf8',flag:'a'});
+    deadline=Date.now()+3000;
+    while(Date.now()<deadline&&!/coding_file_read \[cursor r1:[0-9a-f]{24}:2\]/.test(firstOutput.stdout)) await sleep(50);
+    first.stdin.end();
+    const firstEnded=await Promise.race([firstOutput.closed,sleep(6000).then(()=>({timeout:true}))]);
+    assert.equal(firstEnded.timeout,undefined);
+
+    second=spawn(process.execPath,[cliPath,'remote','--resume',cursor1],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const secondOutput=await collect(second);
+    deadline=Date.now()+5000;
+    while(Date.now()<deadline&&(!/\[REPLAY\] \[OK\] coding_file_read \[cursor r1:[0-9a-f]{24}:2\]/.test(secondOutput.stdout)||
+      !/\[LOG\] Live activity/.test(secondOutput.stdout))) await sleep(50);
+    assert.match(secondOutput.stdout,/\[REPLAY\] \[OK\] coding_file_read \[cursor r1:[0-9a-f]{24}:2\]/);
+    assert.match(secondOutput.stdout,/♻️ \[SESSION\] Previous result stream replayed/);
+    assert.doesNotMatch(secondOutput.stdout,/\[REPLAY\] \[OK\] coding_tree/);
+    const replayIndex=secondOutput.stdout.indexOf('[REPLAY]');
+    const liveIndex=secondOutput.stdout.indexOf('[LOG] Live activity');
+    assert.ok(replayIndex>=0&&liveIndex>replayIndex,'resume replay must happen before new live tail');
+    second.stdin.end();
+    const secondEnded=await Promise.race([secondOutput.closed,sleep(6000).then(()=>({timeout:true}))]);
+    assert.equal(secondEnded.timeout,undefined);
+    assert.equal(secondEnded.code,0,secondOutput.stderr);
+  }finally{
+    if(first?.exitCode===null) first.kill();if(second?.exitCode===null) second.kill();
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
+winTest('remote --verbose preserves detailed audit and bridge log streaming for debugging',async()=>{
+  const fx=await fixture();
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote','--verbose'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const ready=await waitFor(fx.trace,commands=>commands.slice(0,8).join(',')==='start,armprocess,armcoding,armautonomous,processstatus,codingstatus,autonomousstatus,hoststatus');
+    assert.equal(ready.length>=8,true);
+    const liveDeadline=Date.now()+3000;
+    while(Date.now()<liveDeadline&&!/Live logs active/.test(output.stdout)) await sleep(50);
+    assert.match(output.stdout,/Live logs active/);
+    const auditDir=path.join(fx.state,'audit');
+    const runtimeLogs=path.join(fx.state,'runtime','logs');
+    await mkdir(auditDir,{recursive:true});
+    await mkdir(runtimeLogs,{recursive:true});
+    await writeFile(path.join(auditDir,'segment-00000001.jsonl'),[
+      JSON.stringify({seq:1,event_type:'tool.request',tool:'coding_tree',request_id:'abcdef1234567890'}),
+      JSON.stringify({seq:2,event_type:'tool.result',tool:'coding_tree',request_id:'abcdef1234567890',outcome:{is_error:false}})
+    ].join('\n')+'\n','utf8');
+    await writeFile(path.join(runtimeLogs,'bridge.stdout.log'),[
+      '[TOOL IN ] 2026-09-16T00:00:00.000Z #000001 coding_tree {}',
+      '[TOOL OUT] 2026-09-16T00:00:00.001Z #000001 coding_tree {"is_error":false}'
+    ].join('\n')+'\n','utf8');
+    const deadline=Date.now()+3000;
+    while(Date.now()<deadline&&(!/\[AUDIT #2\] tool\.result coding_tree abcdef12/.test(output.stdout)||!/\[BRIDGE\.STDOUT\] \[TOOL OUT\].*coding_tree/.test(output.stdout))) await sleep(50);
+    assert.match(output.stdout,/\[AUDIT #1\] tool\.request coding_tree abcdef12/);
+    assert.match(output.stdout,/\[AUDIT #2\] tool\.result coding_tree abcdef12/);
+    assert.match(output.stdout,/\[BRIDGE\.STDOUT\] \[TOOL IN \].*coding_tree/);
+    assert.match(output.stdout,/\[BRIDGE\.STDOUT\] \[TOOL OUT\].*coding_tree/);
+    child.stdin.end();
+    const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
+    assert.equal(ended.timeout,undefined,'verbose remote session did not exit after input closed');
+    assert.equal(ended.code,0,output.stderr);
+  }finally{
+    if(child?.exitCode===null) child.kill();
+    await rm(fx.dir,{recursive:true,force:true});
+  }
+});
+
 winTest('detached guardian revokes authority, parks, and removes the session marker after the owner is hard-killed',async()=>{
   const fx=await fixture();
   let child=null;
   try{
-    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
+    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ready=await waitFor(fx.trace,commands=>commands.slice(0,9).join(',')==='start,armprocess,armcoding,armautonomous,armhost,processstatus,codingstatus,autonomousstatus,hoststatus');
-    assert.deepEqual(ready.slice(0,9),[
-      'start','armprocess','armcoding','armautonomous','armhost',
+    const ready=await waitFor(fx.trace,commands=>commands.slice(0,8).join(',')==='start,armprocess,armcoding,armautonomous,processstatus,codingstatus,autonomousstatus,hoststatus');
+    assert.deepEqual(ready.slice(0,8),[
+      'start','armprocess','armcoding','armautonomous',
       'processstatus','codingstatus','autonomousstatus','hoststatus'
     ]);
     const markerPath=path.join(fx.state,'runtime','remote-session.json');
@@ -164,7 +269,7 @@ winTest('detached guardian revokes authority, parks, and removes the session mar
 });
 
 winTest('bare remote rolls back authority and parks if one plane fails to arm',async()=>{
-  const fx=await fixture({failCommand:'armhost'});
+  const fx=await fixture({failCommand:'armcoding'});
   try{
     const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
@@ -172,7 +277,7 @@ winTest('bare remote rolls back authority and parks if one plane fails to arm',a
     assert.equal(ended.timeout,undefined,'failed startup did not terminate');
     assert.notEqual(ended.code,0);
     const commands=await traceCommands(fx.trace);
-    assert.deepEqual(commands.slice(0,5),['start','armprocess','armcoding','armautonomous','armhost']);
+    assert.deepEqual(commands.slice(0,3),['start','armprocess','armcoding']);
     assert.deepEqual(commands.slice(-5),['disarmautonomous','disarmcoding','disarmprocess','disarmhost','park']);
     assert.doesNotMatch(output.stdout,/Live logs/i);
   }finally{await rm(fx.dir,{recursive:true,force:true});}

package/test/runtime-self-update.test.mjs

@@ -10,6 +10,7 @@ import {
   loadPowerShellDataFile,
   parseUpdateArgs,
   prepareNamedTunnelCloudSpec,
+  readControllerStartFailure,
   runControllerStartNoCapture
 } from '../scripts/runtime-self-update.mjs';
 import * as runtimeUpdate from '../scripts/runtime-self-update.mjs';
@@ -31,10 +32,12 @@ test('R32 updater loads controller data with Windows PowerShell modules isolated
   }
 });
 
-test('R32 updater applies the isolated Windows PowerShell environment to detached controller starts', async () => {
+test('R36 updater keeps detached start semantics and binds controller sidecar diagnostics', async () => {
   const source=await readFile(new URL('../src/runtime-update.mjs',import.meta.url),'utf8');
   assert.match(source,/stdio:'ignore'/);
   assert.match(source,/env:commandEnvironment\(exe,env\?\?process\.env\)/);
+  assert.match(source,/readControllerStartFailure\(ctx\)/);
+  assert.match(source,/evidence_sha256/);
   assert.match(source,/for\(let attempt=1;attempt<=3;attempt\+=1\)/);
 });
 
@@ -74,6 +77,60 @@ test('R27 controller start transport returns while its long-lived descendant is
   assert.doesNotThrow(()=>process.kill(childPid,0),'controller start returned only after descendant exited');
 });
 
+test('R36 controller start sidecar is schema-bound and hash-bound', async () => {
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r36-start-evidence-'));
+  const controllerDir=path.join(base,'controller');
+  const runtime=path.join(controllerDir,'runtime');
+  await mkdir(runtime,{recursive:true});
+  await writeFile(path.join(controllerDir,'deadbyte-controller.ps1'),"param([string]$Command)\nexit 0\n");
+  const body={
+    schema:'deadbyte.controller-start-failure.v1',
+    command:'start',
+    failed_at_utc:'2026-09-18T00:00:00.000Z',
+    message:'R36_CONTROLLER_START_SENTINEL',
+    bridge_stdout_tail:'',
+    bridge_stderr_tail:'compact bridge failed',
+    cloud_stdout_tail:'',
+    cloud_stderr_tail:''
+  };
+  const bytes=Buffer.from(JSON.stringify(body),'utf8');
+  await writeFile(path.join(runtime,'controller-start-failure.json'),bytes);
+  const evidence=await readControllerStartFailure(legacyContext(base));
+  assert.equal(evidence.message,'R36_CONTROLLER_START_SENTINEL');
+  assert.equal(evidence.command,'start');
+  assert.equal(evidence.sha256,sha(bytes));
+});
+
+test('R36 updater preserves exact controller-start failure evidence before rollback', async () => {
+  assert.equal(typeof runtimeUpdate.preserveControllerStartFailure,'function');
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r36-preserve-start-evidence-'));
+  const controllerDir=path.join(base,'controller');
+  const runtime=path.join(controllerDir,'runtime');
+  const evidenceDir=path.join(base,'evidence','updates','candidate');
+  await mkdir(runtime,{recursive:true});
+  await writeFile(path.join(controllerDir,'deadbyte-controller.ps1'),"param([string]$Command)\nexit 0\n");
+  const body={
+    schema:'deadbyte.controller-start-failure.v1',
+    command:'start',
+    failed_at_utc:'2026-09-18T00:00:00.000Z',
+    message:'R36_PRESERVE_SENTINEL',
+    bridge_stdout_tail:'bridge-out',
+    bridge_stderr_tail:'bridge-err',
+    cloud_stdout_tail:'',
+    cloud_stderr_tail:''
+  };
+  const bytes=Buffer.from(JSON.stringify(body),'utf8');
+  const source=path.join(runtime,'controller-start-failure.json');
+  await writeFile(source,bytes);
+  const preserved=await runtimeUpdate.preserveControllerStartFailure(legacyContext(base),evidenceDir);
+  assert.equal(preserved.sha256,sha(bytes));
+  assert.equal(preserved.message,'R36_PRESERVE_SENTINEL');
+  assert.equal(preserved.path,path.join(evidenceDir,'controller-start-failure.json'));
+  assert.deepEqual(await readFile(preserved.path),bytes);
+  await writeFile(source,Buffer.from('destroyed-after-snapshot','utf8'));
+  assert.deepEqual(await readFile(preserved.path),bytes,'rollback/runtime restart must not mutate preserved evidence');
+});
+
 test('R28 slot-update CLI binds direct cloudflared plus external token file as one pinned contract', () => {
   const base=['--stage','stage','--development-root','dev','--expected-version','0.8.4','--expected-manifest',hex('a')];
   assert.throws(() => parseUpdateArgs([...base,'--cloud-cloudflared','C:/cloudflared.exe']), /named tunnel bootstrap requires all|cloud/i);
@@ -206,6 +263,40 @@ test('R31 slot-update CLI binds process-policy bootstrap and machine-FS enable e
   assert.equal(parsed.enableMachineFs,true);
 });
 
+test('R35 slot-update CLI binds semantic LSP config as one exact path plus SHA-256 pair', () => {
+  const base=['--stage','stage','--development-root','dev','--expected-version','0.9.0','--expected-manifest',hex('a')];
+  assert.throws(() => parseUpdateArgs([...base,'--semantic-lsp-config','C:/candidate/semantic.json']), /semantic LSP config.*pair/i);
+  assert.throws(() => parseUpdateArgs([...base,'--semantic-lsp-config-sha256',hex('b')]), /semantic LSP config.*pair/i);
+  const parsed=parseUpdateArgs([...base,'--semantic-lsp-config','C:/candidate/semantic.json','--semantic-lsp-config-sha256',hex('b')]);
+  assert.equal(parsed.semanticLspBootstrap.path,path.resolve('C:/candidate/semantic.json'));
+  assert.equal(parsed.semanticLspBootstrap.sha256,hex('b'));
+});
+
+test('R35 semantic LSP bootstrap accepts only exact pinned semantic config bytes', async () => {
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r35-semantic-bootstrap-'));
+  const file=path.join(root,'semantic.json');
+  const config={schema:'deadbyte.semantic-lsp-config.v1',servers:[]};
+  const bytes=Buffer.from(`${JSON.stringify(config)}\n`,'utf8');
+  await writeFile(file,bytes);
+  assert.equal(typeof runtimeUpdate.prepareSemanticLspConfigBootstrap,'function');
+  const accepted=await runtimeUpdate.prepareSemanticLspConfigBootstrap({path:file,sha256:sha(bytes)});
+  assert.equal(accepted.path,path.resolve(file));
+  assert.equal(accepted.sha256,sha(bytes));
+  await assert.rejects(runtimeUpdate.prepareSemanticLspConfigBootstrap({path:file,sha256:hex('f')}),/semantic LSP config.*SHA-256 mismatch/i);
+  const bad=path.join(root,'bad.json');
+  const badBytes=Buffer.from(`${JSON.stringify({schema:'wrong',servers:[]})}\n`,'utf8');
+  await writeFile(bad,badBytes);
+  await assert.rejects(runtimeUpdate.prepareSemanticLspConfigBootstrap({path:bad,sha256:sha(badBytes)}),/semantic LSP config schema/i);
+});
+
+test('R35 updater threads pinned semantic LSP config into successor generation', async () => {
+  const source=await readFile(new URL('../src/runtime-update.mjs',import.meta.url),'utf8');
+  assert.match(source,/prepareSemanticLspConfigBootstrap\(semanticLspBootstrap\)/);
+  assert.match(source,/SemanticLspConfigFile=semanticBootstrap\.path/);
+  assert.match(source,/SemanticLspConfigSha256=semanticBootstrap\.sha256/);
+  assert.match(source,/semanticLspBootstrap:args\.semanticLspBootstrap/);
+});
+
 test('R32 slot-update CLI enables observation only by explicit flag', () => {
   const base=['--stage','stage','--development-root','dev','--expected-version','0.8.6','--expected-manifest',hex('a')];
   const plain=parseUpdateArgs(base);
@@ -215,6 +306,35 @@ test('R32 slot-update CLI enables observation only by explicit flag', () => {
   assert.throws(() => parseUpdateArgs([...base,'--enable-observation','--enable-observation']),/duplicate self-update argument/i);
 });
 
+test('R34 slot-update CLI enables the out-of-band supervisor only by explicit flag', () => {
+  const base=['--stage','stage','--development-root','dev','--expected-version','0.8.11','--expected-manifest',hex('a')];
+  const plain=parseUpdateArgs(base);
+  assert.equal(plain.enableAutonomousSupervisor,false);
+  const enabled=parseUpdateArgs([...base,'--enable-autonomous-supervisor']);
+  assert.equal(enabled.enableAutonomousSupervisor,true);
+  assert.throws(() => parseUpdateArgs([...base,'--enable-autonomous-supervisor','--enable-autonomous-supervisor']),/duplicate self-update argument/i);
+});
+
+test('R34 supervisor bootstrap derives exact release-bound script identity from trusted Bridge executable', async () => {
+  assert.equal(typeof runtimeUpdate.prepareAutonomousSupervisorSpec,'function');
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-supervisor-bootstrap-'));
+  const release=path.join(base,'release'),src=path.join(release,'src'); await mkdir(src,{recursive:true});
+  const script=Buffer.from('console.log("supervisor-r34")\n','utf8');
+  await writeFile(path.join(src,'autonomous-supervisor-host.mjs'),script);
+  const nodeHash=sha(await readFile(process.execPath));
+  const config={AutonomousRuntimeEnabled:true,AutonomousSupervisorEnabled:false,
+    Bridge:{FilePath:process.execPath,FileSha256:nodeHash}};
+  const bound=await runtimeUpdate.prepareAutonomousSupervisorSpec(config,{releaseRoot:release,enable:true});
+  assert.equal(bound.AutonomousSupervisorEnabled,true);
+  assert.deepEqual(bound.Supervisor,{
+    FilePath:process.execPath,FileSha256:nodeHash,Arguments:'src\\autonomous-supervisor-host.mjs',
+    WorkingDirectory:path.resolve(release),ScriptPath:path.join(path.resolve(release),'src','autonomous-supervisor-host.mjs'),ScriptSha256:sha(script)
+  });
+  const untouched=await runtimeUpdate.prepareAutonomousSupervisorSpec(config,{releaseRoot:release,enable:false});
+  assert.equal(untouched.AutonomousSupervisorEnabled,false);
+  assert.equal(untouched.Supervisor,undefined);
+});
+
 test('R31 process-policy bootstrap accepts only an exact pinned enabled process policy', async () => {
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r31-process-bootstrap-'));
   const file=path.join(root,'process-policy.json');

package/test/semantic-backend-registry.test.mjs

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createSemanticBackendRegistry } from '../src/semantic-backend-registry.mjs';
+
+const backend=(id,extensions)=>({id,extensions:new Set(extensions),outline(){},definition(){},references(){},replaceSymbol(){},diagnostics(){}});
+
+test('semantic backend registry resolves normalized extensions and exposes stable languages',()=>{
+  const ts=backend('typescript',['.ts','.tsx']);
+  const py=backend('python',['.py']);
+  const registry=createSemanticBackendRegistry({backends:[py,ts]});
+  assert.equal(registry.backendForPath('SRC/MAIN.TS'),ts);
+  assert.equal(registry.backendForPath('pkg/mod.py'),py);
+  assert.deepEqual(registry.languages(),[
+    {id:'python',extensions:['.py']},
+    {id:'typescript',extensions:['.ts','.tsx']}
+  ]);
+});
+
+test('semantic backend registry fails closed for unsupported languages',()=>{
+  const registry=createSemanticBackendRegistry({backends:[backend('typescript',['.ts'])]});
+  assert.throws(()=>registry.backendForPath('main.rs'),/unsupported semantic language: \.rs/i);
+  assert.throws(()=>registry.backendForPath('README'),/unsupported semantic language: <none>/i);
+});
+
+test('semantic backend registry rejects duplicate ids, extension ownership, and incomplete backends',()=>{
+  assert.throws(()=>createSemanticBackendRegistry({backends:[backend('a',['.x']),backend('a',['.y'])]}),/duplicate semantic backend id/i);
+  assert.throws(()=>createSemanticBackendRegistry({backends:[backend('a',['.x']),backend('b',['.X'])]}),/semantic extension.*already owned/i);
+  assert.throws(()=>createSemanticBackendRegistry({backends:[{id:'bad',extensions:new Set(['.x'])}]}),/missing method.*outline/i);
+});

package/test/semantic-code.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { loadCodingPolicy } from '../src/coding-plane.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const serverPath=path.join(repoRoot,'src','mcp-server.mjs');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sha256File=async file=>sha256(await readFile(file));
+function structured(value,label){if(value.isError)throw new Error(`${label}: ${JSON.stringify(value.structuredContent??value.content)}`);return value.structuredContent;}
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-semantic-'));
+  const project=path.join(root,'project'); const trust=path.join(root,'trust');
+  await mkdir(project); await mkdir(trust);
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  const math=`export function add(a: number, b: number) {\n  return a + b;\n}\n\nexport function twice(x: number) {\n  return add(x, x);\n}\n`;
+  const main=`import { add } from './math.js';\nexport const total = add(2, 3);\n`;
+  await writeFile(path.join(project,'math.ts'),math,'utf8'); await writeFile(path.join(project,'main.ts'),main,'utf8');
+  await writeFile(path.join(project,'tsconfig.json'),JSON.stringify({compilerOptions:{target:'ES2022',module:'NodeNext',moduleResolution:'NodeNext',strict:true},include:['*.ts']},null,2),'utf8');
+  const policyPath=path.join(root,'coding-policy.json'); const leasePath=path.join(root,'coding-lease.json');
+  await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:leasePath,evidence_dir:path.join(root,'evidence'),roots:{project:{path:project,read:true,write:true,exec:true,deny_paths:['.git','node_modules']}},commands:{node_script:{kind:'script',executable:process.execPath,executable_sha256:await sha256File(process.execPath),root_ids:['project'],prefix_args:[],extensions:['.mjs','.js'],timeout_ms:30000,max_output_bytes:262144}},max_read_bytes:524288,max_write_bytes:2097152},null,2),'utf8');
+  const policy=await loadCodingPolicy(policyPath);
+  await writeFile(leasePath,JSON.stringify({schema:'deadbyte.coding-lease.v1',policy_sha256:policy.policy_sha256,instance_nonce:'c'.repeat(64),root_ids:['project'],armed_at_utc:new Date().toISOString(),expires_at_utc:new Date(Date.now()+3600000).toISOString()}),'utf8');
+  const client=new Client({name:'deadbyte-semantic-test',version:'0.8.11'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StdioClientTransport({command:process.execPath,args:[serverPath],cwd:repoRoot,env:{...getDefaultEnvironment(),DEADBYTE_SIGNING_KEY:keys.privateKeyPath,DEADBYTE_VERIFY_KEY:keys.publicKeyPath,DEADBYTE_CODING_RUNTIME:'1',DEADBYTE_CODING_POLICY:policyPath},stderr:'pipe'});
+  return {root,project,client,transport,math,main};
+}
+
+test('semantic tools provide outline, definition, references and receipt-backed edit by symbol',async()=>{
+  const f=await fixture();
+  try{
+    await f.client.connect(f.transport);
+    const names=new Set((await f.client.listTools()).tools.map(t=>t.name));
+    for(const name of ['coding_symbol_outline','coding_symbol_definition','coding_symbol_references','coding_symbol_replace']) assert.ok(names.has(name),`missing semantic tool ${name}`);
+
+    const outline=structured(await f.client.callTool({name:'coding_symbol_outline',arguments:{root_id:'project',path:'math.ts',max_symbols:100}}),'outline');
+    assert.equal(outline.status,'ok');
+    const add=outline.symbols.find(s=>s.name==='add'&&s.kind==='function');
+    assert.ok(add,'add function missing from outline'); assert.match(add.symbol_id,/^[0-9a-f]{64}$/);
+
+    const useColumn=f.main.split('\n')[1].indexOf('add');
+    const definition=structured(await f.client.callTool({name:'coding_symbol_definition',arguments:{root_id:'project',path:'main.ts',line:1,column:useColumn,max_results:20}}),'definition');
+    assert.ok(definition.locations.some(x=>x.path==='math.ts'&&x.name==='add'));
+
+    const references=structured(await f.client.callTool({name:'coding_symbol_references',arguments:{root_id:'project',path:'math.ts',line:add.name_start_line,column:add.name_start_column,max_results:50}}),'references');
+    assert.ok(references.locations.some(x=>x.path==='main.ts'));
+    assert.ok(references.locations.some(x=>x.path==='math.ts'&&x.start_line===5));
+
+    const before=structured(await f.client.callTool({name:'coding_file_read',arguments:{root_id:'project',path:'math.ts',encoding:'utf8'}}),'before');
+    const replacement='export function add(a: number, b: number) {\n  return a - b;\n}';
+    const edited=structured(await f.client.callTool({name:'coding_symbol_replace',arguments:{root_id:'project',path:'math.ts',symbol_id:add.symbol_id,new_body:replacement,expected_sha256:before.sha256}}),'replace-symbol');
+    assert.equal(edited.status,'committed'); assert.equal(edited.symbol_name,'add');
+    const verified=structured(await f.client.callTool({name:'coding_receipt_verify',arguments:{receipt_id:edited.receipt_id}}),'receipt');
+    assert.equal(verified.ok,true); assert.equal(verified.signature_valid,true);
+    assert.match(await readFile(path.join(f.project,'math.ts'),'utf8'),/return a - b/);
+  } finally {await f.client.close().catch(()=>{}); await rm(f.root,{recursive:true,force:true}).catch(()=>{});}
+});

package/test/semantic-lsp-backend.test.mjs

@@ -0,0 +1,108 @@
+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 { fileURLToPath } from 'node:url';
+import { createSemanticLspBackend } from '../src/semantic-lsp-backend.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const fixture=path.join(here,'fixtures','lsp-framed-server.mjs');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const nodeSha=sha256(await readFile(process.execPath));
+
+async function makeFixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-lsp-backend-'));
+  const source='export function alpha() {}\n';
+  await writeFile(path.join(root,'main.foo'),source,'utf8');
+  const codingRuntime={
+    policy:{roots:{project:{real_path:root,read:true,write:true,exec:false,deny_paths:['denied']}}},
+    async sessionStatus(){return {armed:true,reason:'standing-grant',root_ids:['project']};},
+    async fileRead({rootId,relativePath}){assert.equal(rootId,'project');const content=await readFile(path.join(root,relativePath),'utf8');return {status:'ok',content,sha256:sha256(Buffer.from(content,'utf8'))};},
+    async textReplace({rootId,relativePath,oldString,newString,expectedSha256,expectedReplacements}){
+      assert.equal(rootId,'project');assert.equal(expectedReplacements,1);
+      const file=path.join(root,relativePath);const before=await readFile(file,'utf8');assert.equal(sha256(Buffer.from(before)),expectedSha256);
+      const count=before.split(oldString).length-1;assert.equal(count,1);const after=before.replace(oldString,newString);await writeFile(file,after,'utf8');
+      return {status:'committed',receipt_id:'f'.repeat(24),sha256:sha256(Buffer.from(after))};
+    }
+  };
+  const backend=createSemanticLspBackend({id:'fixture-lsp',extensions:['.foo'],codingRuntime,server:{executable_path:process.execPath,executable_sha256:nodeSha,args:[fixture],initialization_options:{fixture:true},request_timeout_ms:1000,max_message_bytes:131072}});
+  return {root,source,codingRuntime,backend};
+}
+
+test('semantic LSP backend normalizes outline definition references diagnostics and receipt-path replacement',async()=>{
+  const f=await makeFixture();
+  try{
+    const outline=await f.backend.outline({rootId:'project',relativePath:'main.foo',maxSymbols:10});
+    assert.equal(outline.engine,'fixture-lsp');assert.equal(outline.symbols.length,1);
+    const symbol=outline.symbols[0];assert.equal(symbol.name,'alpha');assert.match(symbol.symbol_id,/^[0-9a-f]{64}$/);
+    const def=await f.backend.definition({rootId:'project',relativePath:'main.foo',line:0,column:18,maxResults:10});
+    assert.equal(def.locations[0].path,'main.foo');assert.equal(def.locations[0].start_column,16);
+    const refs=await f.backend.references({rootId:'project',relativePath:'main.foo',line:0,column:18,maxResults:10});
+    assert.equal(refs.locations[0].path,'main.foo');
+    const diagnostics=await f.backend.diagnostics({rootId:'project',relativePath:'main.foo',maxResults:10});
+    assert.equal(diagnostics.diagnostics[0].message,'fixture diagnostic');
+    assert.match(diagnostics.file_sha256,/^[0-9a-f]{64}$/); assert.match(diagnostics.result_sha256,/^[0-9a-f]{64}$/);
+    const implementations=await f.backend.implementations({rootId:'project',relativePath:'main.foo',line:0,column:18,maxResults:10});
+    assert.equal(implementations.status,'ok'); assert.equal(implementations.locations[0].path,'main.foo'); assert.match(implementations.result_sha256,/^[0-9a-f]{64}$/);
+    const unsupportedImpl=await f.backend.implementations({rootId:'project',relativePath:'main.foo',line:0,column:999,maxResults:10});
+    assert.equal(unsupportedImpl.status,'unsupported'); assert.equal(unsupportedImpl.capability,'implementations');
+    const rename=await f.backend.renameEdits({rootId:'project',relativePath:'main.foo',line:0,column:18,newName:'gamma'});
+    assert.equal(rename.status,'ok'); assert.deepEqual(rename.edits,[{path:'main.foo',start:16,length:5,new_text:'gamma'}]);
+    const unsupportedRename=await f.backend.renameEdits({rootId:'project',relativePath:'main.foo',line:0,column:18,newName:'UNSUPPORTED'});
+    assert.equal(unsupportedRename.status,'unsupported'); assert.equal(unsupportedRename.capability,'rename_preview');
+    const before=await f.codingRuntime.fileRead({rootId:'project',relativePath:'main.foo'});
+    const edited=await f.backend.replaceSymbol({rootId:'project',relativePath:'main.foo',symbolId:symbol.symbol_id,newBody:'export function beta() {}',expectedSha256:before.sha256});
+    assert.equal(edited.status,'committed');assert.equal(edited.symbol_name,'alpha');assert.equal(edited.engine,'fixture-lsp');
+    assert.equal(await readFile(path.join(f.root,'main.foo'),'utf8'),'export function beta() {}\n');
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('semantic LSP backend rejects targets outside lease/root policy before launching server',async()=>{
+  const f=await makeFixture();
+  try{
+    await assert.rejects(f.backend.outline({rootId:'missing',relativePath:'main.foo',maxSymbols:10}),/outside active lease/i);
+    await assert.rejects(f.backend.outline({rootId:'project',relativePath:'denied/main.foo',maxSymbols:10}),/denied/i);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('semantic LSP backend forwards dependency pins before launching server',async()=>{
+  const f=await makeFixture();
+  try{
+    const backend=createSemanticLspBackend({id:'fixture-pinned',extensions:['.foo'],codingRuntime:f.codingRuntime,server:{executable_path:process.execPath,executable_sha256:nodeSha,args:[fixture],dependencies:[{path:fixture,expectedSha256:'0'.repeat(64)}],request_timeout_ms:1000,max_message_bytes:131072}});
+    await assert.rejects(backend.outline({rootId:'project',relativePath:'main.foo',maxSymbols:10}),/LSP dependency SHA-256 mismatch/i);
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('semantic LSP backend separates engine id from LSP language id',async()=>{
+  const f=await makeFixture();
+  try{
+    const fixtureSha=sha256(await readFile(fixture));
+    const backend=createSemanticLspBackend({id:'fixture-engine',extensions:['.foo'],codingRuntime:f.codingRuntime,server:{language_id:'fixture-language',executable_path:process.execPath,executable_sha256:nodeSha,args:[fixture],dependencies:[{path:fixture,expectedSha256:fixtureSha}],initialization_options:{expectedLanguageId:'fixture-language'},request_timeout_ms:1000,max_message_bytes:131072}});
+    const outline=await backend.outline({rootId:'project',relativePath:'main.foo',maxSymbols:10});
+    assert.equal(outline.engine,'fixture-engine');
+    assert.equal(outline.symbols[0].name,'alpha');
+  } finally {await rm(f.root,{recursive:true,force:true});}
+});
+
+test('semantic LSP backend pre-opens bounded same-language project files for deterministic cross-file navigation',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-lsp-project-'));
+  await writeFile(path.join(root,'main.foo'),'export function main() { return alpha(); }\n','utf8');
+  await writeFile(path.join(root,'peer.foo'),'export function alpha() { return 1; }\n','utf8');
+  const codingRuntime={
+    policy:{roots:{project:{real_path:root,read:true,write:true,exec:false,deny_paths:[]}}},
+    async sessionStatus(){return {armed:true,reason:'standing-grant',root_ids:['project']};},
+    async tree(){return {truncated:false,entries:[{type:'file',path:'main.foo'},{type:'file',path:'peer.foo'}]};},
+    async fileRead({relativePath}){const content=await readFile(path.join(root,relativePath),'utf8');return {status:'ok',content,sha256:sha256(Buffer.from(content,'utf8'))};},
+    async textReplace(){throw new Error('not used');}
+  };
+  try{
+    const fixtureSha=sha256(await readFile(fixture));
+    const backend=createSemanticLspBackend({id:'fixture-project',extensions:['.foo'],codingRuntime,server:{language_id:'fixture-language',executable_path:process.execPath,executable_sha256:nodeSha,args:[fixture],dependencies:[{path:fixture,expectedSha256:fixtureSha}],initialization_options:{expectedLanguageId:'fixture-language',requiredOpenCount:2},request_timeout_ms:1000,max_message_bytes:131072}});
+    const definition=await backend.definition({rootId:'project',relativePath:'main.foo',line:0,column:18,maxResults:10});
+    assert.ok(definition.locations.some(item=>item.path==='peer.foo'),JSON.stringify(definition.locations));
+    const references=await backend.references({rootId:'project',relativePath:'main.foo',line:0,column:18,maxResults:10});
+    assert.ok(references.locations.some(item=>item.path==='peer.foo'),JSON.stringify(references.locations));
+  } finally {await rm(root,{recursive:true,force:true});}
+});