deadbyte-mcp 0.8.10 → 0.10.0

package/test/autonomous-r34-e2e.test.mjs

@@ -0,0 +1,338 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile, writeFile } from 'node:fs/promises';
+import {
+  createR34Fixture,sendPlannerDecision,planCreateDecision,inspectDecision,patchDecision,
+  stepCompleteDecision,finishDecision
+} from './helpers/autonomous-r34-fixture.mjs';
+
+test('R34 loop executes plan -> inspect -> act -> verify -> step complete -> finish', async () => {
+  const f = await createR34Fixture();
+  try {
+    const goal = await f.runtime.submit({submissionId:'r34-happy',rootId:'project',title:'repair',
+      goal:'change x to y',acceptance:'x.txt contains y and release evidence verifies'});
+    let result = await f.runtime.run({goalId:goal.goal_id,maxCycles:4});
+    assert.equal(result.status,'input_required');
+
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,planCreateDecision());
+    assert.equal(result.status,'input_required');
+    assert.equal(result.loop.phase,'INSPECTING');
+    let status = await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(status.loop.phase,'INSPECTING');
+    assert.equal(status.loop.plan_version,1);
+    assert.equal(status.loop.current_step.step_id,'repair');
+
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,inspectDecision());
+    assert.equal(result.status,'input_required');
+    status = await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(status.loop.phase,'ACTING');
+
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,patchDecision(f.initial_sha256));
+    assert.equal(result.status,'input_required');
+    assert.equal(await readFile(f.target,'utf8'),'y\n');
+    status = await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(status.loop.phase,'VERIFYING');
+    const afterAct = await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const committed = afterAct.events.find(event=>event.type==='native_diff_committed');
+    assert.ok(committed);
+    assert.ok(afterAct.events.some(event=>event.type==='progress_judged'&&event.payload.verdict==='progress'));
+
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,stepCompleteDecision([{
+      kind:'native_diff',id:'repair-diff',sha256:committed.payload.diff_receipt_sha256
+    }]));
+    assert.equal(result.status,'input_required');
+    status = await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(status.loop.phase,'PLANNING');
+    assert.equal(status.loop.current_step,null);
+
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,finishDecision(),{maxCycles:8});
+    assert.equal(result.status,'completed');
+    status = await f.runtime.status({goalId:goal.goal_id});
+    assert.equal(status.state,'succeeded');
+    assert.equal(status.loop.phase,'COMPLETE');
+    assert.equal(status.loop.plan_version,1);
+    assert.equal((await f.runtime.verify({goalId:goal.goal_id})).ok,true);
+  } finally { await f.cleanup(); }
+});
+
+test('R34 missing authority waits durably and approval resumes the same phase after operator re-arm', async () => {
+  const f = await createR34Fixture();
+  try {
+    const goal = await f.runtime.submit({submissionId:'r34-authority-wait',rootId:'project',title:'repair',
+      goal:'change x to y',acceptance:'verified mutation'});
+    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');
+
+    await f.disarm();
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,patchDecision(f.initial_sha256));
+    assert.equal(result.status,'paused');
+    assert.equal(result.loop.phase,'WAITING');
+    assert.equal(result.loop.wait_reason,'authority_unavailable');
+    assert.equal(await readFile(f.target,'utf8'),'x\n');
+    let journal = await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    assert.equal(journal.events.filter(event=>event.type==='action_started').length,0);
+
+    await f.arm();
+    const approved = await f.runtime.approve({goalId:goal.goal_id,decision:'approve'});
+    assert.equal(approved.status,'approved');
+    assert.equal(approved.loop.phase,'ACTING');
+    const resumed = await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    assert.equal(resumed.status,'input_required');
+    assert.equal(resumed.loop.phase,'ACTING');
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,resumed,patchDecision(f.initial_sha256));
+    assert.equal(result.loop.phase,'VERIFYING');
+    assert.equal(await readFile(f.target,'utf8'),'y\n');
+  } finally { await f.cleanup(); }
+});
+
+test('R34 finish is blocked while the active plan is incomplete', async () => {
+  const f = await createR34Fixture();
+  try {
+    const goal = await f.runtime.submit({submissionId:'r34-finish-blocked',rootId:'project',title:'repair',
+      goal:'change x to y',acceptance:'complete the plan first'});
+    let result = await f.runtime.run({goalId:goal.goal_id,maxCycles:4});
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,planCreateDecision());
+    assert.equal(result.loop.phase,'INSPECTING');
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,finishDecision());
+    assert.equal(result.status,'input_required');
+    assert.equal(result.loop.phase,'INSPECTING');
+    const journal = await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const blocked = journal.events.find(event=>event.type==='plan_guard_blocked');
+    assert.ok(blocked);
+    assert.equal(blocked.payload.reason,'plan_incomplete_blocks_finish');
+    assert.equal(await readFile(f.target,'utf8'),'x\n');
+  } finally { await f.cleanup(); }
+});
+
+test('R34 failed verification enters REPLANNING with regressed progress evidence', async () => {
+  const f = await createR34Fixture({withFailingProfile:true});
+  try {
+    const goal = await f.runtime.submit({submissionId:'r34-verification-regressed',rootId:'project',title:'verify',
+      goal:'inspect then verify x.txt',acceptance:'verification must pass'});
+    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:'run_profile',profile_id:'check'}
+    });
+    assert.equal(result.status,'input_required');
+    assert.equal(result.loop.phase,'REPLANNING');
+    assert.equal(await readFile(f.target,'utf8'),'x\n');
+    const journal = await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const failed = journal.events.find(event=>event.type==='profile_completed'&&event.payload.profile_id==='check');
+    assert.ok(failed);
+    assert.equal(failed.payload.passed,false);
+    const progress = [...journal.events].reverse().find(event=>event.type==='progress_judged');
+    assert.ok(progress);
+    assert.equal(progress.payload.verdict,'regressed');
+    const critic = journal.events.find(event=>event.type==='critic_classified'&&event.payload.failure_class==='verification_failure');
+    assert.ok(critic);
+    assert.equal(critic.payload.evidence_fingerprint,progress.payload.fingerprint);
+    assert.ok(journal.events.some(event=>event.type==='phase_changed'&&event.payload.to==='CRITIC'));
+  } finally { await f.cleanup(); }
+});
+
+test('R34 operator reject cancels a waiting goal without requiring authority re-arm', async () => {
+  const f = await createR34Fixture();
+  try {
+    const goal = await f.runtime.submit({submissionId:'r34-reject-waiting',rootId:'project',title:'repair',
+      goal:'change x to y',acceptance:'verified mutation'});
+    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());
+    await f.disarm();
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,patchDecision(f.initial_sha256));
+    assert.equal(result.loop.phase,'WAITING');
+    const rejected = await f.runtime.approve({goalId:goal.goal_id,decision:'reject'});
+    assert.equal(rejected.status,'rejected');
+    assert.equal(rejected.state,'cancelled');
+    assert.equal(rejected.loop.phase,'WAITING');
+    assert.equal(rejected.loop.wait_reason,'resume_rejected');
+    assert.equal(rejected.loop.pending_approval,false);
+    assert.equal(await readFile(f.target,'utf8'),'x\n');
+  } finally { await f.cleanup(); }
+});
+
+test('R34 stale SHA returns to REPLANNING without force overwrite', async () => {
+  const f = await createR34Fixture();
+  try {
+    const goal = await f.runtime.submit({submissionId:'r34-stale-sha',rootId:'project',title:'repair',
+      goal:'change x to y',acceptance:'never overwrite drifted source'});
+    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');
+    await writeFile(f.target,'external\n');
+    result = await sendPlannerDecision(f.runtime,goal.goal_id,result,patchDecision(f.initial_sha256));
+    assert.equal(await readFile(f.target,'utf8'),'external\n');
+    assert.equal(result.status,'input_required');
+    assert.equal(result.loop.phase,'REPLANNING');
+    const journal = await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    assert.ok(journal.events.some(event=>event.type==='action_precondition_failed'&&event.payload.reason==='stale_sha'));
+    assert.ok(journal.events.some(event=>event.type==='critic_classified'&&event.payload.failure_class==='stale_precondition'));
+    assert.ok(journal.events.some(event=>event.type==='phase_changed'&&event.payload.to==='CRITIC'));
+    assert.equal(journal.events.filter(event=>event.type==='native_diff_committed').length,0);
+  } finally { await f.cleanup(); }
+});
+
+test('R34 forged profile receipt substitution enters WAITING without replay', async () => {
+  let receiptDurable=false;
+  let crashOnce=true;
+  let commandCalls=0;
+  const f = await createR34Fixture({withFailingProfile:true,codingRuntimeFactory:base=>Object.freeze({...base,
+    commandRun:async args=>{ commandCalls+=1; const result=await base.commandRun(args); receiptDurable=true; return result; },
+    verifyReceiptDetailed:async receiptId=>{
+      const checked=await base.verifyReceiptDetailed(receiptId);
+      if(receiptDurable&&crashOnce){ crashOnce=false; throw new Error('simulated crash after profile receipt'); }
+      return checked;
+    }
+  })});
+  try {
+    const goal=await f.runtime.submit({submissionId:'r34-forged-receipt',rootId:'project',title:'verify',
+      goal:'run verification profile',acceptance:'receipt identity must remain exact'});
+    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');
+    await assert.rejects(sendPlannerDecision(f.runtime,goal.goal_id,result,{
+      schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'run_profile',profile_id:'check'}
+    }),/simulated crash after profile receipt/);
+    assert.equal(commandCalls,1);
+
+    const forged=Object.freeze({...f.baseCodingRuntime,
+      commandRun:async args=>{ commandCalls+=1; return f.baseCodingRuntime.commandRun(args); },
+      verifyReceiptDetailed:async receiptId=>{
+        const checked=await f.baseCodingRuntime.verifyReceiptDetailed(receiptId);
+        return checked.ok?{...checked,request_sha256:'f'.repeat(64)}:checked;
+      }
+    });
+    const restarted=f.createRuntime({codingRuntimeOverride:forged});
+    result=await restarted.run({goalId:goal.goal_id,maxCycles:2});
+    assert.equal(result.status,'paused');
+    assert.equal(result.loop.phase,'WAITING');
+    assert.equal(result.loop.wait_reason,'ambiguous_interrupted_action');
+    assert.equal(commandCalls,1,'forged recovery must not execute the profile twice');
+    const journal=await restarted.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    assert.ok(journal.events.some(event=>event.type==='waiting_entered'&&event.payload.reason==='ambiguous_interrupted_action'));
+    assert.equal(journal.events.filter(event=>event.type==='profile_completed').length,0);
+  } finally { await f.cleanup(); }
+});
+
+test('R34 multi-step fail replan repair finish emits independently verifiable release evidence', async () => {
+  const f=await createR34Fixture({withStatefulProfile:true});
+  try {
+    await writeFile(`${f.project}/context.txt`,'CONTEXT\n');
+    const goal=await f.runtime.submit({submissionId:'r34-real-multistep',rootId:'project',title:'repair after evidence',
+      goal:'inspect two files, observe the failing verifier, replan, repair x.txt, verify, and finish',
+      acceptance:'x.txt must be y and the required verification profile plus release receipt must verify'});
+    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:'run_profile',profile_id:'check'}
+    });
+    assert.equal(result.loop.phase,'REPLANNING');
+
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{
+      schema:'deadbyte.autonomous-decision.v2',kind:'replan',reason:'verification failed before repair',
+      steps:[{step_id:'repair2',intent:'inspect x.txt and context.txt then repair x.txt under exact SHA'}]
+    });
+    assert.equal(result.loop.phase,'INSPECTING');
+    assert.equal(result.loop.plan_version,2);
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{
+      schema:'deadbyte.autonomous-decision.v2',kind:'inspect',reads:[
+        {path:'x.txt',max_bytes:4096},{path:'context.txt',max_bytes:4096}
+      ]
+    });
+    assert.equal(result.loop.phase,'ACTING');
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,patchDecision(f.initial_sha256));
+    assert.equal(result.loop.phase,'VERIFYING');
+    assert.equal(await readFile(f.target,'utf8'),'y\n');
+
+    let journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const commit=[...journal.events].reverse().find(event=>event.type==='native_diff_committed');
+    const passingProfile=[...journal.events].reverse().find(event=>event.type==='profile_completed'&&event.payload.profile_id==='check'&&event.payload.passed===true);
+    assert.ok(commit);
+    assert.ok(passingProfile);
+    const inspections=journal.events.filter(event=>event.type==='inspection_completed');
+    assert.equal(inspections.at(-1).payload.contexts.length,2);
+    assert.equal(journal.events.find(event=>event.type==='plan_created').payload.plan.plan_version,1);
+    assert.equal(journal.events.find(event=>event.type==='plan_replanned').payload.plan.plan_version,2);
+    const criticEvent=journal.events.find(event=>event.type==='critic_classified'&&event.payload.failure_class==='verification_failure');
+    const repairStarted=journal.events.find(event=>event.type==='repair_started');
+    const repairCompleted=journal.events.find(event=>event.type==='repair_completed');
+    assert.ok(criticEvent);
+    assert.ok(repairStarted);
+    assert.ok(repairCompleted);
+    assert.notEqual(repairCompleted.payload.previous_fingerprint,repairCompleted.payload.repair_fingerprint);
+    const criticPhase=journal.events.findIndex(event=>event.type==='phase_changed'&&event.payload.to==='CRITIC');
+    const repairPhase=journal.events.findIndex(event=>event.type==='phase_changed'&&event.payload.from==='CRITIC'&&event.payload.to==='REPAIR');
+    const repairedInspect=journal.events.findIndex(event=>event.type==='phase_changed'&&event.payload.from==='REPAIR'&&event.payload.to==='INSPECT');
+    assert.ok(criticPhase>=0&&repairPhase>criticPhase&&repairedInspect>repairPhase);
+    const verdicts=journal.events.filter(event=>event.type==='progress_judged').map(event=>event.payload.verdict);
+    assert.ok(verdicts.includes('regressed'));
+    assert.ok(verdicts.includes('progress'));
+
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,{
+      schema:'deadbyte.autonomous-decision.v2',kind:'step_complete',step_id:'repair2',evidence:[
+        {kind:'native_diff',id:commit.payload.diff_id,sha256:commit.payload.diff_receipt_sha256},
+        {kind:'profile',id:passingProfile.payload.receipt_id,sha256:passingProfile.payload.receipt_sha256}
+      ]
+    });
+    assert.equal(result.loop.phase,'PLANNING');
+    result=await sendPlannerDecision(f.runtime,goal.goal_id,result,finishDecision(),{maxCycles:8});
+    assert.equal(result.status,'completed');
+    assert.equal(result.loop.phase,'COMPLETE');
+    assert.match(result.release.receipt_sha256,/^[0-9a-f]{64}$/);
+    const verified=await f.runtime.verify({goalId:goal.goal_id});
+    assert.equal(verified.ok,true,verified.reason);
+    assert.equal(verified.signature_valid,true);
+    assert.equal(verified.receipt_sha256,result.release.receipt_sha256);
+    assert.equal(verified.native_diffs_verified,1);
+    assert.equal(verified.required_profiles_verified,1);
+  } finally { await f.cleanup(); }
+});
+
+test('R34 v2 crash after durable mutation reconciles the same action without duplicate apply', async () => {
+  let applyCalls=0;
+  let crashOnce=true;
+  const f=await createR34Fixture({nativeDiffRuntimeFactory:base=>Object.freeze({
+    preview:args=>base.preview(args),verify:args=>base.verify(args),
+    async apply(args){
+      applyCalls+=1;
+      const result=await base.apply(args);
+      if(crashOnce){ crashOnce=false; throw new Error('simulated R34 crash after native diff apply'); }
+      return result;
+    }
+  })});
+  try {
+    const goal=await f.runtime.submit({submissionId:'r34-v2-crash-dedupe',rootId:'project',title:'crash recovery',
+      goal:'repair x.txt exactly once',acceptance:'restart must reconcile the same action identity'});
+    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());
+    await assert.rejects(sendPlannerDecision(f.runtime,goal.goal_id,result,patchDecision(f.initial_sha256)),/simulated R34 crash after native diff apply/);
+    assert.equal(applyCalls,1);
+    assert.equal(await readFile(f.target,'utf8'),'y\n');
+    let journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const started=journal.events.find(event=>event.type==='action_started');
+    assert.ok(started);
+
+    const restarted=f.createRuntime();
+    result=await restarted.run({goalId:goal.goal_id,maxCycles:2});
+    assert.equal(applyCalls,1,'restart must not invoke Native Diff apply a second time');
+    assert.equal(result.loop.phase,'VERIFYING');
+    journal=await restarted.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const reconciled=journal.events.find(event=>event.type==='action_reconciled');
+    assert.ok(reconciled);
+    assert.equal(reconciled.payload.action_id,started.payload.action_id);
+    assert.equal(reconciled.payload.classification,'executed_verified');
+    assert.equal(journal.events.filter(event=>event.type==='action_started').length,1);
+    assert.equal(journal.events.filter(event=>event.type==='native_diff_committed').length,1);
+    assert.equal(journal.events.filter(event=>event.type==='action_completed').length,1);
+  } finally { await f.cleanup(); }
+});

