deadbyte-mcp 0.9.0 → 0.10.0

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

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

@@ -0,0 +1,102 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  CAPABILITY_LEDGER_SCHEMA,
+  capabilityProfileFromEnv,
+  createCapabilityLedger,
+  assertCapabilityClosure
+} from '../src/capability-ledger.mjs';
+
+const entry = overrides => ({
+  id:'coding.search',
+  full_tool:'coding_search',
+  compact_tool:'coding_inspect',
+  compact_op:'search',
+  runtime_flag:'DEADBYTE_CODING_RUNTIME',
+  authority:'coding',
+  mutating:false,
+  receipt_class:'observation',
+  production:true,
+  host_only:false,
+  ...overrides
+});
+
+const snapshot = names => ({
+  schema:'deadbyte.tool-surface.v1',
+  tools:names.map(name=>({name,input_sha256:'0'.repeat(64),output_sha256:'1'.repeat(64)})),
+  surface_sha256:'2'.repeat(64)
+});
+
+test('R36 capability ledger rejects duplicate ids', () => {
+  assert.throws(() => createCapabilityLedger([
+    entry({}),
+    entry({full_tool:'other_tool'})
+  ]), /duplicate capability id/i);
+});
+
+test('R36 capability ledger validates authority and canonicalizes identity', () => {
+  assert.throws(() => createCapabilityLedger([entry({authority:'root'})]), /authority/i);
+  const a=createCapabilityLedger([
+    entry({id:'process.read',full_tool:'process_session_read',compact_tool:'process_session',compact_op:'read',runtime_flag:'DEADBYTE_PROCESS_RUNTIME',authority:'process'}),
+    entry({})
+  ]);
+  const b=createCapabilityLedger([
+    entry({}),
+    entry({id:'process.read',full_tool:'process_session_read',compact_tool:'process_session',compact_op:'read',runtime_flag:'DEADBYTE_PROCESS_RUNTIME',authority:'process'})
+  ]);
+  assert.equal(a.schema,CAPABILITY_LEDGER_SCHEMA);
+  assert.equal(a.ledger_sha256,b.ledger_sha256);
+  assert.deepEqual(a.entries.map(x=>x.id),['coding.search','process.read']);
+  assert.ok(Object.isFrozen(a));
+  assert.ok(Object.isFrozen(a.entries));
+});
+
+test('R36 surface profile defaults full and accepts only full or compact', () => {
+  assert.equal(capabilityProfileFromEnv({}),'full');
+  assert.equal(capabilityProfileFromEnv({DEADBYTE_CAPABILITY_PROFILE:'full'}),'full');
+  assert.equal(capabilityProfileFromEnv({DEADBYTE_CAPABILITY_PROFILE:'compact'}),'compact');
+  assert.throws(() => capabilityProfileFromEnv({DEADBYTE_CAPABILITY_PROFILE:'wide'}), /full or compact/i);
+});
+
+test('R36 compact closure covers every production non-host capability', () => {
+  const ledger=createCapabilityLedger([
+    entry({}),
+    entry({id:'host.exec',full_tool:'host_exec',compact_tool:null,compact_op:null,runtime_flag:'DEADBYTE_PRIVILEGED_POLICY',authority:'host',mutating:true,receipt_class:'host',production:false,host_only:true})
+  ]);
+  assert.equal(assertCapabilityClosure({
+    ledger,
+    fullToolSnapshot:snapshot(['coding_search','host_exec']),
+    compactToolSnapshot:snapshot(['coding_inspect'])
+  }),true);
+});
+
+test('R36 closure fails when a production route is lost or advertised tool is absent', () => {
+  const missingCompact=createCapabilityLedger([entry({compact_tool:null,compact_op:null})]);
+  assert.throws(() => assertCapabilityClosure({
+    ledger:missingCompact,
+    fullToolSnapshot:snapshot(['coding_search']),
+    compactToolSnapshot:snapshot([])
+  }), /compact route/i);
+
+  const ledger=createCapabilityLedger([entry({})]);
+  assert.throws(() => assertCapabilityClosure({
+    ledger,
+    fullToolSnapshot:snapshot([]),
+    compactToolSnapshot:snapshot(['coding_inspect'])
+  }), /full tool/i);
+  assert.throws(() => assertCapabilityClosure({
+    ledger,
+    fullToolSnapshot:snapshot(['coding_search']),
+    compactToolSnapshot:snapshot([])
+  }), /compact tool/i);
+});
+
+test('R36 compact surface hard-fails above the observed 42-tool ceiling', () => {
+  const ledger=createCapabilityLedger([entry({})]);
+  const tooMany=Array.from({length:43},(_,i)=>i===0?'coding_inspect':`extra_${i}`);
+  assert.throws(() => assertCapabilityClosure({
+    ledger,
+    fullToolSnapshot:snapshot(['coding_search']),
+    compactToolSnapshot:snapshot(tooMany)
+  }), /42/i);
+});

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

