deadbyte-mcp 0.9.0 → 0.11.0

package/src/semantic-code.mjs

@@ -149,7 +149,7 @@ export function createTypeScriptSemanticBackend({codingRuntime}){
   }
   async function diagnostics({rootId,relativePath,maxResults=200}){
     if(!Number.isInteger(maxResults)||maxResults<1||maxResults>500) throw new Error('max_results must be in [1, 500]');
-    await codingRuntime.fileRead({rootId,relativePath,encoding:'utf8'});
+    const file=await codingRuntime.fileRead({rootId,relativePath,encoding:'utf8'});
     const project=await buildProject(codingRuntime,rootId); const target=targetFile(project,relativePath);
     const all=[...project.service.getSyntacticDiagnostics(target.absolute),...project.service.getSemanticDiagnostics(target.absolute)];
     const diagnosticsOut=all.slice(0,maxResults).map(item=>{
@@ -157,23 +157,90 @@ export function createTypeScriptSemanticBackend({codingRuntime}){
       const loc=locationFromSpan(project,target.absolute,span,'','diagnostic');
       return {message:ts.flattenDiagnosticMessageText(item.messageText,'\n'),code:String(item.code),severity:diagnosticCategory(item.category),...(loc?{location:loc}:{})};
     });
-    return {status:'ok',root_id:rootId,path:relativePath,engine:`typescript-${ts.version}`,diagnostics:diagnosticsOut,truncated:all.length>maxResults};
+    const stable={root_id:rootId,path:relativePath,file_sha256:file.sha256,engine:`typescript-${ts.version}`,diagnostics:diagnosticsOut,truncated:all.length>maxResults};
+    return {status:'ok',...stable,result_sha256:digest({schema:'deadbyte.semantic-diagnostics.v1',...stable})};
+  }
+  async function implementations({rootId,relativePath,line,column,maxResults=200}){
+    if(!Number.isInteger(maxResults)||maxResults<1||maxResults>500) throw new Error('max_results must be in [1, 500]');
+    const file=await codingRuntime.fileRead({rootId,relativePath,encoding:'utf8'});
+    const project=await buildProject(codingRuntime,rootId); const target=targetFile(project,relativePath); const pos=offsetAt(target.source,line,column);
+    const raw=project.service.getImplementationAtPosition(target.absolute,pos)??[];
+    const locations=raw.map(item=>locationFromSpan(project,item.fileName,item.textSpan,item.name??'',item.kind??'implementation')).filter(Boolean).slice(0,maxResults);
+    const stable={root_id:rootId,path:relativePath,line,column,file_sha256:file.sha256,engine:`typescript-${ts.version}`,locations,truncated:raw.length>maxResults};
+    return {status:'ok',...stable,result_sha256:digest({schema:'deadbyte.semantic-implementations.v1',...stable})};
   }
-  return Object.freeze({id:'typescript',extensions:new Set(SOURCE_EXTENSIONS),outline,definition,references,replaceSymbol,diagnostics});
+  async function renameEdits({rootId,relativePath,line,column,newName}){
+    const file=await codingRuntime.fileRead({rootId,relativePath,encoding:'utf8'});
+    const project=await buildProject(codingRuntime,rootId); const target=targetFile(project,relativePath); const pos=offsetAt(target.source,line,column);
+    const info=project.service.getRenameInfo(target.absolute,pos,{allowRenameOfImportPath:false});
+    if(!info?.canRename) throw new Error(`semantic rename unavailable: ${info?.localizedErrorMessage??'symbol cannot be renamed'}`);
+    const raw=project.service.findRenameLocations(target.absolute,pos,false,false,true)??[];
+    if(raw.length<1) throw new Error('semantic rename produced no locations');
+    const edits=[];
+    for(const item of raw){
+      const loc=locationFromSpan(project,item.fileName,item.textSpan,'','rename');
+      if(!loc) continue;
+      edits.push({path:loc.path,start:item.textSpan.start,length:item.textSpan.length,new_text:`${item.prefixText??''}${newName}${item.suffixText??''}`});
+    }
+    if(edits.length<1) throw new Error('semantic rename produced no allowed edits');
+    edits.sort((a,b)=>a.path.localeCompare(b.path,'en')||a.start-b.start||a.length-b.length);
+    return {status:'ok',root_id:rootId,path:relativePath,engine:`typescript-${ts.version}`,target_file_sha256:file.sha256,edits};
+  }
+  return Object.freeze({id:'typescript',extensions:new Set(SOURCE_EXTENSIONS),outline,definition,references,replaceSymbol,diagnostics,implementations,renameEdits});
 }
 