package/test/autonomous-runtime.test.mjs

@@ -23,8 +23,8 @@ const r23Tools = [
   'contained_transform','evidence_verify','file_read','proof_execute','workspace_open',
   '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_receipt_verify','coding_search','coding_session_status','coding_stat',
+  '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_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('R30 hermetic autonomous fixture exposes the exact 41-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/autonomous-supervisor-integration.test.mjs

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createHash, randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
 import { createServer } from 'node:http';
 import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
@@ -15,6 +16,14 @@ const repoRoot = path.resolve(here, '..');
 const serverPath = path.join(repoRoot, 'src', 'mcp-server.mjs');
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 const nonce = () => randomBytes(32).toString('hex');
+const runChild = (command,args,options={}) => new Promise((resolve,reject)=>{
+  const child=spawn(command,args,{...options,stdio:['ignore','pipe','pipe'],shell:false});
+  const out=[],err=[];
+  child.stdout.on('data',chunk=>out.push(Buffer.from(chunk)));
+  child.stderr.on('data',chunk=>err.push(Buffer.from(chunk)));
+  child.on('error',reject);
+  child.on('exit',code=>resolve({code,stdout:Buffer.concat(out).toString('utf8'),stderr:Buffer.concat(err).toString('utf8')}));
+});
 
 async function startPlanner() {
   let round = 0;
@@ -31,7 +40,7 @@ async function startPlanner() {
   });
   await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
   return { server, endpoint:`http://127.0.0.1:${server.address().port}/v1/chat/completions`, rounds:() => round };
-}async function fixture() {
+}async function fixture({supervisorMode='in_process'}={}) {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-supervisor-mcp-'));
   const project = path.join(root, 'project');
   const trust = path.join(root, 'trust');
@@ -73,9 +82,10 @@ async function startPlanner() {
     env:{ ...getDefaultEnvironment(), DEADBYTE_SIGNING_KEY:keys.privateKeyPath,
       DEADBYTE_VERIFY_KEY:keys.publicKeyPath, DEADBYTE_CODING_RUNTIME:'1',
       DEADBYTE_CODING_POLICY:codingPath, DEADBYTE_AUTONOMOUS_RUNTIME:'1',
-      DEADBYTE_AUTONOMOUS_POLICY:autonomousPath }
+      DEADBYTE_AUTONOMOUS_POLICY:autonomousPath,
+      DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:supervisorMode }
   });