@@ -8,7 +8,7 @@ const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const expected=[
   '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_task_approve','coding_task_cancel',
+  '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'
 ].sort();
 function extract(source){
@@ -17,7 +17,7 @@ function extract(source){
   return [...m[1].matchAll(/'([^']+)'/g)].map(x=>x[1]).sort();
 }
 for(const rel of ['src/machine-fs-smoke-client.mjs','src/observation-smoke-client.mjs','src/remote-mcp-coding-smoke-client.mjs','src/remote-mcp-smoke-client.mjs']){
-  test(`${rel} uses the exact R34 22-tool coding catalog`,async()=>{
+  test(`${rel} uses the exact R36 25-tool coding catalog`,async()=>{
     const source=await readFile(path.join(root,...rel.split('/')),'utf8');
     assert.deepEqual(extract(source),expected);
   });

package/test/coding-plane.test.mjs

@@ -15,7 +15,7 @@ const serverPath = path.join(repoRoot, 'src', 'mcp-server.mjs');
 const workspaceRoot = path.join(repoRoot, 'workspaces');
 const codingTools = [
   'coding_benchmark_run', 'coding_command_run', 'coding_file_read', 'coding_file_write', 'coding_files_read',
-  'coding_receipt_verify', 'coding_search', 'coding_session_status', 'coding_stat', 'coding_symbol_definition', 'coding_symbol_outline', 'coding_symbol_references', 'coding_symbol_replace', 'coding_task_approve', 'coding_task_cancel',
+  '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'
 ];
@@ -69,7 +69,7 @@ async function fixture() {
   return { root, client, transport };
 }
 
-test('R34 hermetic coding fixture exposes the exact 34-tool no-host catalog', async () => {
+test('R36 hermetic coding fixture exposes the exact 37-tool no-host catalog', async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);

package/test/coding-runtime.test.mjs

@@ -56,6 +56,22 @@ test('coding plane edits files under lease and verifies signed action receipts',
   } finally { await rm(f.root, { recursive: true, force: true }); }
 });
 
+test('R36 coding stat exposes mutation-relevant observation identity', async () => {
+  const f = await fixture();
+  try {
+    await writeFile(path.join(f.project,'stat.txt'),'stat-body\n');
+    const value=await f.runtime.stat({rootId:'project',relativePath:'stat.txt',hash:true});
+    assert.equal(value.status,'ok');
+    assert.equal(value.normalized_path,'stat.txt');
+    assert.equal(value.type,'file');
+    assert.equal(value.reparse_state,'none');
+    assert.match(value.sha256,/^[0-9a-f]{64}$/);
+    assert.match(value.object_identity_sha256,/^[0-9a-f]{64}$/);
+    assert.match(value.observation_sha256,/^[0-9a-f]{64}$/);
+    assert.equal(value.policy_root_id,'project');
+  } finally { await rm(f.root, { recursive: true, force: true }); }
+});
+
 test('coding plane rejects mutation when lease is absent or precondition is stale', async () => {
   const f = await fixture({ armed: false });
   try {

package/test/coding-search-r36.test.mjs

@@ -0,0 +1,90 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { createSearchCursorCodec } from '../src/search-cursor.mjs';
+import { createCodingSearch } from '../src/coding-search.mjs';
+
+async function fixture(){
+  const temp=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r36-search-'));
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(temp,'private.pem'),publicKeyPath:path.join(temp,'public.pem')});
+  const state=new Map([
+    ['src/a.txt',Buffer.from('foo1 foo2\nbar foo3\n','utf8')],
+    ['src/b.txt',Buffer.from('other FOO4 and foo5\n','utf8')],
+    ['src/foo-file.js',Buffer.from('nothing here\n','utf8')],
+    ['src/binary.bin',Buffer.from([0xff,0xfe,0x00,0x61])]
+  ]);
+  let reads=0;
+  const tree=async()=>({status:'ok',root_id:'core',path:'.',truncated:false,entries:[...state].map(([p,b])=>({path:p,type:'file',bytes:b.length}))});
+  const fileRead=async({relativePath,encoding})=>{
+    reads+=1;
+    const bytes=state.get(relativePath);
+    if(!bytes) throw new Error('missing');
+    return {status:'ok',root_id:'core',path:relativePath,encoding,bytes:bytes.length,sha256:(await import('node:crypto')).createHash('sha256').update(bytes).digest('hex'),content:encoding==='base64'?bytes.toString('base64'):bytes.toString('utf8')};
+  };
+  const cursorCodec=createSearchCursorCodec({signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const search=createCodingSearch({tree,fileRead,cursorCodec});
+  return {temp,state,search,get reads(){return reads;},cleanup:()=>rm(temp,{recursive:true,force:true})};
+}
+
+test('R36 regex search returns multiple matches per file with deterministic signed paging',async()=>{
+  const f=await fixture();
+  try{
+    const first=await f.search({rootId:'core',path:'.',target:'content',mode:'regex',pattern:'foo\\d',caseSensitive:false,pageSize:2,maxResults:20});
+    assert.equal(first.matches.length,2);
+    assert.deepEqual(first.matches.map(x=>[x.path,x.line,x.column]),[['src/a.txt',1,1],['src/a.txt',1,6]]);
+    assert.match(first.query_sha256,/^[0-9a-f]{64}$/);
+    assert.match(first.snapshot_sha256,/^[0-9a-f]{64}$/);
+    assert.match(first.page_sha256,/^[0-9a-f]{64}$/);
+    assert.ok(first.next_cursor);
+    const second=await f.search({rootId:'core',path:'.',target:'content',mode:'regex',pattern:'foo\\d',caseSensitive:false,pageSize:2,maxResults:20,cursor:first.next_cursor});
+    assert.equal(second.matches.length,2);
+    assert.deepEqual(second.matches.map(x=>x.path),['src/a.txt','src/b.txt']);
+    assert.notEqual(second.page_sha256,first.page_sha256);
+  } finally {await f.cleanup();}
+});
+
+test('R36 path search does not decode file content and is deterministic',async()=>{
+  const f=await fixture();
+  try{
+    const result=await f.search({rootId:'core',target:'path',mode:'literal',pattern:'foo-file',pageSize:10,maxResults:20});
+    assert.equal(result.matches.length,1);
+    assert.equal(result.matches[0].path,'src/foo-file.js');
+    assert.equal(result.matches[0].line,null);
+    assert.equal(result.bytes_scanned,0);
+    assert.equal(f.reads,0);
+  } finally {await f.cleanup();}
+});
+
+test('R36 search cursor is query-bound and stale snapshot fails closed',async()=>{
+  const f=await fixture();
+  try{
+    const first=await f.search({rootId:'core',target:'content',mode:'literal',pattern:'foo',pageSize:1,maxResults:20});
+    await assert.rejects(()=>f.search({rootId:'core',target:'content',mode:'literal',pattern:'bar',pageSize:1,maxResults:20,cursor:first.next_cursor}),/cursor.*query/i);
+    f.state.set('src/a.txt',Buffer.from('foo1 changed same workflow\n','utf8'));
+    await assert.rejects(()=>f.search({rootId:'core',target:'content',mode:'literal',pattern:'foo',pageSize:1,maxResults:20,cursor:first.next_cursor}),/cursor.*stale|snapshot/i);
+  } finally {await f.cleanup();}
+});
+
+test('R36 invalid regex fails before repository file reads and binary is classified',async()=>{
+  const f=await fixture();
+  try{
+    await assert.rejects(()=>f.search({rootId:'core',target:'content',mode:'regex',pattern:'[unterminated'}),/regex/i);
+    assert.equal(f.reads,0);
+    const result=await f.search({rootId:'core',target:'content',mode:'literal',pattern:'foo',pageSize:20,maxResults:20});
+    assert.equal(result.binary_files_skipped,1);
+    assert.ok(result.matches.length>=5);
+  } finally {await f.cleanup();}
+});
+
+test('R36 scan-byte bound truncates deterministically',async()=>{
+  const f=await fixture();
+  try{
+    const result=await f.search({rootId:'core',target:'content',mode:'literal',pattern:'foo',maxScanBytes:10,pageSize:20,maxResults:20});
+    assert.equal(result.truncated,true);
+    assert.equal(result.truncation_reason,'scan_byte_limit');
+    assert.ok(result.bytes_scanned<=10);
+  } finally {await f.cleanup();}
+});