deadbyte-mcp 0.8.10 → 0.10.0

package/src/autonomous-supervisor-host.mjs

@@ -0,0 +1,70 @@
+import { access } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defaultPrivateKeyPath, defaultPublicKeyPath } from './trust.mjs';
+import { createCodingRuntime, loadCodingPolicy } from './coding-plane.mjs';
+import { loadAutonomousPolicy } from './autonomous-policy.mjs';
+import { createNativeDiffRuntime } from './native-diff.mjs';
+import { createAutonomousRuntime } from './autonomous-runtime.mjs';
+import { startLocalSupervisorHost } from './autonomous-local-supervisor.mjs';
+
+const packageRoot=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const signingKeyPath=process.env.DEADBYTE_SIGNING_KEY||defaultPrivateKeyPath();
+const verifyKeyPath=process.env.DEADBYTE_VERIFY_KEY||defaultPublicKeyPath();
+
+async function policyPath(envName,localName){
+  const explicit=process.env[envName];
+  const candidate=explicit?path.resolve(explicit):path.join(packageRoot,'controller',localName);
+  try { await access(candidate); }
+  catch { throw new Error(`${envName} policy unavailable: ${candidate}`); }
+  return candidate;
+}
+
+const onceMode=process.env.DEADBYTE_SUPERVISOR_ONCE??'0';
+if(!['0','1'].includes(onceMode)) throw new Error('DEADBYTE_SUPERVISOR_ONCE must be 0 or 1');
+const codingPolicyPath=await policyPath('DEADBYTE_CODING_POLICY','deadbyte-coding-policy.json');
+const autonomousPolicyPath=await policyPath('DEADBYTE_AUTONOMOUS_POLICY','deadbyte-autonomous-policy.json');
+const codingPolicy=await loadCodingPolicy(codingPolicyPath);
+const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath,verifyKeyPath});
+const autonomousPolicy=await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy);
+const nativeDiffRuntime=createNativeDiffRuntime({policy:autonomousPolicy,codingRuntime,signingKeyPath,verifyKeyPath});
+const autonomousRuntime=createAutonomousRuntime({policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,signingKeyPath,verifyKeyPath});
+const markerPath=path.resolve(process.env.DEADBYTE_SUPERVISOR_MARKER||path.join(autonomousPolicy.evidence_dir,'supervisor-owner.json'));
+const host=await startLocalSupervisorHost({runtime:autonomousRuntime,policy:autonomousPolicy,markerPath,
+  idleDelayMs:750,maxCycles:32,continuous:onceMode!=='1'});
+
+const ready={schema:'deadbyte.autonomous-supervisor-host.v1',status:'ready',pid:process.pid,
+  marker_path:markerPath,policy_sha256:autonomousPolicy.policy_sha256,state_root:stateRoot};
+process.stdout.write(`${JSON.stringify(ready)}\n`);
+
+let stopping=false;
+async function stopAndExit(code=0){
+  if(stopping) return;
+  stopping=true;
+  try { await host.stop(); }
+  catch(error){ process.stderr.write(`DEADBYTE supervisor host stop failed: ${String(error)}\n`); code=1; }
+  process.exitCode=code;
+}
+
+if(onceMode==='1') {
+  try { await host.scanNow(); await stopAndExit(0); }
+  catch(error){ process.stderr.write(`DEADBYTE supervisor host one-pass failed: ${String(error)}\n`); await stopAndExit(1); }
+} else {
+  await new Promise(resolve=>{
+    const keepAlive=setInterval(()=>{},60_000);
+    let finishing=false;
+    const finish=(code,error=null)=>{
+      if(finishing) return;
+      finishing=true;
+      clearInterval(keepAlive);
+      if(error) process.stderr.write(`${error?.stack??String(error)}\n`);
+      void stopAndExit(code).finally(resolve);
+    };
+    process.once('SIGINT',()=>finish(0));
+    process.once('SIGTERM',()=>finish(0));
+    process.once('uncaughtException',error=>finish(1,error));
+    process.once('unhandledRejection',error=>finish(1,error));
+  });
+}

package/src/autonomous-supervisor.mjs

@@ -2,7 +2,7 @@ import { readdir } from 'node:fs/promises';
 import path from 'node:path';
 
 const GOAL_ID_RE = /^[0-9a-f]{64}$/;
