deadbyte-mcp 0.8.9 → 0.9.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_outline','coding_symbol_references','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('R34 hermetic autonomous fixture exposes the exact 46-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-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.test.mjs

@@ -0,0 +1,47 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  CAPABILITY_BENCHMARK_SCHEMA,
+  normalizeBenchmarkCase,
+  buildCapabilityBenchmark
+} from '../src/capability-benchmark.mjs';
+
+const H=c=>c.repeat(64);
+const base={case_id:'filesystem_bounded_read',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,evidence_sha256:H('b')};
+
+test('R35 benchmark schema is exact and preserves separate measurable dimensions',()=>{
+  assert.equal(CAPABILITY_BENCHMARK_SCHEMA,'deadbyte.r35-capability-benchmark.v1');
+  const value=normalizeBenchmarkCase(base);
+  assert.deepEqual(Object.keys(value).sort(),[
+    'bytes_returned','case_id','correct','duplicate_side_effects','elapsed_ms','evidence_sha256','fixture_sha256',
+    'recovery_success','round_trips','stale_rejected'
+  ].sort());
+  assert.equal(value.correct,true);assert.equal(value.round_trips,2);assert.equal(value.duplicate_side_effects,0);
+});
+
+test('benchmark rejects missing evidence and invalid measurements instead of manufacturing a score',()=>{
+  assert.throws(()=>normalizeBenchmarkCase({...base,evidence_sha256:undefined}),/evidence/i);
+  assert.throws(()=>normalizeBenchmarkCase({...base,elapsed_ms:-1}),/elapsed/i);
+  assert.throws(()=>normalizeBenchmarkCase({...base,round_trips:0}),/round.?trips/i);
+  assert.throws(()=>normalizeBenchmarkCase({...base,duplicate_side_effects:-1}),/duplicate/i);
+});
+
+test('aggregate identity is deterministic across timing changes while fixture/correctness verdicts remain inspectable',()=>{
+  const cases=[base,{...base,case_id:'remote_replay_dedupe',fixture_sha256:H('c'),evidence_sha256:H('d'),elapsed_ms:22}];
+  const first=buildCapabilityBenchmark({suite_id:'r35-offline-v1',cases});
+  const second=buildCapabilityBenchmark({suite_id:'r35-offline-v1',cases:cases.map(item=>({...item,elapsed_ms:item.elapsed_ms+100}))});
+  assert.equal(first.schema,CAPABILITY_BENCHMARK_SCHEMA);
+  assert.equal(first.fixture_identity_sha256,second.fixture_identity_sha256);
+  assert.deepEqual(first.cases.map(item=>[item.case_id,item.correct,item.fixture_sha256]),
+    second.cases.map(item=>[item.case_id,item.correct,item.fixture_sha256]));
+  assert.notEqual(first.observation_sha256,second.observation_sha256,'observed timings remain evidence, not hidden');
+  assert.equal(first.overall_correct,true);
+  assert.equal('score' in first,false);
+});
+
+test('aggregate fails closed on duplicate case ids or any incorrect case',()=>{
+  assert.throws(()=>buildCapabilityBenchmark({suite_id:'r35-offline-v1',cases:[base,base]}),/duplicate case/i);
+  const result=buildCapabilityBenchmark({suite_id:'r35-offline-v1',cases:[base,{...base,case_id:'broken',correct:false,evidence_sha256:H('e')} ]});
+  assert.equal(result.overall_correct,false);
+});

package/test/cli-entrypoint.test.mjs

@@ -27,6 +27,18 @@ test('npx CLI remote path invokes stable PS1 directly and never routes through C
   assert.match(source,/verifyAuditChain/);
 });
 
+test('npx CLI exposes local supervisor lifecycle without any supervisor arm command',async()=>{
+  const source=await readFile(cliPath,'utf8');
+  assert.match(source,/SUPERVISOR_COMMANDS/);
+  assert.match(source,/supervisorstart/);
+  assert.match(source,/supervisorstop/);
+  assert.match(source,/supervisorstatus/);
+  assert.match(source,/supervisorrecover/);
+  const mapping=source.match(/const SUPERVISOR_COMMANDS=.*?;\n/s)?.[0]??'';
+  assert.doesNotMatch(mapping,/arm(?:coding|autonomous|process|host)/i);
+  assert.match(source,/npx deadbyte-mcp@latest supervisor status/);
+});
+
 test('README makes npx the primary operator UX',async()=>{
   const readme=await readFile(path.join(root,'README.txt'),'utf8');
   assert.match(readme,/npx deadbyte-mcp@latest remote/);

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

@@ -0,0 +1,24 @@
+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)));
+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_task_events','coding_task_run','coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree'
+].sort();
+function extract(source){
+  const m=source.match(/const (?:codingTools|coding)\s*=\s*\[([\s\S]*?)\];/);
+  assert.ok(m,'coding catalog array missing');
+  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()=>{
+    const source=await readFile(path.join(root,...rel.split('/')),'utf8');
+    assert.deepEqual(extract(source),expected);
+  });
+}

package/test/coding-plane.test.mjs

@@ -14,8 +14,8 @@ const repoRoot = path.resolve(here, '..');
 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_receipt_verify', 'coding_search', 'coding_session_status', 'coding_stat', 'coding_task_approve', 'coding_task_cancel',
+  '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_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('R27 hermetic coding fixture exposes the exact 29-tool no-host catalog', async () => {
+test('R34 hermetic coding fixture exposes the exact 34-tool no-host catalog', async () => {
   const f = await fixture();
   try {
     await f.client.connect(f.transport);