-export function createSemanticCodeRuntime({codingRuntime,backends=[]}){
+export function createSemanticCodeRuntime({codingRuntime,backends=[],nativeDiffRuntime=null}){
   if(!codingRuntime) throw new Error('semantic runtime requires coding runtime');
   if(!Array.isArray(backends)) throw new Error('semantic runtime backends must be an array');
   const typescript=createTypeScriptSemanticBackend({codingRuntime});
   const registry=createSemanticBackendRegistry({backends:[typescript,...backends]});
-  const route=(method,args)=>registry.backendForPath(args.relativePath)[method](args);
+  const backendFor=args=>registry.backendForPath(args.relativePath);
+  const route=(method,args)=>{
+    const backend=backendFor(args);
+    if(typeof backend[method]!=='function') return {status:'unsupported',capability:method,engine:backend.id};
+    return backend[method](args);
+  };
+  async function renamePreview({rootId,relativePath,line,column,newName}){
+    if(typeof newName!=='string'||!/^[A-Za-z_$][A-Za-z0-9_$]{0,127}$/.test(newName)) throw new Error('semantic rename new name must be a valid bounded identifier');
+    if(!nativeDiffRuntime||typeof nativeDiffRuntime.preview!=='function') throw new Error('semantic rename preview requires Native Diff runtime');
+    const backend=backendFor({relativePath});
+    if(typeof backend.renameEdits!=='function') return {status:'unsupported',capability:'rename_preview',engine:backend.id};
+    const plan=await backend.renameEdits({rootId,relativePath,line,column,newName});
+    if(plan?.status==='unsupported') return plan;
+    if(!plan||plan.status!=='ok'||!Array.isArray(plan.edits)||plan.edits.length<1) throw new Error('semantic rename backend returned no normalized edits');
+    const groups=new Map();
+    for(const edit of plan.edits){
+      if(!edit||typeof edit.path!=='string'||!Number.isInteger(edit.start)||edit.start<0||!Number.isInteger(edit.length)||edit.length<0||typeof edit.new_text!=='string') throw new Error('semantic rename edit malformed');
+      const list=groups.get(edit.path)??[]; list.push(edit); groups.set(edit.path,list);
+    }
+    const operations=[]; const preimages=[]; let editCount=0;
+    for(const filePath of [...groups.keys()].sort((a,b)=>a.localeCompare(b,'en'))){
+      const file=await codingRuntime.fileRead({rootId,relativePath:filePath,encoding:'utf8'});
+      const edits=[...groups.get(filePath)].sort((a,b)=>a.start-b.start||a.length-b.length);
+      let priorEnd=-1;
+      for(const edit of edits){
+        if(edit.start<priorEnd) throw new Error(`semantic rename overlapping edits in ${filePath}`);
+        if(edit.start+edit.length>file.content.length) throw new Error(`semantic rename edit outside ${filePath}`);
+        priorEnd=edit.start+edit.length;
+      }
+      let next=file.content;
+      for(const edit of [...edits].sort((a,b)=>b.start-a.start)) next=next.slice(0,edit.start)+edit.new_text+next.slice(edit.start+edit.length);
+      operations.push({kind:'write',path:filePath,content:next,encoding:'utf8',expected_sha256:file.sha256});
+      preimages.push({path:filePath,sha256:file.sha256});
+      editCount+=edits.length;
+    }
+    const diff=await nativeDiffRuntime.preview({rootId,title:`semantic rename ${relativePath} -> ${newName}`,operations});
+    return {status:'ready',diff_id:diff.diff_id,affected_files:operations.length,edit_count:editCount,
+      backend:plan.engine??backend.id,preimages};
+  }
   return Object.freeze({
     outline:async args=>route('outline',args),
     definition:async args=>route('definition',args),
     references:async args=>route('references',args),
     replaceSymbol:async args=>route('replaceSymbol',args),
     diagnostics:async args=>route('diagnostics',args),
+    implementations:async args=>route('implementations',args),
+    renamePreview,
     languages:()=>registry.languages()
   });
 }

package/src/semantic-lsp-backend.mjs

@@ -119,7 +119,7 @@ export function createSemanticLspBackend({id,extensions,codingRuntime,server}){
   const open=async ctx=>{
     const client=createLspStdioClient({executablePath:server.executable_path,expectedSha256:server.executable_sha256,args:server.args??[],cwd:ctx.root.real_path,env:server.env??{},dependencies:server.dependencies??[],requestTimeoutMs:server.request_timeout_ms??10000,maxMessageBytes:server.max_message_bytes??4*1024*1024});
     try{
-      await client.initialize({processId:null,rootPath:ctx.root.real_path,rootUri:ctx.rootUri,workspaceFolders:[{uri:ctx.rootUri,name:path.basename(ctx.root.real_path)}],capabilities:{workspace:{workspaceFolders:true},textDocument:{documentSymbol:{hierarchicalDocumentSymbolSupport:true},definition:{},references:{},diagnostic:{}}},initializationOptions:server.initialization_options??{}});
+      await client.initialize({processId:null,rootPath:ctx.root.real_path,rootUri:ctx.rootUri,workspaceFolders:[{uri:ctx.rootUri,name:path.basename(ctx.root.real_path)}],capabilities:{workspace:{workspaceFolders:true},textDocument:{documentSymbol:{hierarchicalDocumentSymbolSupport:true},definition:{},references:{},implementation:{},rename:{prepareSupport:false},diagnostic:{}}},initializationOptions:server.initialization_options??{}});
       for(const document of await workspaceDocuments(ctx)) client.notify('textDocument/didOpen',{textDocument:{uri:document.uri,languageId,version:1,text:document.text}});
       if(startupSettleMs>0) await new Promise(resolve=>setTimeout(resolve,startupSettleMs));
       return client;
@@ -163,7 +163,43 @@ export function createSemanticLspBackend({id,extensions,codingRuntime,server}){
     const raw=await withClient(ctx,client=>requestRead(client,'textDocument/diagnostic',{textDocument:{uri:ctx.uri}}));
     const items=Array.isArray(raw?.items)?raw.items:[];
     const diagnosticsOut=items.slice(0,maxResults).filter(item=>validRange(item?.range)).map(item=>({message:String(item.message??''),code:String(item.code??''),severity:SEVERITY[Number(item.severity)]??'unknown',location:{path:ctx.relativePath,name:'',kind:'diagnostic',start_line:item.range.start.line,start_column:item.range.start.character,end_line:item.range.end.line,end_column:item.range.end.character}}));
-    return {status:'ok',root_id:rootId,path:ctx.relativePath,engine:id,diagnostics:diagnosticsOut,truncated:items.length>maxResults};
+    const stable={root_id:rootId,path:ctx.relativePath,file_sha256:ctx.file.sha256,engine:id,diagnostics:diagnosticsOut,truncated:items.length>maxResults};
+    return {status:'ok',...stable,result_sha256:digest({schema:'deadbyte.semantic-diagnostics.v1',...stable})};
+  }
+  async function implementations({rootId,relativePath,line,column,maxResults=200}){
+    if(!Number.isInteger(maxResults)||maxResults<1||maxResults>500) throw new Error('max_results must be in [1, 500]');
+    const ctx=await rootContext(codingRuntime,rootId,relativePath);
+    let raw;
+    try { raw=await withClient(ctx,client=>requestRead(client,'textDocument/implementation',{textDocument:{uri:ctx.uri},position:{line,character:column}})); }
+    catch(error){ if(/-32601|method not found/i.test(String(error))) return {status:'unsupported',capability:'implementations',engine:id}; throw error; }
+    const normalized=normalizeLocations(raw,ctx,maxResults);
+    const stable={root_id:rootId,path:ctx.relativePath,line,column,file_sha256:ctx.file.sha256,engine:id,...normalized};
+    return {status:'ok',...stable,result_sha256:digest({schema:'deadbyte.semantic-implementations.v1',...stable})};
+  }
+  async function renameEdits({rootId,relativePath,line,column,newName}){
+    const ctx=await rootContext(codingRuntime,rootId,relativePath);
+    let raw;
+    try { raw=await withClient(ctx,client=>requestRead(client,'textDocument/rename',{textDocument:{uri:ctx.uri},position:{line,character:column},newName})); }
+    catch(error){ if(/-32601|method not found/i.test(String(error))) return {status:'unsupported',capability:'rename_preview',engine:id}; throw error; }
+    const byUri=[];
+    if(raw?.changes&&typeof raw.changes==='object') for(const [uri,edits] of Object.entries(raw.changes)) byUri.push({uri,edits});
+    for(const change of raw?.documentChanges??[]){ if(change?.textDocument?.uri&&Array.isArray(change.edits)) byUri.push({uri:change.textDocument.uri,edits:change.edits}); }
+    const normalized=[];
+    for(const group of byUri){
+      let absolute; try{absolute=path.resolve(fileURLToPath(group.uri));}catch{continue;}
+      if(!inside(ctx.root.real_path,absolute)||denied(ctx.root,absolute)) continue;
+      const rel=relNormalized(path.relative(ctx.root.real_path,absolute));
+      const file=await codingRuntime.fileRead({rootId,relativePath:rel,encoding:'utf8'});
+      for(const edit of group.edits??[]){
+        if(!validRange(edit?.range)||typeof edit?.newText!=='string') throw new Error('semantic LSP rename edit malformed');
+        const start=positionToOffset(file.content,edit.range.start); const end=positionToOffset(file.content,edit.range.end);
+        if(end<start) throw new Error('semantic LSP rename range invalid');
+        normalized.push({path:rel,start,length:end-start,new_text:edit.newText});
+      }
+    }
+    if(normalized.length<1) throw new Error('semantic LSP rename produced no allowed edits');
+    normalized.sort((a,b)=>a.path.localeCompare(b.path,'en')||a.start-b.start||a.length-b.length);
+    return {status:'ok',root_id:rootId,path:ctx.relativePath,engine:id,target_file_sha256:ctx.file.sha256,edits:normalized};
   }
   async function replaceSymbol({rootId,relativePath,symbolId,newBody,expectedSha256}){
     if(typeof newBody!=='string'||newBody.length>524288) throw new Error('new_body exceeds 524288 characters');
@@ -179,5 +215,5 @@ export function createSemanticLspBackend({id,extensions,codingRuntime,server}){
     const result=await codingRuntime.textReplace({rootId,relativePath:ctx.relativePath,oldString:oldBody,newString:newBody,expectedSha256,expectedReplacements:1});
     return {...result,symbol_id:symbolId,symbol_name:symbol.name,engine:id};
   }
-  return Object.freeze({id,extensions:extensionSet,outline,definition,references,replaceSymbol,diagnostics});
+  return Object.freeze({id,extensions:extensionSet,outline,definition,references,replaceSymbol,diagnostics,implementations,renameEdits});
 }

package/src/version.mjs

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

package/src/worker-scheduler.mjs

@@ -0,0 +1,53 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const WORKER_SCHEDULER_SCHEMA='deadbyte.worker-scheduler.v1';
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+
+export function createWorkerScheduler({maxConcurrent=1,totalCpuUnits=1,totalMemoryMb=1024,leaseMs=60000,clock=()=>Date.now()}={}){
+  if(!Number.isInteger(maxConcurrent)||maxConcurrent<1) throw new Error('maxConcurrent invalid');
+  if(!Number.isInteger(totalCpuUnits)||totalCpuUnits<1) throw new Error('totalCpuUnits invalid');
+  if(!Number.isInteger(totalMemoryMb)||totalMemoryMb<1) throw new Error('totalMemoryMb invalid');
+  if(!Number.isInteger(leaseMs)||leaseMs<100) throw new Error('leaseMs invalid');
+  const active=new Map(),attempts=new Map(),history=[];
+  function reclaim(){
+    const now=clock();
+    for(const [id,lease] of active) if(lease.expires_at_ms<=now){
+      active.delete(id);history.push({...lease,status:'expired',released_at_ms:now});
+    }
+  }
+  function usage(){
+    return [...active.values()].reduce((x,l)=>({cpu:x.cpu+l.cpu_units,memory:x.memory+l.memory_mb}),{cpu:0,memory:0});
+  }
+  function snapshot(){
+    reclaim();
+    const used=usage();
+    return Object.freeze({schema:WORKER_SCHEDULER_SCHEMA,max_concurrent:maxConcurrent,total_cpu_units:totalCpuUnits,total_memory_mb:totalMemoryMb,
+      active:[...active.values()].sort((a,b)=>a.lease_id.localeCompare(b.lease_id,'en')),
+      history:[...history],used_cpu_units:used.cpu,used_memory_mb:used.memory});
+  }
+  function acquire({taskId,workerClass,cpuUnits=1,memoryMb=128}){
+    reclaim();
+    if(typeof taskId!=='string'||!taskId) throw new Error('taskId invalid');
+    if(typeof workerClass!=='string'||!workerClass) throw new Error('workerClass invalid');
+    if(!Number.isInteger(cpuUnits)||cpuUnits<1||!Number.isInteger(memoryMb)||memoryMb<1) throw new Error('worker resources invalid');
+    const used=usage();
+    if(active.size>=maxConcurrent||used.cpu+cpuUnits>totalCpuUnits||used.memory+memoryMb>totalMemoryMb) throw new Error('worker scheduler capacity exceeded');
+    const attempt=(attempts.get(taskId)??0)+1;attempts.set(taskId,attempt);
+    const issued=clock(),expires=issued+leaseMs;
+    const body={schema:'deadbyte.worker-lease.v1',task_id:taskId,worker_class:workerClass,attempt,cpu_units:cpuUnits,memory_mb:memoryMb,issued_at_ms:issued,expires_at_ms:expires};
+    const lease=Object.freeze({...body,lease_id:sha(body)});
+    active.set(lease.lease_id,lease);
+    return lease;
+  }
+  function heartbeat(leaseId){
+    reclaim();const current=active.get(leaseId);if(!current) throw new Error('worker lease unavailable');
+    const next=Object.freeze({...current,expires_at_ms:clock()+leaseMs});active.set(leaseId,next);return next;
+  }
+  function release(leaseId,{status='completed'}={}){
+    reclaim();const lease=active.get(leaseId);if(!lease) throw new Error('worker lease unavailable');
+    active.delete(leaseId);const item={...lease,status,released_at_ms:clock()};history.push(item);
+    return Object.freeze({status:'released',lease:item});
+  }
+  return Object.freeze({acquire,heartbeat,release,snapshot});
+}

package/test/autonomous-capability-r36.test.mjs

@@ -0,0 +1,151 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parseR34PlannerDecision, buildPlannerPrompt } from '../src/autonomous-planner.mjs';
+import { judgeProgress } from '../src/autonomous-progress.mjs';
+import { createR34Fixture, sendPlannerDecision, planCreateDecision, inspectDecision } from './helpers/autonomous-r34-fixture.mjs';
+
+const H='a'.repeat(64);
+const policy={
+  profiles:{},
+  limits:{max_context_bytes:262144,max_files_per_diff:32,max_stalled_cycles:2,max_post_replan_stalls:2,max_replans:8}
+};
+const wrap=action=>JSON.stringify({schema:'deadbyte.autonomous-decision.v2',kind:'act',action});
+
+const typedCases=[
+  ['search',{kind:'search',path:'.',target:'content',mode:'regex',pattern:'foo\\d+',case_sensitive:false,max_results:50,max_file_bytes:262144,max_scan_bytes:1048576,page_size:25,cursor:null}],
+  ['stat',{kind:'stat',path:'src/a.mjs',hash:true}],
+  ['multi_read',{kind:'multi_read',files:[{path:'src/a.mjs',encoding:'utf8'},{path:'src/b.mjs',encoding:'utf8'}],max_total_bytes:131072}],
+  ['semantic_references',{kind:'semantic_references',path:'src/a.mjs',line:1,column:2,max_results:100}],
+  ['semantic_rename_preview',{kind:'semantic_rename_preview',path:'src/a.mjs',line:1,column:2,new_name:'renamed'}],
+  ['native_diff_apply',{kind:'native_diff_apply',diff_id:H,expected_operation_count:1}],
+  ['native_diff_verify',{kind:'native_diff_verify',diff_id:H}],
+  ['process_start',{kind:'process_start',profile_id:'test',cwd:'.',args:[]}],
+  ['process_read',{kind:'process_read',session_id:H,offset:0,max_bytes:65536}],
+  ['process_status',{kind:'process_status',session_id:H}],
+  ['process_action',{kind:'process_action',session_id:H,action_id:'ping'}],
+  ['process_terminate',{kind:'process_terminate',session_id:H}],
+  ['machine_fs_stat',{kind:'machine_fs_stat',path:'src',hash:true}],
+  ['machine_fs_list',{kind:'machine_fs_list',path:'.',cursor:null,limit:100,hash_files:false}],
+  ['machine_fs_read',{kind:'machine_fs_read',path:'src/a.mjs',offset:0,max_bytes:65536,hash_file:true}],
+  ['machine_fs_mkdir',{kind:'machine_fs_mkdir',path:'generated'}],
+  ['machine_fs_move',{kind:'machine_fs_move',source_path:'a.txt',destination_path:'b.txt',expected_source_identity:H}],
+  ['machine_fs_delete',{kind:'machine_fs_delete',path:'empty',expected_source_identity:H}],
+  ['observation_search_start',{kind:'observation_search_start',path:'.',pattern:'FAIL',case_sensitive:false,max_results:100,max_files:1000,max_bytes:1048576,max_file_bytes:262144}],
+  ['observation_search_page',{kind:'observation_search_page',search_id:H,cursor:null,limit:50}],
+  ['observation_system_status',{kind:'observation_system_status'}]
+];
+
+test('R36 planner parses first-class capability actions without delegate wrapper',()=>{
+  for(const [label,action] of typedCases){
+    const parsed=parseR34PlannerDecision(wrap(action),policy);
+    assert.equal(parsed.kind,'act',label);
+    assert.equal(parsed.action.kind,action.kind,label);
+    assert.notEqual(parsed.action.kind,'delegate',label);
+  }
+});
+
+test('R36 legacy delegate is accepted only for a known operation and normalized into typed action',()=>{
+  const parsed=parseR34PlannerDecision(wrap({kind:'delegate',operation:{kind:'process_status',session_id:H}}),policy);
+  assert.equal(parsed.action.kind,'process_status');
+  assert.equal(parsed.action.session_id,H);
+  assert.equal('operation' in parsed.action,false);
+  assert.throws(()=>parseR34PlannerDecision(wrap({kind:'delegate',operation:{kind:'arbitrary_tool',tool_name:'host_exec',args:{}}}),policy),/contract|delegated|unsupported|authority/i);
+});
+
+test('R36 planner prompt exposes configured capability manifest and never advertises Host',()=>{
+  const prompt=buildPlannerPrompt({goal:{title:'x',goal:'fix',acceptance:'tests pass'},policy,view:{mutation_epoch:0,planner_round:0,tree:[],contexts:[],observations:[],recent_decisions:[],active_plan:null,capabilities:{schema:'deadbyte.capability-manifest.v1',ledger_sha256:H,entries:[
+    {id:'coding.search',authority:'coding',mutating:false},
+    {id:'process.start',authority:'process',mutating:true}
+  ]}}});
+  assert.match(prompt,/coding\.search/);
+  assert.match(prompt,/process\.start/);
+  assert.doesNotMatch(prompt,/host\.exec|host_file|host authority/i);
+});
+
+test('R36 progress fingerprint ignores rationale but binds capability, evidence, session and cursor identity',()=>{
+  const base={before:{mutation_epoch:2},after:{mutation_epoch:2},decision:{kind:'process_read',rationale:'first'},evidence:{capability_id:'process.read',session_id:H,cursor:10,observation_sha256:'b'.repeat(64),receipt_sha256:'c'.repeat(64)}};
+  const a=judgeProgress(base);
+  const prose=judgeProgress({...base,decision:{...base.decision,rationale:'completely different prose'}});
+  assert.equal(a.fingerprint,prose.fingerprint);
+  const cap=judgeProgress({...base,evidence:{...base.evidence,capability_id:'process.status'}});
+  const cursor=judgeProgress({...base,evidence:{...base.evidence,cursor:11}});
+  const session=judgeProgress({...base,evidence:{...base.evidence,session_id:'d'.repeat(64)}});
+  const receipt=judgeProgress({...base,evidence:{...base.evidence,receipt_sha256:'e'.repeat(64)}});
+  assert.notEqual(a.fingerprint,cap.fingerprint);
+  assert.notEqual(a.fingerprint,cursor.fingerprint);
+  assert.notEqual(a.fingerprint,session.fingerprint);
+  assert.notEqual(a.fingerprint,receipt.fingerprint);
+});
+
+test('R36 typed stat executes through the autonomous loop and records capability-bound evidence',async()=>{
+  const f=await createR34Fixture();
+  try{
+    const goal=await f.runtime.submit({submissionId:'r36-typed-stat',rootId:'project',title:'typed stat',goal:'inspect x.txt identity',acceptance:'stat evidence is journaled'});
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:4});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,planCreateDecision());
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,inspectDecision());
+    assert.equal(result.loop.phase,'ACTING');
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'stat',path:'x.txt',hash:true}});
+    assert.equal(result.status,'input_required');
+    assert.equal(result.loop.phase,'VERIFYING');
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const event=journal.events.find(item=>item.type==='delegated_action_completed'&&item.payload?.operation?.kind==='stat');
+    assert.ok(event);
+    assert.equal(event.payload.capability_id,'coding.stat');
+    assert.match(event.payload.result.observation_sha256,/^[0-9a-f]{64}$/);
+  } finally {await f.cleanup();}
+});
+
+test('R36 typed native_diff_apply binds expected operation count and advances mutation epoch only after verified apply',async()=>{
+  const f=await createR34Fixture();
+  try{
+    const preview=await f.nativeDiffRuntime.preview({rootId:'project',title:'typed apply',operations:[{
+      kind:'replace',path:'x.txt',expected_sha256:f.initial_sha256,old_string:'x',new_string:'y',expected_replacements:1
+    }]});
+    assert.equal(preview.operation_count,1);
+    const goal=await f.runtime.submit({submissionId:'r36-typed-apply',rootId:'project',title:'typed apply',goal:'apply the prepared native diff',acceptance:'mutation is verified and journaled'});
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:4});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,planCreateDecision());
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,inspectDecision());
+    assert.equal(result.loop.phase,'ACTING');
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'native_diff_apply',diff_id:preview.diff_id,expected_operation_count:1}});
+    assert.equal(result.status,'input_required');
+    assert.equal(result.loop.phase,'VERIFYING');
+    const state=await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(state.mutation_epoch,1);
+    assert.equal(state.mutation_count,1);
+    const read=await f.baseCodingRuntime.fileRead({rootId:'project',relativePath:'x.txt',encoding:'utf8'});
+    assert.equal(read.content,'y\n');
+    const verified=await f.nativeDiffRuntime.verify({diffId:preview.diff_id});
+    assert.equal(verified.ok,true);
+    assert.equal(verified.current_state_matches,true);
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const committed=journal.events.find(item=>item.type==='native_diff_committed'&&item.payload?.diff_id===preview.diff_id);
+    assert.ok(committed);
+    assert.equal(committed.payload.mutation_count,1);
+    assert.deepEqual(committed.payload.paths,['x.txt']);
+  } finally {await f.cleanup();}
+});
+
+test('R36 typed machine_fs_mkdir is promoted to Native Diff V2 and advances mutation epoch',async()=>{
+  const f=await createR34Fixture();
+  try{
+    const goal=await f.runtime.submit({submissionId:'r36-typed-mkdir',rootId:'project',title:'typed mkdir',goal:'create generated directory transactionally',acceptance:'directory creation is native-diff verified'});
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:4});
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,planCreateDecision());
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,inspectDecision());
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'machine_fs_mkdir',path:'generated'}});
+    assert.equal(result.status,'input_required');
+    assert.equal(result.loop.phase,'VERIFYING');
+    const state=await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(state.mutation_epoch,1);
+    assert.equal(state.mutation_count,1);
+    const dir=await f.machineFsRuntime.state({rootId:'project',relativePath:'generated'});
+    assert.equal(dir.exists,true);
+    assert.equal(dir.kind,'directory');
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const committed=journal.events.find(item=>item.type==='native_diff_committed');
+    assert.ok(committed);
+    assert.deepEqual(committed.payload.paths,['generated']);
+  } finally {await f.cleanup();}
+});