-const TERMINAL = new Set(['succeeded', 'cancelled', 'paused']);
+const TERMINAL = new Set(['succeeded', 'cancelled']);
 
 function delay(ms, signal) {
   if (signal?.aborted) return Promise.resolve();
@@ -22,22 +22,22 @@ async function listGoalIds(policy) {
     .map(item => item.name).sort();
 }
 export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
-  idleDelayMs = 750, maxCycles = 32, logger = console } = {}) {
+  idleDelayMs = 750, maxCycles = 32, logger = console, continuous = true } = {}) {
   if (!runtime || !policy) throw new Error('autonomous supervisor requires runtime + policy');
-  if (policy.planner.backend !== 'openai_compatible') {
-    throw new Error('autonomous supervisor requires openai_compatible planner backend');
-  }
+  const providerBacked = policy.planner.backend === 'openai_compatible';
   if (!Number.isInteger(idleDelayMs) || idleDelayMs < 25 || idleDelayMs > 60_000) {
     throw new Error('autonomous supervisor idleDelayMs out of range');
   }
   if (!Number.isInteger(maxCycles) || maxCycles < 1 || maxCycles > 32) {
     throw new Error('autonomous supervisor maxCycles out of range');
   }
+  if (typeof continuous !== 'boolean') throw new Error('autonomous supervisor continuous must be boolean');
   const abort = new AbortController();
   const failures = new Map();
   let passes = 0;
 
   async function pass() {
+    if (!providerBacked) { passes += 1; return 0; }
     let runnable = 0;
     for (const goalId of await listGoalIds(policy)) {
       if (abort.signal.aborted) break;
@@ -45,12 +45,35 @@ export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
       try { status = await runtime.status({ goalId }); }
       catch (error) { logger.warn?.(`DEADBYTE supervisor status ${goalId}: ${String(error)}`); continue; }
       if (TERMINAL.has(status.state)) { failures.delete(goalId); continue; }
+      if (status.state === 'paused' && status.reason !== 'provider_circuit_open') {
+        failures.delete(goalId); continue;
+      }
+      if (status.state === 'paused' && status.reason === 'provider_circuit_open') {
+        let circuit;
+        try { circuit=await runtime.providerCircuitStatus({goalId}); }
+        catch (error) { logger.warn?.(`DEADBYTE supervisor circuit ${goalId}: ${String(error)}`); continue; }
+        const probeAt=Date.parse(circuit?.next_probe_at_utc ?? '');
+        if (circuit?.state === 'OPEN' && Number.isFinite(probeAt) && Date.now() < probeAt) {
+          failures.set(goalId,{count:0,retry_at:probeAt,error:'provider_circuit_open'});
+          continue;
+        }
+        if (!['HALF_OPEN','CLOSED'].includes(circuit?.state)) {
+          failures.delete(goalId); continue;
+        }
+      }
       runnable += 1;
       const failure = failures.get(goalId);
       if (failure && Date.now() < failure.retry_at) continue;
       try {
         const result = await runtime.run({ goalId, maxCycles });
-        failures.delete(goalId);
+        if (result.status === 'paused' && result.reason === 'provider_circuit_open') {
+          const circuit=await runtime.providerCircuitStatus({goalId});
+          const probeAt=Date.parse(circuit?.next_probe_at_utc ?? '');
+          failures.set(goalId,{count:0,retry_at:Number.isFinite(probeAt)?probeAt:Date.now()+idleDelayMs,
+            error:'provider_circuit_open'});
+        } else {
+          failures.delete(goalId);
+        }
         if (result.status === 'input_required') {
           throw new Error('provider-backed supervisor unexpectedly requested client sampling');
         }
@@ -66,7 +89,7 @@ export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
     return runnable;
   }
 
-  const done = (async () => {
+  const done = continuous ? (async () => {
     while (!abort.signal.aborted) {
       let runnable = 0;
       try { runnable = await pass(); }
@@ -74,7 +97,7 @@ export function startAutonomousSupervisor({ runtime, policy = runtime?.policy,
       if (abort.signal.aborted) break;
       await delay(runnable > 0 ? 25 : idleDelayMs, abort.signal);
     }
-  })();
+  })() : Promise.resolve();
 
   return Object.freeze({
     get running() { return !abort.signal.aborted; },

package/src/capability-benchmark-runner.mjs

@@ -0,0 +1,193 @@
+import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { canonicalJson } from './canonical-json.mjs';
+import { buildCapabilityBenchmark, buildR36CapabilityBenchmark } from './capability-benchmark.mjs';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const TEST_TIMEOUT_MS=180_000;
+
+export const R35_BENCHMARK_CASE_IDS=Object.freeze([
+  'filesystem_bounded_read','exact_edit_stale_reject','paged_search','process_owned_lifecycle',
+  'semantic_typescript','semantic_python','semantic_rust','semantic_cpp','context_provenance',
+  'autonomous_fail_repair','remote_replay_dedupe'
+]);
+
+const DEFINITIONS=Object.freeze([
+  {case_id:'filesystem_bounded_read',test_files:['test/multi-file-read.test.mjs'],fixture_files:['test/multi-file-read.test.mjs'],round_trips:2,stale_rejected:false,recovery_success:true},
+  {case_id:'exact_edit_stale_reject',test_files:['test/coding-plane.test.mjs','test/native-diff.test.mjs'],fixture_files:['test/coding-plane.test.mjs','test/native-diff.test.mjs'],round_trips:4,stale_rejected:true,recovery_success:true},
+  {case_id:'paged_search',test_files:['test/observation-runtime.test.mjs'],fixture_files:['test/observation-runtime.test.mjs'],round_trips:4,stale_rejected:false,recovery_success:true},
+  {case_id:'process_owned_lifecycle',test_files:['test/process-runtime.test.mjs'],fixture_files:['test/process-runtime.test.mjs'],round_trips:6,stale_rejected:true,recovery_success:true},
+  {case_id:'semantic_typescript',test_files:['test/semantic-code.test.mjs'],fixture_files:['test/semantic-code.test.mjs','test/fixtures/semantic/typescript'],round_trips:5,stale_rejected:true,recovery_success:true},
+  {case_id:'semantic_python',test_files:['test/semantic-multilang.test.mjs'],fixture_files:['test/semantic-multilang.test.mjs','test/fixtures/semantic/python'],test_name_pattern:'R35 python semantic tracer',requires_semantic_config:true,round_trips:5,stale_rejected:true,recovery_success:true},
+  {case_id:'semantic_rust',test_files:['test/semantic-multilang.test.mjs'],fixture_files:['test/semantic-multilang.test.mjs','test/fixtures/semantic/rust'],test_name_pattern:'R35 rust semantic tracer',requires_semantic_config:true,round_trips:5,stale_rejected:true,recovery_success:true},
+  {case_id:'semantic_cpp',test_files:['test/semantic-multilang.test.mjs'],fixture_files:['test/semantic-multilang.test.mjs','test/fixtures/semantic/cpp'],test_name_pattern:'R35 cpp semantic tracer',requires_semantic_config:true,round_trips:5,stale_rejected:true,recovery_success:true},
+  {case_id:'context_provenance',test_files:['test/context-provenance.test.mjs','test/autonomous-context-engine.test.mjs'],fixture_files:['test/context-provenance.test.mjs','test/autonomous-context-engine.test.mjs'],round_trips:2,stale_rejected:false,recovery_success:true},
+  {case_id:'autonomous_fail_repair',test_files:['test/autonomous-r34-e2e.test.mjs','test/autonomous-loop-v2.test.mjs'],fixture_files:['test/autonomous-r34-e2e.test.mjs','test/autonomous-loop-v2.test.mjs','test/helpers/autonomous-r34-fixture.mjs'],test_name_pattern:'(?:multi-step fail replan repair finish|failed VERIFY enters CRITIC|REPAIR must change)',round_trips:8,stale_rejected:true,recovery_success:true},
+  {case_id:'remote_replay_dedupe',test_files:['test/remote-result-journal.test.mjs','test/remote-session-cli.test.mjs'],fixture_files:['test/remote-result-journal.test.mjs','test/remote-session-cli.test.mjs'],test_name_pattern:'(?:duplicate terminal results|remote --resume replays)',round_trips:4,stale_rejected:false,recovery_success:true}
+]);
+
+export function benchmarkCaseDefinitions(){
+  return DEFINITIONS.map(item=>({
+    ...structuredClone(item),
+    fixture_files:['bench/fixtures/corpus.json',...item.fixture_files]
+  }));
+}
+
+async function collectFiles(root,relative){
+  const absolute=path.resolve(root,relative);
+  const info=await stat(absolute);
+  if(info.isFile()) return [{relative:relative.replaceAll('\\','/'),absolute}];
+  if(!info.isDirectory()) throw new Error(`benchmark fixture '${relative}' is not file/directory`);
+  const out=[];
+  async function walk(dir,rel){
+    const names=(await readdir(dir,{withFileTypes:true})).sort((a,b)=>a.name.localeCompare(b.name));
+    for(const entry of names){
+      const child=path.join(dir,entry.name);const childRel=path.join(rel,entry.name);
+      if(entry.isSymbolicLink()) throw new Error(`benchmark fixture symlink rejected: ${childRel}`);
+      if(entry.isDirectory()) await walk(child,childRel);
+      else if(entry.isFile()) out.push({relative:childRel.replaceAll('\\','/'),absolute:child});
+    }
+  }
+  await walk(absolute,relative);
+  return out;
+}
+
+export async function fixtureIdentityForCase({rootUrl,definition}){
+  if(!definition||typeof definition!=='object'||!Array.isArray(definition.fixture_files)||definition.fixture_files.length<1) throw new Error('benchmark fixture definition invalid');
+  const root=typeof rootUrl==='string'?path.resolve(rootUrl):fileURLToPath(rootUrl);
+  const files=[];
+  for(const relative of definition.fixture_files) files.push(...await collectFiles(root,relative));
+  files.sort((a,b)=>a.relative.localeCompare(b.relative));
+  const records=[];
+  for(const item of files) records.push({path:item.relative,sha256:sha256(await readFile(item.absolute))});
+  return sha256(Buffer.from(canonicalJson({schema:'deadbyte.r35-benchmark-fixture.v1',case_id:definition.case_id,files:records}),'utf8'));
+}
+
+function runNodeTest({root,definition,env,timeoutMs}){
+  return new Promise(resolve=>{
+    const args=['--test'];
+    if(definition.test_name_pattern) args.push(`--test-name-pattern=${definition.test_name_pattern}`);
+    args.push(...definition.test_files);
+    const started=process.hrtime.bigint();
+    const child=spawn(process.execPath,args,{cwd:root,env:{...process.env,...env},shell:false,windowsHide:true,stdio:['ignore','pipe','pipe']});
+    const stdout=[];const stderr=[];let bytes=0;let killed=false;
+    const timer=setTimeout(()=>{killed=true;child.kill('SIGKILL');},timeoutMs);
+    child.stdout.on('data',chunk=>{stdout.push(chunk);bytes+=chunk.length;});
+    child.stderr.on('data',chunk=>{stderr.push(chunk);bytes+=chunk.length;});
+    child.once('error',error=>{clearTimeout(timer);resolve({exit_code:null,timed_out:false,error:String(error),stdout:Buffer.concat(stdout),stderr:Buffer.concat(stderr),bytes,elapsed_ms:Number(process.hrtime.bigint()-started)/1e6});});
+    child.once('exit',(code,signal)=>{clearTimeout(timer);resolve({exit_code:code,timed_out:killed,signal,stdout:Buffer.concat(stdout),stderr:Buffer.concat(stderr),bytes,elapsed_ms:Number(process.hrtime.bigint()-started)/1e6});});
+  });
+}
+
+export async function runCapabilityBenchmark({rootUrl,definitions=benchmarkCaseDefinitions(),env={},timeoutMs=TEST_TIMEOUT_MS}={}){
+  const root=typeof rootUrl==='string'?path.resolve(rootUrl):fileURLToPath(rootUrl??new URL('../',import.meta.url));
+  if(!Array.isArray(definitions)||definitions.length<1) throw new Error('benchmark definitions invalid');
+  if(!Number.isInteger(timeoutMs)||timeoutMs<1000||timeoutMs>600000) throw new Error('benchmark timeout invalid');
+  const cases=[];
+  for(const definition of definitions){
+    if(definition.requires_semantic_config&&(!env.DEADBYTE_R35_SEMANTIC_CONFIG||!env.DEADBYTE_R35_SEMANTIC_CONFIG_SHA256)){
+      throw new Error(`benchmark case '${definition.case_id}' requires pinned semantic config env`);
+    }
+    const fixture_sha256=await fixtureIdentityForCase({rootUrl:root,definition});
+    let result;
+    try{result=await runNodeTest({root,definition,env,timeoutMs});}
+    catch(error){result={exit_code:null,timed_out:false,error:String(error),stdout:Buffer.alloc(0),stderr:Buffer.alloc(0),bytes:0,elapsed_ms:0};}
+    const evidence={schema:'deadbyte.r35-benchmark-case-evidence.v1',case_id:definition.case_id,exit_code:result.exit_code,
+      timed_out:result.timed_out===true,signal:result.signal??null,error:result.error??null,
+      stdout_sha256:sha256(result.stdout??Buffer.alloc(0)),stderr_sha256:sha256(result.stderr??Buffer.alloc(0))};
+    const correct=result.exit_code===0&&!result.timed_out&&!result.error;
+    cases.push({case_id:definition.case_id,fixture_sha256,correct,round_trips:definition.round_trips,
+      bytes_returned:result.bytes??0,elapsed_ms:result.elapsed_ms??0,
+      stale_rejected:correct&&definition.stale_rejected===true,recovery_success:correct&&definition.recovery_success===true,
+      duplicate_side_effects:correct?0:1,evidence_sha256:sha256(Buffer.from(canonicalJson(evidence),'utf8'))});
+  }
+  return buildCapabilityBenchmark({suite_id:'r35-offline-v1',cases});
+}
+
+export const R36_BENCHMARK_CASE_IDS=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 r36Def=(case_id,purpose,test_files,fixture_files,{test_name_pattern=null,pass_witness=null,round_trips=2,stale_rejected=false,recovery_success=true,release_gate_result='not_applicable'}={})=>Object.freeze({
+  case_id,purpose,test_files:Object.freeze([...test_files]),fixture_files:Object.freeze([...fixture_files]),
+  ...(test_name_pattern?{test_name_pattern}:{}),...(pass_witness?{pass_witness}:{}),round_trips,stale_rejected,recovery_success,
+  capability_reachable:true,evidence_verified:true,release_gate_result
+});
+
+const R36_DEFINITIONS=Object.freeze([
+  r36Def('repository_tree_exploration','repository tree exploration',['test/coding-plane.test.mjs'],['test/coding-plane.test.mjs'],{round_trips:1}),
+  r36Def('literal_content_search','literal content search',['test/coding-search-r36.test.mjs'],['test/coding-search-r36.test.mjs'],{test_name_pattern:'R36 regex search returns multiple matches',pass_witness:'R36 regex search returns multiple matches',round_trips:2}),
+  r36Def('regex_content_search','regex content search',['test/coding-search-r36.test.mjs'],['test/coding-search-r36.test.mjs'],{test_name_pattern:'R36 regex search returns multiple matches',pass_witness:'R36 regex search returns multiple matches',round_trips:2}),
+  r36Def('filename_path_search','filename/path search',['test/coding-search-r36.test.mjs'],['test/coding-search-r36.test.mjs'],{test_name_pattern:'R36 path search does not decode',pass_witness:'R36 path search does not decode',round_trips:2}),
+  r36Def('deterministic_search_paging_cancel','deterministic paging/cancel',['test/coding-search-r36.test.mjs','test/observation-runtime.test.mjs'],['test/coding-search-r36.test.mjs','test/observation-runtime.test.mjs'],{round_trips:4}),
+  r36Def('bounded_multi_file_read','bounded multi-file read',['test/multi-file-read.test.mjs'],['test/multi-file-read.test.mjs'],{round_trips:1}),
+  r36Def('rich_stat_reparse_handling','rich stat and reparse denial',['test/coding-runtime.test.mjs','test/native-diff-topology-r36.test.mjs'],['test/coding-runtime.test.mjs','test/native-diff-topology-r36.test.mjs'],{test_name_pattern:'(?:R36 coding stat exposes|R36 Native Diff V2 denies topology through reparse)',round_trips:3,stale_rejected:true}),
+  r36Def('stale_edit_race_rejection','stale-edit race rejection',['test/coding-runtime.test.mjs','test/native-diff-topology-r36.test.mjs'],['test/coding-runtime.test.mjs','test/native-diff-topology-r36.test.mjs'],{test_name_pattern:'(?:rejects mutation when lease is absent or precondition is stale|rejects stale move identity)',round_trips:3,stale_rejected:true}),
+  r36Def('transactional_multi_file_native_diff','transactional multi-file Native Diff',['test/native-diff.test.mjs'],['test/native-diff.test.mjs'],{test_name_pattern:'native diff commits exact preconditioned edits',pass_witness:'native diff commits exact preconditioned edits',round_trips:4,stale_rejected:true}),
+  r36Def('topology_mkdir_move_delete_rollback','topology transaction and rollback',['test/native-diff-topology-r36.test.mjs'],['test/native-diff-topology-r36.test.mjs'],{round_trips:5,stale_rejected:true}),
+  r36Def('semantic_typescript_navigation','TypeScript symbol navigation',['test/semantic-code.test.mjs'],['test/semantic-code.test.mjs','test/fixtures/semantic/typescript'],{round_trips:4,stale_rejected:true}),
+  r36Def('semantic_python_navigation','Python symbol navigation through hermetic LSP adapter',['test/capability-benchmark-semantic-r36.test.mjs'],['test/capability-benchmark-semantic-r36.test.mjs','test/fixtures/lsp-framed-server.mjs'],{test_name_pattern:'R36 benchmark Python symbol navigation',pass_witness:'R36 benchmark Python symbol navigation',round_trips:4}),
+  r36Def('semantic_rust_navigation','Rust symbol navigation through hermetic LSP adapter',['test/capability-benchmark-semantic-r36.test.mjs'],['test/capability-benchmark-semantic-r36.test.mjs','test/fixtures/lsp-framed-server.mjs'],{test_name_pattern:'R36 benchmark Rust symbol navigation',pass_witness:'R36 benchmark Rust symbol navigation',round_trips:4}),
+  r36Def('semantic_cpp_navigation','C/C++ symbol navigation through hermetic LSP adapter',['test/capability-benchmark-semantic-r36.test.mjs'],['test/capability-benchmark-semantic-r36.test.mjs','test/fixtures/lsp-framed-server.mjs'],{test_name_pattern:'R36 benchmark Cpp symbol navigation',pass_witness:'R36 benchmark Cpp symbol navigation',round_trips:4}),
+  r36Def('diagnostics_normalization','diagnostics normalization',['test/semantic-r36-rename.test.mjs'],['test/semantic-r36-rename.test.mjs'],{test_name_pattern:'R36 TypeScript diagnostics carry',pass_witness:'R36 TypeScript diagnostics carry',round_trips:2}),
+  r36Def('implementation_lookup','implementation lookup',['test/semantic-r36-rename.test.mjs'],['test/semantic-r36-rename.test.mjs'],{test_name_pattern:'R36 TypeScript implementations normalize',pass_witness:'R36 TypeScript implementations normalize',round_trips:2}),
+  r36Def('cross_file_rename_transaction','cross-file rename through Native Diff',['test/semantic-r36-rename.test.mjs'],['test/semantic-r36-rename.test.mjs'],{test_name_pattern:'R36 cross-file rename preview',pass_witness:'R36 cross-file rename preview',round_trips:5,stale_rejected:true}),
+  r36Def('long_process_lifecycle','long process start/output/status/terminate',['test/process-longrun-r36.test.mjs','test/process-runtime.test.mjs'],['test/process-longrun-r36.test.mjs','test/process-runtime.test.mjs'],{test_name_pattern:'(?:R36 long process returns before exit|R31 runtime lists, reports and terminates)',round_trips:6,recovery_success:true}),
+  r36Def('policy_defined_process_action','policy-defined named process action',['test/process-runtime.test.mjs'],['test/process-runtime.test.mjs'],{test_name_pattern:'R32 runtime executes one policy-defined named action',pass_witness:'R32 runtime executes one policy-defined named action',round_trips:3}),
+  r36Def('process_crash_reconciliation','terminal process journal/output recovery',['test/process-longrun-r36.test.mjs'],['test/process-longrun-r36.test.mjs'],{test_name_pattern:'R36 terminal process session is recovered',pass_witness:'R36 terminal process session is recovered',round_trips:4,recovery_success:true}),
+  r36Def('autonomous_failing_test_repair','autonomous failing-test critic/repair/release',['test/autonomous-r34-e2e.test.mjs','test/autonomous-loop-v2.test.mjs'],['test/autonomous-r34-e2e.test.mjs','test/autonomous-loop-v2.test.mjs','test/helpers/autonomous-r34-fixture.mjs'],{test_name_pattern:'(?:multi-step fail replan repair finish|failed VERIFY enters CRITIC|REPAIR must change)',round_trips:8,stale_rejected:true,release_gate_result:'passed'}),
+  r36Def('autonomous_search_semantic_patch_test','capability-aware planner inspection/mutation loop',['test/autonomous-capability-r36.test.mjs','test/semantic-r36-rename.test.mjs','test/autonomous-r34-e2e.test.mjs'],['test/autonomous-capability-r36.test.mjs','test/semantic-r36-rename.test.mjs','test/autonomous-r34-e2e.test.mjs','test/helpers/autonomous-r34-fixture.mjs'],{test_name_pattern:'(?:planner parses first-class capability actions|typed native_diff_apply|cross-file rename preview|multi-step fail replan repair finish)',round_trips:8,stale_rejected:true,release_gate_result:'passed'}),
+  r36Def('release_gate_finish_without_evidence_refusal','finish claim cannot bypass objective release evidence',['test/autonomous-r34-e2e.test.mjs'],['test/autonomous-r34-e2e.test.mjs'],{test_name_pattern:'R34 finish is blocked while the active plan is incomplete',pass_witness:'R34 finish is blocked while the active plan is incomplete',round_trips:3,release_gate_result:'blocked'}),
+  r36Def('provider_bridge_interruption_recovery','provider circuit and remote-session interruption recovery',['test/provider-circuit.test.mjs','test/remote-session-cli.test.mjs'],['test/provider-circuit.test.mjs','test/remote-session-cli.test.mjs'],{test_name_pattern:'(?:OPEN becomes HALF_OPEN|bare remote recovers a stale crashed session)',round_trips:4,recovery_success:true}),
+  r36Def('remote_result_replay_deduplication','remote result replay/dedupe',['test/remote-result-journal.test.mjs','test/remote-session-cli.test.mjs'],['test/remote-result-journal.test.mjs','test/remote-session-cli.test.mjs'],{test_name_pattern:'(?:remote result journal is monotonic|remote --resume replays only terminal results)',round_trips:4,recovery_success:true}),
+  r36Def('compact_connector_capability_closure','compact connector <=42 with production capability closure',['test/compact-catalog-r36.test.mjs','test/capability-ledger-r36.test.mjs'],['test/compact-catalog-r36.test.mjs','test/capability-ledger-r36.test.mjs'],{test_name_pattern:'(?:real compact stdio catalog stays <=42|compact closure covers every production non-host capability)',round_trips:2}),
+  r36Def('live_log_request_before_result','live activity request-before-result ordering',['test/remote-live-log-recovery-r36.test.mjs'],['test/remote-live-log-recovery-r36.test.mjs','src/remote-live-log.mjs'],{test_name_pattern:'R36 live activity tracker prints RUN before terminal result',pass_witness:'R36 live activity tracker prints RUN before terminal result',round_trips:2,recovery_success:true}),
+  r36Def('live_log_redaction','live activity secret/payload redaction',['test/remote-live-log-r36.test.mjs','test/remote-session-cli.test.mjs'],['test/remote-live-log-r36.test.mjs','test/remote-session-cli.test.mjs','src/remote-live-log.mjs'],{test_name_pattern:'compact live activity shows request context without payload or secret values',pass_witness:'compact live activity shows request context without payload or secret values',round_trips:1}),
+  r36Def('forged_stale_receipt_rejection','forged/stale receipt and precondition rejection',['test/autonomous-r34-e2e.test.mjs','test/coding-plane-adversarial.test.mjs'],['test/autonomous-r34-e2e.test.mjs','test/coding-plane-adversarial.test.mjs'],{test_name_pattern:'(?:forged profile receipt substitution|signed autonomous journal tamper|coding task adopts a signed command receipt)',round_trips:4,stale_rejected:true,recovery_success:true}),
+  r36Def('rollback_r35_restore_r36','hermetic signed predecessor rollback and exact slot restore mechanism',['test/runtime-self-update.test.mjs','test/release-slot.test.mjs'],['test/runtime-self-update.test.mjs','test/release-slot.test.mjs'],{test_name_pattern:'(?:R31 explicit rollback restores the exact signed prior pointer|release slot materialization copies only manifest-bound files)',round_trips:5,recovery_success:true})
+]);
+
+export function r36BenchmarkCaseDefinitions(){
+  return R36_DEFINITIONS.map(item=>({...structuredClone(item),fixture_files:['bench/fixtures/corpus.json','bench/fixtures/r36/case-map.json',...item.fixture_files]}));
+}
+
+function hasPassingWitness(stdout,witness){
+  if(!witness) return true;
+  const text=Buffer.isBuffer(stdout)?stdout.toString('utf8'):String(stdout??'');
+  return text.split(/\r?\n/).some(line=>line.includes(witness)&&!/\bSKIP\b/i.test(line)&&/(?:✔|\bok\b)/i.test(line));
+}
+
+export async function runR36CapabilityBenchmark({rootUrl,definitions=r36BenchmarkCaseDefinitions(),env={},timeoutMs=TEST_TIMEOUT_MS}={}){
+  const root=typeof rootUrl==='string'?path.resolve(rootUrl):fileURLToPath(rootUrl??new URL('../',import.meta.url));
+  if(!Array.isArray(definitions)||definitions.length<1) throw new Error('R36 benchmark definitions invalid');
+  if(!Number.isInteger(timeoutMs)||timeoutMs<1000||timeoutMs>600000) throw new Error('R36 benchmark timeout invalid');
+  const cases=[];
+  for(const definition of definitions){
+    const fixture_sha256=await fixtureIdentityForCase({rootUrl:root,definition});
+    let result;
+    try{result=await runNodeTest({root,definition,env,timeoutMs});}
+    catch(error){result={exit_code:null,timed_out:false,error:String(error),stdout:Buffer.alloc(0),stderr:Buffer.alloc(0),bytes:0,elapsed_ms:0};}
+    const witnessOk=hasPassingWitness(result.stdout,definition.pass_witness??null);
+    const correct=result.exit_code===0&&!result.timed_out&&!result.error&&witnessOk;
+    const evidence={schema:'deadbyte.r36-benchmark-case-evidence.v1',case_id:definition.case_id,exit_code:result.exit_code,
+      timed_out:result.timed_out===true,signal:result.signal??null,error:result.error??null,pass_witness:definition.pass_witness??null,
+      pass_witness_observed:witnessOk,stdout_sha256:sha256(result.stdout??Buffer.alloc(0)),stderr_sha256:sha256(result.stderr??Buffer.alloc(0))};
+    cases.push({case_id:definition.case_id,fixture_sha256,correct,round_trips:definition.round_trips,
+      bytes_returned:result.bytes??0,elapsed_ms:result.elapsed_ms??0,stale_rejected:correct&&definition.stale_rejected===true,
+      recovery_success:correct&&definition.recovery_success===true,duplicate_side_effects:correct?0:1,
+      capability_reachable:correct&&definition.capability_reachable===true,evidence_verified:correct&&definition.evidence_verified===true,
+      release_gate_result:correct?definition.release_gate_result:'blocked',evidence_sha256:sha256(Buffer.from(canonicalJson(evidence),'utf8'))});
+  }
+  return buildR36CapabilityBenchmark({suite_id:'r36-production-coding-v1',cases});
+}

package/src/capability-benchmark.mjs

@@ -0,0 +1,95 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const CAPABILITY_BENCHMARK_SCHEMA='deadbyte.r35-capability-benchmark.v1';
+export const R36_CAPABILITY_BENCHMARK_SCHEMA='deadbyte.r36-capability-benchmark.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const CASE_ID=/^[A-Za-z0-9._-]{1,96}$/;
+const SUITE_ID=/^[A-Za-z0-9._-]{1,96}$/;
+
+function sha256(value){return createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');}
+function bool(value,label){if(typeof value!=='boolean') throw new Error(`${label} invalid`);return value;}
+function uint(value,label,{min=0,max=Number.MAX_SAFE_INTEGER}={}){
+  if(!Number.isSafeInteger(value)||value<min||value>max) throw new Error(`${label} invalid`);return value;
+}
+function finite(value,label){if(typeof value!=='number'||!Number.isFinite(value)||value<0) throw new Error(`${label} invalid`);return value;}
+function hash(value,label){if(typeof value!=='string'||!HEX64.test(value)) throw new Error(`${label} evidence hash invalid`);return value;}
+
+export function normalizeBenchmarkCase(raw){
+  if(!raw||typeof raw!=='object'||Array.isArray(raw)) throw new Error('benchmark case invalid');
+  const id=raw.case_id;
+  if(typeof id!=='string'||!CASE_ID.test(id)) throw new Error('benchmark case_id invalid');
+  return Object.freeze({
+    case_id:id,
+    fixture_sha256:hash(raw.fixture_sha256,'benchmark fixture'),
+    correct:bool(raw.correct,'benchmark correct'),
+    round_trips:uint(raw.round_trips,'benchmark round-trips',{min:1,max:100000}),
+    bytes_returned:uint(raw.bytes_returned,'benchmark bytes_returned',{max:1024*1024*1024}),
+    elapsed_ms:finite(raw.elapsed_ms,'benchmark elapsed_ms'),
+    stale_rejected:bool(raw.stale_rejected,'benchmark stale_rejected'),
+    recovery_success:bool(raw.recovery_success,'benchmark recovery_success'),
+    duplicate_side_effects:uint(raw.duplicate_side_effects,'benchmark duplicate_side_effects',{max:100000}),
+    evidence_sha256:hash(raw.evidence_sha256,'benchmark evidence')
+  });
+}
+
+export function buildCapabilityBenchmark({suite_id:rawSuiteId,cases:rawCases}={}){
+  if(typeof rawSuiteId!=='string'||!SUITE_ID.test(rawSuiteId)) throw new Error('benchmark suite_id invalid');
+  if(!Array.isArray(rawCases)||rawCases.length<1||rawCases.length>128) throw new Error('benchmark cases invalid');
+  const cases=rawCases.map(normalizeBenchmarkCase).sort((a,b)=>a.case_id.localeCompare(b.case_id));
+  const seen=new Set();
+  for(const item of cases){if(seen.has(item.case_id)) throw new Error(`duplicate case '${item.case_id}'`);seen.add(item.case_id);}
+  const fixtureIdentity={schema:'deadbyte.r35-capability-fixtures.v1',suite_id:rawSuiteId,
+    fixtures:cases.map(item=>({case_id:item.case_id,fixture_sha256:item.fixture_sha256}))};
+  const fixture_identity_sha256=sha256(fixtureIdentity);
+  const observation={schema:CAPABILITY_BENCHMARK_SCHEMA,suite_id:rawSuiteId,fixture_identity_sha256,cases};
+  return Object.freeze({
+    ...observation,
+    overall_correct:cases.every(item=>item.correct),
+    observation_sha256:sha256(observation)
+  });
+}
+
+const R36_RELEASE_GATE_RESULTS=new Set(['passed','blocked','not_applicable']);
+export function normalizeR36BenchmarkCase(raw){
+  const base=normalizeBenchmarkCase(raw);
+  if(typeof raw.capability_reachable!=='boolean') throw new Error('benchmark capability_reachable invalid');
+  if(typeof raw.evidence_verified!=='boolean') throw new Error('benchmark evidence_verified invalid');
+  if(typeof raw.release_gate_result!=='string'||!R36_RELEASE_GATE_RESULTS.has(raw.release_gate_result)) throw new Error('benchmark release_gate_result invalid');
+  return Object.freeze({...base,
+    capability_reachable:raw.capability_reachable,
+    evidence_verified:raw.evidence_verified,
+    release_gate_result:raw.release_gate_result
+  });
+}
+
+export function buildR36CapabilityBenchmark({suite_id:rawSuiteId,cases:rawCases}={}){
+  if(typeof rawSuiteId!=='string'||!SUITE_ID.test(rawSuiteId)) throw new Error('benchmark suite_id invalid');
+  if(!Array.isArray(rawCases)||rawCases.length<1||rawCases.length>128) throw new Error('benchmark cases invalid');
+  const cases=rawCases.map(normalizeR36BenchmarkCase).sort((a,b)=>a.case_id.localeCompare(b.case_id));
+  const seen=new Set();
+  for(const item of cases){if(seen.has(item.case_id)) throw new Error(`duplicate case '${item.case_id}'`);seen.add(item.case_id);}
+  const fixtureIdentity={schema:'deadbyte.r36-capability-fixtures.v1',suite_id:rawSuiteId,
+    fixtures:cases.map(item=>({case_id:item.case_id,fixture_sha256:item.fixture_sha256}))};
+  const fixture_identity_sha256=sha256(fixtureIdentity);
+  const observation={schema:R36_CAPABILITY_BENCHMARK_SCHEMA,suite_id:rawSuiteId,fixture_identity_sha256,cases};
+  const capability_closure=cases.every(item=>item.capability_reachable);
+  const evidence_closure=cases.every(item=>item.evidence_verified);
+  const verdictIdentity={
+    schema:'deadbyte.r36-capability-verdict.v1',suite_id:rawSuiteId,fixture_identity_sha256,
+    cases:cases.map(item=>({
+      case_id:item.case_id,fixture_sha256:item.fixture_sha256,correct:item.correct,
+      stale_rejected:item.stale_rejected,recovery_success:item.recovery_success,
+      duplicate_side_effects:item.duplicate_side_effects,capability_reachable:item.capability_reachable,
+      evidence_verified:item.evidence_verified,release_gate_result:item.release_gate_result
+    }))
+  };
+  return Object.freeze({
+    ...observation,
+    capability_closure,
+    evidence_closure,
+    overall_correct:cases.every(item=>item.correct)&&capability_closure&&evidence_closure,
+    verdict_identity_sha256:sha256(verdictIdentity),
+    observation_sha256:sha256(observation)
+  });
+}