-  return { root, planner, client, transport };
+  return { root, planner, client, transport, codingPath, autonomousPath, keys };
 }test('provider-backed MCP server supervises submitted goal without client run calls', async () => {
   const f = await fixture();
   try {
@@ -103,4 +113,39 @@ async function startPlanner() {
     await new Promise(resolve => f.planner.server.close(resolve));
     await rm(f.root, { recursive:true, force:true });
   }
+});
+
+test('external supervisor mode leaves provider goal durable until standalone host advances it', async () => {
+  const f = await fixture({supervisorMode:'external'});
+  try {
+    await f.client.connect(f.transport);
+    const submit = await f.client.callTool({ name:'autonomous_goal_submit', arguments:{
+      submission_id:'external-owner-integration', root_id:'project', title:'external-owner',
+      goal:'Inspect source.txt and release after verified observation.', acceptance:'source.txt must remain READY',
+      max_iterations:8
+    } });
+    assert.equal(submit.isError,false);
+    const goalId=submit.structuredContent.goal_id;
+    await new Promise(resolve=>setTimeout(resolve,1200));
+    const before=await f.client.callTool({name:'autonomous_goal_status',arguments:{goal_id:goalId}});
+    assert.equal(before.isError,false);
+    assert.equal(before.structuredContent.state,'pending');
+    assert.equal(f.planner.rounds(),0);
+
+    const host=await runChild(process.execPath,[path.join(repoRoot,'src','autonomous-supervisor-host.mjs')],{
+      cwd:repoRoot,
+      env:{...process.env,DEADBYTE_SIGNING_KEY:f.keys.privateKeyPath,DEADBYTE_VERIFY_KEY:f.keys.publicKeyPath,
+        DEADBYTE_CODING_POLICY:f.codingPath,DEADBYTE_AUTONOMOUS_POLICY:f.autonomousPath,
+        DEADBYTE_SUPERVISOR_ONCE:'1',DEADBYTE_SUPERVISOR_MARKER:path.join(f.root,'external-supervisor-owner.json')}
+    });
+    assert.equal(host.code,0,host.stderr||host.stdout);
+    const after=await f.client.callTool({name:'autonomous_goal_status',arguments:{goal_id:goalId}});
+    assert.equal(after.isError,false);
+    assert.equal(after.structuredContent.state,'succeeded');
+    assert.ok(f.planner.rounds()>=2);
+  } finally {
+    await f.client.close().catch(()=>{});
+    await new Promise(resolve=>f.planner.server.close(resolve));
+    await rm(f.root,{recursive:true,force:true});
+  }
 });

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-runner.test.mjs

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  R35_BENCHMARK_CASE_IDS,
+  benchmarkCaseDefinitions,
+  fixtureIdentityForCase,
+  runCapabilityBenchmark
+} from '../src/capability-benchmark-runner.mjs';
+
+const REQUIRED=[
+  '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'
+];
+
+test('R35 benchmark corpus exposes the exact required offline case set',()=>{
+  assert.deepEqual([...R35_BENCHMARK_CASE_IDS],REQUIRED);
+  const defs=benchmarkCaseDefinitions();
+  assert.deepEqual(defs.map(item=>item.case_id),REQUIRED);
+  for(const item of defs){
+    assert.ok(Array.isArray(item.test_files)&&item.test_files.length>=1,item.case_id);
+    assert.ok(Number.isInteger(item.round_trips)&&item.round_trips>=1,item.case_id);
+    assert.equal(typeof item.stale_rejected,'boolean');
+    assert.equal(typeof item.recovery_success,'boolean');
+  }
+});
+
+test('fixture identity is deterministic and changes when any declared fixture byte changes',async()=>{
+  const root=new URL('../',import.meta.url);
+  const def={case_id:'fixture_probe',test_files:['test/capability-benchmark.test.mjs'],fixture_files:['test/capability-benchmark.test.mjs']};
+  const a=await fixtureIdentityForCase({rootUrl:root,definition:def});
+  const b=await fixtureIdentityForCase({rootUrl:root,definition:structuredClone(def)});
+  assert.match(a,/^[0-9a-f]{64}$/);assert.equal(a,b);
+});
+
+test('runner fails closed on a failed case and returns evidence-backed metrics for passing cases',async()=>{
+  const defs=[
+    {case_id:'pass_case',test_files:['test/capability-benchmark.test.mjs'],fixture_files:['test/capability-benchmark.test.mjs'],round_trips:1,stale_rejected:false,recovery_success:true},
+    {case_id:'fail_case',test_files:['test/__definitely_missing__.test.mjs'],fixture_files:['test/capability-benchmark.test.mjs'],round_trips:1,stale_rejected:false,recovery_success:false}
+  ];
+  const root=new URL('../',import.meta.url);
+  const result=await runCapabilityBenchmark({rootUrl:root,definitions:defs,env:{},timeoutMs:30_000});
+  assert.equal(result.schema,'deadbyte.r35-capability-benchmark.v1');
+  assert.equal(result.overall_correct,false);
+  const pass=result.cases.find(item=>item.case_id==='pass_case');
+  const fail=result.cases.find(item=>item.case_id==='fail_case');
+  assert.equal(pass.correct,true);assert.match(pass.evidence_sha256,/^[0-9a-f]{64}$/);assert.ok(pass.bytes_returned>0);assert.ok(pass.elapsed_ms>=0);
+  assert.equal(fail.correct,false);assert.match(fail.evidence_sha256,/^[0-9a-f]{64}$/);
+});

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