deadbyte-mcp 0.8.9 → 0.9.0

package/test/autonomous-loop.test.mjs

@@ -21,6 +21,10 @@ async function startPlanner(decisions) {
     const parsed = JSON.parse(body); prompts.push(parsed.messages?.at(-1)?.content ?? '');
     const decision = decisions[prompts.length - 1];
     if (!decision) { res.writeHead(500); return res.end('planner sequence exhausted'); }
+    if (Number.isInteger(decision?.__http_status)) {
+      res.writeHead(decision.__http_status,{'content-type':'application/json'});
+      return res.end(JSON.stringify({error:'intentional provider failure'}));
+    }
     res.writeHead(200,{'content-type':'application/json'});
     const content = typeof decision === 'string' ? decision : JSON.stringify(decision);
     res.end(JSON.stringify({ model:'deadbyte-fake-planner', choices:[{ message:{ content } }] }));
@@ -78,7 +82,8 @@ async function fixture(decisionPrefix = []) {
     lease_file:path.join(root,'autonomous-lease.json'), evidence_dir:path.join(root,'autonomous-evidence'),
     root_ids:['project'], coding_policy_sha256:codingPolicy.policy_sha256,
     planner:{ backend:'openai_compatible', endpoint:planner.endpoint, model:'fake', max_tokens:2048,
-      timeout_ms:30000, max_response_bytes:262144 },
+      timeout_ms:30000, max_response_bytes:262144,
+      circuit:{failure_threshold:3,open_ms:100,half_open_probe_limit:1} },
     profiles:{
       build:{ kind:'command', root_id:'project', command_id:'node_script', script_path:'build.mjs',
         script_sha256:buildHash, args:[], cwd:'.', required_for_release:true, run_after_mutation:true,
@@ -161,6 +166,79 @@ test('provider planner repairs an invalid structured decision inside the same ru
   }
 });
 
+test('provider circuit survives runtime restart, suppresses OPEN calls, then permits one HALF_OPEN probe', async () => {
+  const failures=[{__http_status:503},{__http_status:503},{__http_status:503}];
+  const f=await fixture(failures);
+  try {
+    assert.deepEqual(f.policy.planner.circuit,{failure_threshold:3,open_ms:100,half_open_probe_limit:1});
+    const submitted=await f.runtime.submit({submissionId:'provider-circuit',rootId:'project',title:'provider circuit',
+      goal:'make exported value equal fixed',acceptance:'provider failures must be bounded',maxIterations:10});
+    await assert.rejects(f.runtime.run({goalId:submitted.goal_id,maxCycles:2}),/planner HTTP 503/);
+    await assert.rejects(f.runtime.run({goalId:submitted.goal_id,maxCycles:2}),/planner HTTP 503/);
+    const opened=await f.runtime.run({goalId:submitted.goal_id,maxCycles:2});
+    assert.equal(opened.status,'paused');
+    assert.equal(opened.reason,'provider_circuit_open');
+    assert.equal(f.planner.prompts.length,3);
+
+    const immediate=await f.runtime.run({goalId:submitted.goal_id,maxCycles:2});
+    assert.equal(immediate.status,'paused');
+    assert.equal(f.planner.prompts.length,3,'OPEN circuit must suppress provider invocation');
+
+    const restarted=createAutonomousRuntime({policy:f.policy,codingRuntime:f.codingRuntime,nativeDiffRuntime:f.nativeDiff,
+      signingKeyPath:f.keys.privateKeyPath,verifyKeyPath:f.keys.publicKeyPath});
+    await new Promise(resolve=>setTimeout(resolve,130));
+    const circuitBeforeResume=await restarted.providerCircuitStatus({goalId:submitted.goal_id});
+    assert.equal(circuitBeforeResume.state,'HALF_OPEN',JSON.stringify(circuitBeforeResume));
+    const resumed=await restarted.run({goalId:submitted.goal_id,maxCycles:1});
+    assert.notEqual(resumed.status,'paused');
+    assert.equal(f.planner.prompts.length,4,'HALF_OPEN must permit exactly one provider probe');
+    const journal=await restarted.events({goalId:submitted.goal_id,fromSeq:1,limit:200});
+    assert.equal(journal.events.filter(event=>event.type==='provider_call_failed').length,3);
+    assert.equal(journal.events.filter(event=>event.type==='provider_probe_started').length,1);
+    assert.equal(journal.events.filter(event=>event.type==='provider_call_succeeded').length,1);
+    assert.ok(journal.events.some(event=>event.type==='waiting_entered'&&event.payload.reason==='provider_circuit_open'));
+    assert.ok(journal.events.some(event=>event.type==='goal_resumed'&&event.payload.previous_reason==='provider_circuit_open'));
+  } finally {
+    await new Promise(resolve=>f.planner.server.close(resolve));
+    await rm(f.root,{recursive:true,force:true});
+  }
+});
+
+test('provider supervisor adopts an OPEN circuit after restart and resumes only at HALF_OPEN boundary', async () => {
+  const f=await fixture([{__http_status:503},{__http_status:503},{__http_status:503}]);
+  let supervisor=null;
+  try {
+    const submitted=await f.runtime.submit({submissionId:'provider-circuit-supervisor',rootId:'project',
+      title:'provider circuit supervisor',goal:'make exported value equal fixed',
+      acceptance:'supervisor must resume only after the provider circuit probe boundary',maxIterations:10});
+    await assert.rejects(f.runtime.run({goalId:submitted.goal_id,maxCycles:2}),/planner HTTP 503/);
+    await assert.rejects(f.runtime.run({goalId:submitted.goal_id,maxCycles:2}),/planner HTTP 503/);
+    const opened=await f.runtime.run({goalId:submitted.goal_id,maxCycles:2});
+    assert.equal(opened.status,'paused');
+    assert.equal(opened.reason,'provider_circuit_open');
+    assert.equal(f.planner.prompts.length,3);
+
+    supervisor=startAutonomousSupervisor({runtime:f.runtime,policy:f.policy,idleDelayMs:25,maxCycles:16,logger:{warn(){}}});
+    const deadline=Date.now()+10_000;
+    let status;
+    do {
+      status=await f.runtime.status({goalId:submitted.goal_id});
+      if(status.state==='succeeded') break;
+      if(status.state==='cancelled') throw new Error('provider circuit supervisor cancelled goal');
+      await new Promise(resolve=>setTimeout(resolve,25));
+    } while(Date.now()<deadline);
+    assert.equal(status.state,'succeeded');
+    assert.ok(f.planner.prompts.length>3);
+    const journal=await f.runtime.events({goalId:submitted.goal_id,fromSeq:1,limit:200});
+    assert.equal(journal.events.filter(event=>event.type==='provider_probe_started').length,1);
+    assert.ok(journal.events.some(event=>event.type==='goal_resumed'&&event.payload.previous_reason==='provider_circuit_open'));
+  } finally {
+    if(supervisor) await supervisor.stop();
+    await new Promise(resolve=>f.planner.server.close(resolve));
+    await rm(f.root,{recursive:true,force:true});
+  }
+});
+
 test('provider supervisor completes a submitted goal without client run calls', async () => {
   const f = await fixture();
   const supervisor = startAutonomousSupervisor({ runtime:f.runtime, policy:f.policy, idleDelayMs:25, maxCycles:16,

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

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
+  autonomousGoalApproveOutputSchema, autonomousGoalRunOutputSchema, autonomousGoalStatusOutputSchema,
   autonomousGoalVerifyOutputSchema,
   autonomousStructuredResult
 } from '../src/autonomous-output-contracts.mjs';
@@ -22,3 +23,56 @@ test('autonomous_goal_verify structured contract preserves delegated action evid
   const result = autonomousStructuredResult(autonomousGoalVerifyOutputSchema,value);
   assert.equal(result.structuredContent.delegated_actions_verified,1);
 });
+
+function baseDerived() {
+  return {
+    state:'running', reason:null, planner_round:2, mutation_epoch:1, mutation_count:1,
+    contexts:[], observations:[], diffs:[], decisions:[], planner_rejections:[], active_plan:null,
+    pending_request:null, pending_decision:null, journal_head_sha256:'a'.repeat(64),
+    created_at_utc:'2026-09-16T00:00:00.000Z', elapsed_ms:10
+  };
+}
+
+const publicLoop = {
+  schema:'deadbyte.autonomous-loop-state.v1', phase:'ACTING', plan_id:'b'.repeat(64), plan_version:2,
+  current_step:{step_id:'repair',intent:'repair x.txt',status:'active'}, replan_count:1,
+  progress:{verdict:'progress',score:1,reason_codes:['verified_mutation_epoch_advanced'],fingerprint:'c'.repeat(64)},
+  pending_action:{action_id:'d'.repeat(64),request_sha256:'e'.repeat(64),kind:'patch'},
+  pending_approval:false, wait_reason:null
+};
+
+test('R34 run/status output contracts accept only the sanitized public loop projection', () => {
+  const run = autonomousStructuredResult(autonomousGoalRunOutputSchema,{
+    status:'yielded',goal_id:'1'.repeat(64),...baseDerived(),loop:publicLoop
+  });
+  assert.equal(run.structuredContent.loop.phase,'ACTING');
+  const status = autonomousStructuredResult(autonomousGoalStatusOutputSchema,{
+    status:'ok',goal_id:'1'.repeat(64),goal_sha256:'2'.repeat(64),title:'x',root_id:'project',journal_verified:true,
+    ...baseDerived(),loop:publicLoop
+  });
+  assert.equal(status.structuredContent.loop.pending_action.kind,'patch');
+  const approved = autonomousStructuredResult(autonomousGoalApproveOutputSchema,{
+    status:'approved',goal_id:'1'.repeat(64),state:'running',loop:{...publicLoop,phase:'ACTING'}
+  });
+  assert.equal(approved.structuredContent.loop.phase,'ACTING');
+});
+
+test('bounded yielded autonomous run preserves its resumable cycle count', () => {
+  const result = autonomousStructuredResult(autonomousGoalRunOutputSchema,{
+    status:'yielded',goal_id:'1'.repeat(64),cycles:1,...baseDerived(),loop:publicLoop
+  });
+  assert.equal(result.structuredContent.cycles,1);
+});
+
+test('R34 public loop contract rejects internal progress/action payload fields', () => {
+  assert.throws(() => autonomousStructuredResult(autonomousGoalRunOutputSchema,{
+    status:'yielded',goal_id:'1'.repeat(64),...baseDerived(),loop:{
+      ...publicLoop,pending_action:{...publicLoop.pending_action,action:{kind:'patch',operations:[]}}
+    }
+  }),/autonomous output contract violation/);
+  assert.throws(() => autonomousStructuredResult(autonomousGoalRunOutputSchema,{
+    status:'yielded',goal_id:'1'.repeat(64),...baseDerived(),loop:{
+      ...publicLoop,progress:{...publicLoop.progress,decision_event_sha256:'f'.repeat(64)}
+    }
+  }),/autonomous output contract violation/);
+});

package/test/autonomous-plan.test.mjs

@@ -0,0 +1,101 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  createPlan,
+  replanPlan,
+  completePlanStep,
+  planIsComplete,
+  activePlanStep
+} from '../src/autonomous-plan.mjs';
+
+const H = c => c.repeat(64);
+
+function basePlan() {
+  return createPlan({
+    goalId:H('a'),
+    title:'Repair',
+    reasonHash:H('b'),
+    steps:[
+      { step_id:'inspect', intent:'Inspect source' },
+      { step_id:'fix', intent:'Apply repair' },
+      { step_id:'verify', intent:'Verify acceptance' }
+    ]
+  });
+}
+
+test('plan id is goal-stable and version starts at one', () => {
+  const plan = basePlan();
+  assert.equal(plan.schema,'deadbyte.autonomous-plan.v1');
+  assert.equal(plan.plan_version,1);
+  assert.equal(plan.parent_plan_version,null);
+  assert.match(plan.plan_id,/^[0-9a-f]{64}$/);
+  assert.equal(plan.steps[0].status,'active');
+  assert.equal(plan.steps[1].status,'pending');
+  assert.equal(plan.steps[2].status,'pending');
+  const same = basePlan();
+  assert.equal(same.plan_id,plan.plan_id);
+});
+
+test('completed prefix is immutable across replan', () => {
+  let plan = basePlan();
+  plan = completePlanStep(plan,{
+    stepId:'inspect',
+    evidence:[{kind:'read',id:H('c'),sha256:H('d')}]
+  });
+  assert.throws(() => replanPlan(plan,{
+    reasonHash:H('e'),
+    steps:[
+      { step_id:'inspect', intent:'Changed completed intent' },
+      { step_id:'fix2', intent:'Alternative repair' }
+    ]
+  }),/completed prefix/i);
+});
+
+test('replan changes only active and pending suffix and increments version', () => {
+  let plan = basePlan();
+  plan = completePlanStep(plan,{
+    stepId:'inspect',
+    evidence:[{kind:'read',id:H('c'),sha256:H('d')}]
+  });
+  const next = replanPlan(plan,{
+    reasonHash:H('e'),
+    steps:[
+      plan.steps[0],
+      { step_id:'diagnose', intent:'Diagnose failure' },
+      { step_id:'fix2', intent:'Apply corrected repair' }
+    ]
+  });
+  assert.equal(next.plan_version,2);
+  assert.equal(next.parent_plan_version,1);
+  assert.equal(next.plan_id,plan.plan_id);
+  assert.deepEqual(next.steps[0],plan.steps[0]);
+  assert.equal(next.steps[1].status,'active');
+  assert.equal(next.steps[2].status,'pending');
+});
+
+test('step completion requires evidence and activates exactly the next step', () => {
+  const plan = basePlan();
+  assert.throws(() => completePlanStep(plan,{stepId:'inspect',evidence:[]}),/evidence/i);
+  const next = completePlanStep(plan,{
+    stepId:'inspect',
+    evidence:[{kind:'read',id:H('c'),sha256:H('d')}]
+  });
+  assert.equal(next.steps[0].status,'completed');
+  assert.equal(next.steps[1].status,'active');
+  assert.equal(next.steps[2].status,'pending');
+  assert.equal(activePlanStep(next).step_id,'fix');
+  assert.equal(planIsComplete(next),false);
+});
+
+test('completing the final step leaves no active step and marks plan complete', () => {
+  let plan = basePlan();
+  for (const [index,stepId] of ['inspect','fix','verify'].entries()) {
+    plan = completePlanStep(plan,{
+      stepId,
+      evidence:[{kind:'receipt',id:H(String(index + 1)),sha256:H(String(index + 4))}]
+    });
+  }
+  assert.equal(activePlanStep(plan),null);
+  assert.equal(planIsComplete(plan),true);
+  assert.ok(plan.steps.every(step => step.status === 'completed'));
+});

package/test/autonomous-progress.test.mjs

@@ -0,0 +1,106 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { judgeProgress, stallDisposition } from '../src/autonomous-progress.mjs';
+import { loadCodingPolicy } from '../src/coding-plane.mjs';
+import { loadAutonomousPolicy } from '../src/autonomous-policy.mjs';
+
+const H = c => c.repeat(64);
+
+test('verified Native Diff epoch advance counts as progress', () => {
+  const result = judgeProgress({
+    before:{mutation_epoch:1,completed_steps:0},
+    after:{mutation_epoch:2,completed_steps:0},
+    decision:{kind:'act'},
+    evidence:{native_diff_verified:true}
+  });
+  assert.equal(result.verdict,'progress');
+  assert.ok(result.score > 0);
+  assert.ok(result.reason_codes.includes('verified_mutation_epoch_advanced'));
+  assert.match(result.fingerprint,/^[0-9a-f]{64}$/);
+});
+
+test('same read identity and equivalent decision stalls', () => {
+  const result = judgeProgress({
+    before:{evidence_head:H('a'),completed_steps:0},
+    after:{evidence_head:H('a'),completed_steps:0},
+    decision:{kind:'inspect',fingerprint:H('b'),rationale:'first wording'},
+    evidence:{same_source_sha:true,equivalent_decision:true}
+  });
+  assert.equal(result.verdict,'stalled');
+  assert.equal(result.score,0);
+  assert.ok(result.reason_codes.includes('identical_read_repeated'));
+  assert.ok(result.reason_codes.includes('equivalent_decision_no_new_evidence'));
+});
+
+test('planner rationale text never changes the machine progress fingerprint', () => {
+  const base = {
+    before:{evidence_head:H('a')}, after:{evidence_head:H('a')},
+    evidence:{same_source_sha:true,equivalent_decision:true}
+  };
+  const a = judgeProgress({...base,decision:{kind:'inspect',path:'x',rationale:'one'}});
+  const b = judgeProgress({...base,decision:{kind:'inspect',path:'x',rationale:'completely different prose'}});
+  assert.equal(a.fingerprint,b.fingerprint);
+  assert.equal(a.verdict,b.verdict);
+});
+
+test('resolved acceptance failure and completed plan step count as progress', () => {
+  const result = judgeProgress({
+    before:{acceptance_failures:1,completed_steps:1},
+    after:{acceptance_failures:0,completed_steps:2},
+    decision:{kind:'step_complete'},
+    evidence:{step_evidence_verified:true}
+  });
+  assert.equal(result.verdict,'progress');
+  assert.ok(result.reason_codes.includes('acceptance_failure_resolved'));
+  assert.ok(result.reason_codes.includes('plan_step_completed'));
+});
+
+test('stall policy forces replan then waiting', () => {
+  const limits={max_stalled_cycles:2,max_post_replan_stalls:2,max_replans:8};
+  assert.deepEqual(stallDisposition({history:['stalled','stalled'],limits}),{
+    action:'replan',reason:'stall_threshold_reached'
+  });
+  assert.deepEqual(stallDisposition({history:['replan','stalled','stalled'],limits}),{
+    action:'wait',reason:'post_replan_stall_threshold_reached'
+  });
+});
+
+async function policyFixture(limits) {
+  const root = await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-progress-policy-'));
+  const project = path.join(root,'project');
+  await mkdir(project);
+  const codingPath = path.join(root,'coding.json');
+  await writeFile(codingPath,JSON.stringify({
+    schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:path.join(root,'coding-grant.json'),evidence_dir:path.join(root,'coding-evidence'),
+    roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:[]}},commands:{}
+  }));
+  const coding = await loadCodingPolicy(codingPath);
+  const autonomousPath = path.join(root,'autonomous.json');
+  await writeFile(autonomousPath,JSON.stringify({
+    schema:'deadbyte.autonomous-policy.v1',enabled:true,
+    lease_file:path.join(root,'autonomous-grant.json'),evidence_dir:path.join(root,'autonomous-evidence'),
+    root_ids:['project'],coding_policy_sha256:coding.policy_sha256,
+    planner:{backend:'client_sampling',max_tokens:2048},profiles:{},
+    limits:{max_iterations:8,max_mutations:8,max_wall_ms:600000,max_context_bytes:262144,max_diff_bytes:262144,max_files_per_diff:4,...limits}
+  }));
+  return {root,coding,autonomousPath};
+}
+
+test('autonomous policy defaults R34 progress limits and rejects zero values', async () => {
+  const f = await policyFixture({});
+  try {
+    const policy = await loadAutonomousPolicy(f.autonomousPath,f.coding);
+    assert.equal(policy.limits.max_stalled_cycles,2);
+    assert.equal(policy.limits.max_post_replan_stalls,2);
+    assert.equal(policy.limits.max_replans,8);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+
+  const bad = await policyFixture({max_stalled_cycles:0});
+  try {
+    await assert.rejects(loadAutonomousPolicy(bad.autonomousPath,bad.coding),/max_stalled_cycles/);
+  } finally { await rm(bad.root,{recursive:true,force:true}); }
+});