package/test/autonomous-output-contract.test.mjs

@@ -48,7 +48,7 @@ test('R34 run/status output contracts accept only the sanitized public loop proj
   assert.equal(run.structuredContent.loop.phase,'ACTING');
   const status = autonomousStructuredResult(autonomousGoalStatusOutputSchema,{
     status:'ok',goal_id:'1'.repeat(64),goal_sha256:'2'.repeat(64),title:'x',root_id:'project',journal_verified:true,
-    ...baseDerived(),loop:publicLoop
+    run_busy:false,run_owner_pid:null,run_lock_created_at_utc:null,...baseDerived(),loop:publicLoop
   });
   assert.equal(status.structuredContent.loop.pending_action.kind,'patch');
   const approved = autonomousStructuredResult(autonomousGoalApproveOutputSchema,{

package/test/autonomous-runtime.test.mjs

@@ -24,7 +24,7 @@ const r23Tools = [
   'agent_task_approve','agent_task_cancel','agent_task_events','agent_task_run',
   'agent_task_status','agent_task_submit','agent_task_verify',
   'coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_files_read',
-  'coding_receipt_verify','coding_search','coding_session_status','coding_stat','coding_symbol_definition','coding_symbol_outline','coding_symbol_references','coding_symbol_replace',
+  'coding_receipt_verify','coding_search','coding_session_status','coding_stat','coding_symbol_definition','coding_symbol_diagnostics','coding_symbol_implementations','coding_symbol_outline','coding_symbol_references','coding_symbol_rename_preview','coding_symbol_replace',
   'coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run',
   'coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree'
 ];
@@ -75,7 +75,7 @@ async function fixture() {
   return { root, client, transport };
 }
 
-test('R34 hermetic autonomous fixture exposes the exact 46-tool no-host catalog', async () => {
+test('R36 hermetic autonomous fixture exposes the exact 49-tool no-host catalog', async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

package/test/capability-benchmark-r36.test.mjs

@@ -0,0 +1,107 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import {
+  R36_CAPABILITY_BENCHMARK_SCHEMA,
+  normalizeR36BenchmarkCase,
+  buildR36CapabilityBenchmark
+} from '../src/capability-benchmark.mjs';
+import {
+  R36_BENCHMARK_CASE_IDS,
+  r36BenchmarkCaseDefinitions
+} from '../src/capability-benchmark-runner.mjs';
+
+const REQUIRED=Object.freeze([
+  'repository_tree_exploration',
+  'literal_content_search',
+  'regex_content_search',
+  'filename_path_search',
+  'deterministic_search_paging_cancel',
+  'bounded_multi_file_read',
+  'rich_stat_reparse_handling',
+  'stale_edit_race_rejection',
+  'transactional_multi_file_native_diff',
+  'topology_mkdir_move_delete_rollback',
+  'semantic_typescript_navigation',
+  'semantic_python_navigation',
+  'semantic_rust_navigation',
+  'semantic_cpp_navigation',
+  'diagnostics_normalization',
+  'implementation_lookup',
+  'cross_file_rename_transaction',
+  'long_process_lifecycle',
+  'policy_defined_process_action',
+  'process_crash_reconciliation',
+  'autonomous_failing_test_repair',
+  'autonomous_search_semantic_patch_test',
+  'release_gate_finish_without_evidence_refusal',
+  'provider_bridge_interruption_recovery',
+  'remote_result_replay_deduplication',
+  'compact_connector_capability_closure',
+  'live_log_request_before_result',
+  'live_log_redaction',
+  'forged_stale_receipt_rejection',
+  'rollback_r35_restore_r36'
+]);
+const H=c=>c.repeat(64);
+const base={
+  case_id:REQUIRED[0],fixture_sha256:H('a'),correct:true,round_trips:2,bytes_returned:128,elapsed_ms:12.5,
+  stale_rejected:false,recovery_success:true,duplicate_side_effects:0,capability_reachable:true,
+  evidence_verified:true,release_gate_result:'not_applicable',evidence_sha256:H('b')
+};
+
+test('R36 benchmark corpus exposes exactly the 30 approved production coding cases',async()=>{
+  assert.equal(R36_CAPABILITY_BENCHMARK_SCHEMA,'deadbyte.r36-capability-benchmark.v1');
+  assert.deepEqual([...R36_BENCHMARK_CASE_IDS],REQUIRED);
+  const defs=r36BenchmarkCaseDefinitions();
+  assert.equal(defs.length,30);
+  assert.deepEqual(defs.map(item=>item.case_id),REQUIRED);
+  assert.equal(new Set(defs.map(item=>item.case_id)).size,30);
+  for(const item of defs){
+    assert.ok(Array.isArray(item.test_files)&&item.test_files.length>=1,item.case_id);
+    assert.ok(Array.isArray(item.fixture_files)&&item.fixture_files.length>=1,item.case_id);
+    assert.ok(Number.isInteger(item.round_trips)&&item.round_trips>=1,item.case_id);
+    assert.equal(typeof item.capability_reachable,'boolean',item.case_id);
+    assert.equal(typeof item.evidence_verified,'boolean',item.case_id);
+    assert.ok(['passed','blocked','not_applicable'].includes(item.release_gate_result),item.case_id);
+  }
+  const root=path.resolve(fileURLToPath(new URL('../',import.meta.url)));
+  const corpus=JSON.parse(await readFile(path.join(root,'bench','fixtures','corpus.json'),'utf8'));
+  assert.equal(corpus.schema,'deadbyte.r36-capability-corpus.v1');
+  assert.equal(corpus.suite_id,'r36-production-coding-v1');
+  assert.deepEqual(corpus.cases.map(item=>item.case_id),REQUIRED);
+});
+
+test('R36 benchmark case requires reachability, evidence verification and typed release-gate result',()=>{
+  const value=normalizeR36BenchmarkCase(base);
+  assert.equal(value.capability_reachable,true);
+  assert.equal(value.evidence_verified,true);
+  assert.equal(value.release_gate_result,'not_applicable');
+  assert.throws(()=>normalizeR36BenchmarkCase({...base,capability_reachable:undefined}),/reachable/i);
+  assert.throws(()=>normalizeR36BenchmarkCase({...base,evidence_verified:undefined}),/evidence/i);
+  assert.throws(()=>normalizeR36BenchmarkCase({...base,release_gate_result:'maybe'}),/release/i);
+});
+
+test('R36 aggregate fails closed when correctness reachability or evidence proof is missing',()=>{
+  const ok=buildR36CapabilityBenchmark({suite_id:'r36-production-coding-v1',cases:[base]});
+  assert.equal(ok.overall_correct,true);
+  assert.equal(ok.capability_closure,true);
+  assert.equal(ok.evidence_closure,true);
+  assert.equal('score' in ok,false);
+  const unreachable=buildR36CapabilityBenchmark({suite_id:'r36-production-coding-v1',cases:[{...base,capability_reachable:false}]});
+  assert.equal(unreachable.overall_correct,false);
+  assert.equal(unreachable.capability_closure,false);
+  const unverified=buildR36CapabilityBenchmark({suite_id:'r36-production-coding-v1',cases:[{...base,evidence_verified:false}]});
+  assert.equal(unverified.overall_correct,false);
+  assert.equal(unverified.evidence_closure,false);
+});
+
+test('R36 verdict identity is independent of timing and byte-count noise while observation identity retains it',()=>{
+  const first=buildR36CapabilityBenchmark({suite_id:'r36-production-coding-v1',cases:[base]});
+  const noisy=buildR36CapabilityBenchmark({suite_id:'r36-production-coding-v1',cases:[{...base,elapsed_ms:999.25,bytes_returned:999999,evidence_sha256:H('c')}]});
+  assert.match(first.verdict_identity_sha256,/^[0-9a-f]{64}$/);
+  assert.equal(first.verdict_identity_sha256,noisy.verdict_identity_sha256);
+  assert.notEqual(first.observation_sha256,noisy.observation_sha256);
+});

package/test/capability-benchmark-semantic-r36.test.mjs

@@ -0,0 +1,52 @@
+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 serverFixture=path.join(here,'fixtures','lsp-framed-server.mjs');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const nodeSha=sha256(await readFile(process.execPath));
+const fixtureSha=sha256(await readFile(serverFixture));
+
+async function proveNavigation({extension,languageId,engineId}){
+  const root=await mkdtemp(path.join(os.tmpdir(),`deadbyte-r36-${engineId}-`));
+  const main=`main${extension}`; const peer=`peer${extension}`;
+  await writeFile(path.join(root,main),'export function main() { return alpha(); }\n','utf8');
+  await writeFile(path.join(root,peer),'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},{type:'file',path:peer}]};},
+    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 by navigation benchmark');}
+  };
+  try{
+    const backend=createSemanticLspBackend({id:engineId,extensions:[extension],codingRuntime,server:{
+      language_id:languageId,executable_path:process.execPath,executable_sha256:nodeSha,args:[serverFixture],
+      dependencies:[{path:serverFixture,expectedSha256:fixtureSha}],
+      initialization_options:{expectedLanguageId:languageId,requiredOpenCount:2},request_timeout_ms:1000,max_message_bytes:131072
+    }});
+    const definition=await backend.definition({rootId:'project',relativePath:main,line:0,column:18,maxResults:10});
+    const references=await backend.references({rootId:'project',relativePath:main,line:0,column:18,maxResults:10});
+    assert.equal(definition.engine,engineId);
+    assert.ok(definition.locations.some(item=>item.path===peer),JSON.stringify(definition.locations));
+    assert.ok(references.locations.some(item=>item.path===peer),JSON.stringify(references.locations));
+  } finally {await rm(root,{recursive:true,force:true});}
+}
+
+test('R36 benchmark Python symbol navigation',async()=>{
+  await proveNavigation({extension:'.py',languageId:'python',engineId:'pyright-fixture'});
+});
+
+test('R36 benchmark Rust symbol navigation',async()=>{
+  await proveNavigation({extension:'.rs',languageId:'rust',engineId:'rust-analyzer-fixture'});
+});
+
+test('R36 benchmark Cpp symbol navigation',async()=>{
+  await proveNavigation({extension:'.cpp',languageId:'cpp',engineId:'clangd-fixture'});
+});

package/test/capability-claims-r36.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const root=path.resolve(fileURLToPath(new URL('../',import.meta.url)));
+
+test('R36 capability evidence distinguishes documented competitor claims from direct observation and avoids blanket superiority',async()=>{
+  const file=await readFile(path.join(root,'docs','R36-CAPABILITY-EVIDENCE.md'),'utf8');
+  assert.match(file,/https:\/\/github\.com\/wonderwhy-er\/DesktopCommanderMCP/i);
+  assert.match(file,/https:\/\/github\.com\/desktop-commander\/remote-desktop-commander/i);
+  assert.match(file,/https:\/\/github\.com\/oraios\/serena/i);
+  assert.match(file,/documented/i);
+  assert.match(file,/direct_observation/i);
+  assert.match(file,/3a1d668fcc0c3c38362d0c642c5247357ed7ec6063d89b544c7a1c090521c66e/);
+  assert.doesNotMatch(file,/\b(?:best|superior|beats? all|winner|dominates?)\b/i);
+});
+
+test('R36 README points to reproducible capability evidence instead of a tool-count victory claim',async()=>{
+  const file=await readFile(path.join(root,'README.txt'),'utf8');
+  assert.match(file,/R36-CAPABILITY-EVIDENCE\.md/);
+  assert.doesNotMatch(file,/\b(?:most tools|tool-count victory|beats? all|best MCP)\b/i);
+});