deadbyte-mcp 0.8.9 → 0.9.0

package/test/autonomous-adversarial.test.mjs

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { randomBytes } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -9,7 +9,7 @@ import { createCodingRuntime, loadCodingPolicy } from '../src/coding-plane.mjs';
 import { loadAutonomousPolicy } from '../src/autonomous-policy.mjs';
 import { createNativeDiffRuntime } from '../src/native-diff.mjs';
 import { createAutonomousRuntime } from '../src/autonomous-runtime.mjs';
-import { buildPlannerPrompt, parsePlannerDecision } from '../src/autonomous-planner.mjs';
+import { buildPlannerPrompt, parsePlannerDecision, parseR34PlannerDecision, requestR34ProviderDecision } from '../src/autonomous-planner.mjs';
 
 const nonce = () => randomBytes(32).toString('hex');
 async function fixture(delegates = {}) {
@@ -32,13 +32,17 @@ async function fixture(delegates = {}) {
   await writeFile(policy.lease_file, JSON.stringify({ schema:'deadbyte.autonomous-lease.v1', policy_sha256:policy.policy_sha256,
     instance_nonce:nonce(), root_ids:['project'], armed_at_utc:new Date().toISOString(), expires_at_utc:new Date(Date.now()+1800000).toISOString() }));
   const codingRuntime = createCodingRuntime({ policy:codingPolicy, signingKeyPath:keys.privateKeyPath, verifyKeyPath:keys.publicKeyPath });
-  const nativeDiffRuntime = createNativeDiffRuntime({ policy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath });
-  const { codingRuntimeFactory, observationRuntimeFactory, ...runtimeDelegates } = delegates;
+  const baseNativeDiffRuntime = createNativeDiffRuntime({ policy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath });
+  const { codingRuntimeFactory, nativeDiffRuntimeFactory, observationRuntimeFactory, ...runtimeDelegates } = delegates;
   const autonomousCodingRuntime = codingRuntimeFactory ? codingRuntimeFactory(codingRuntime) : codingRuntime;
+  const autonomousNativeDiffRuntime = nativeDiffRuntimeFactory ? nativeDiffRuntimeFactory(baseNativeDiffRuntime) : baseNativeDiffRuntime;
   if (observationRuntimeFactory) runtimeDelegates.observationRuntime = observationRuntimeFactory({ codingPolicy,keys });
-  const runtime = createAutonomousRuntime({ policy,codingRuntime:autonomousCodingRuntime,nativeDiffRuntime,...runtimeDelegates,
+  const createRuntime = (overrides = {}) => createAutonomousRuntime({ policy,codingRuntime:autonomousCodingRuntime,
+    nativeDiffRuntime:autonomousNativeDiffRuntime,...runtimeDelegates,...overrides,
     signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath });
-  return { root,project,keys,codingPolicy,policy,runtime };
+  const runtime = createRuntime();
+  return { root,project,keys,codingPolicy,policy,codingRuntime:autonomousCodingRuntime,
+    nativeDiffRuntime:autonomousNativeDiffRuntime,baseNativeDiffRuntime,createRuntime,runtime };
 }
 async function submit(runtime,id='adv') {
   return runtime.submit({ submissionId:id, rootId:'project', title:'adversarial', goal:'Inspect x.txt safely.', acceptance:'Do not claim release without evidence.' });
@@ -122,6 +126,66 @@ test('planner parser rejects malformed JSON and unknown top-level fields', async
   } finally { await rm(f.root,{recursive:true,force:true}); }
 });
 
+test('R34 decision parser rejects prose-wrapped JSON and authority arming actions', async () => {
+  const f = await fixture();
+  try {
+    assert.throws(() => parseR34PlannerDecision('Here is JSON: {"schema":"deadbyte.autonomous-decision.v2","kind":"finish"}',f.policy),/structured|JSON|contract/i);
+    assert.throws(() => parseR34PlannerDecision(JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v2',kind:'act',action:{kind:'armcoding'}
+    }),f.policy),/unsupported|authority|contract/i);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R34 replan carries only a bounded mutable suffix proposal', async () => {
+  const f = await fixture();
+  try {
+    const decision = parseR34PlannerDecision(JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v2',kind:'replan',reason:'test failed',
+      steps:[
+        {step_id:'diagnose',intent:'Inspect failing evidence'},
+        {step_id:'fix',intent:'Apply corrected patch'}
+      ]
+    }),f.policy);
+    assert.equal(decision.schema,'deadbyte.autonomous-decision.v2');
+    assert.equal(decision.kind,'replan');
+    assert.equal(decision.steps.length,2);
+    assert.equal(decision.steps[0].step_id,'diagnose');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R34 act accepts one bounded existing patch action with exact SHA precondition', async () => {
+  const f = await fixture();
+  try {
+    const decision = parseR34PlannerDecision(JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v2',kind:'act',
+      action:{kind:'patch',operations:[{
+        kind:'replace',path:'x.txt',expected_sha256:'0'.repeat(64),old_string:'x',new_string:'y',expected_replacements:1
+      }]}
+    }),f.policy);
+    assert.equal(decision.kind,'act');
+    assert.equal(decision.action.kind,'patch');
+    assert.equal(decision.action.operations[0].expected_sha256,'0'.repeat(64));
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R34 provider adapter returns only normalized decision plus raw response hash', async () => {
+  const rawDecision = JSON.stringify({schema:'deadbyte.autonomous-decision.v2',kind:'finish',summary:'verified'});
+  const policy = {
+    planner:{backend:'openai_compatible',endpoint:'https://planner.invalid/v1/chat/completions',model:'fake-r34',api_key_env:null,max_tokens:2048,timeout_ms:30000,max_response_bytes:262144},
+    limits:{max_context_bytes:262144,max_files_per_diff:4},
+    profiles:{}
+  };
+  const fakeFetch = async () => new Response(JSON.stringify({model:'fake-r34',choices:[{message:{content:rawDecision}}]}),{
+    status:200,headers:{'content-type':'application/json'}
+  });
+  const result = await requestR34ProviderDecision(policy,'PROMPT',fakeFetch);
+  assert.equal(result.backend,'openai_compatible');
+  assert.equal(result.model,'fake-r34');
+  assert.equal(result.decision.kind,'finish');
+  assert.match(result.raw_response_sha256,/^[0-9a-f]{64}$/);
+  assert.equal(Object.hasOwn(result,'raw_text'),false);
+});
+
 test('R33 private delegate routes bounded machine reads and records signed evidence', async () => {
   const calls=[];
   const f = await fixture({ machineFsRuntime:{ async stat(args){ calls.push(args); return {status:'ok',root_id:args.rootId,path:args.relativePath,kind:'file',bytes:2}; } } });
@@ -327,3 +391,82 @@ test('signed autonomous journal tamper is rejected before state is trusted', asy
     await assert.rejects(f.runtime.status({ goalId:goal.goal_id }), /signature verification failed|hash-chain mismatch/);
   } finally { await rm(f.root,{recursive:true,force:true}); }
 });
+
+test('R34 event deletion/reorder/signature tamper fails before state trust', async () => {
+  async function prepared(id) {
+    const f=await fixture();
+    const goal=await submit(f.runtime,id);
+    const first=await f.runtime.run({goalId:goal.goal_id,maxCycles:1});
+    assert.equal(first.status,'input_required');
+    const dir=path.join(f.policy.evidence_dir,'goals',goal.goal_id,'events');
+    return {f,goal,dir};
+  }
+  for (const mode of ['delete','reorder','signature']) {
+    const {f,goal,dir}=await prepared(`journal-${mode}`);
+    try {
+      const one=path.join(dir,'000001.json');
+      const two=path.join(dir,'000002.json');
+      if(mode==='delete') {
+        await rm(two,{force:true});
+      } else if(mode==='reorder') {
+        const a=await readFile(one); const b=await readFile(two);
+        await writeFile(one,b); await writeFile(two,a);
+      } else {
+        const event=JSON.parse(await readFile(one,'utf8'));
+        event.payload.submission_id='forged-submission';
+        await writeFile(one,JSON.stringify(event));
+      }
+      await assert.rejects(f.runtime.status({goalId:goal.goal_id}),/event gap|signature verification failed|hash-chain mismatch/);
+    } finally { await rm(f.root,{recursive:true,force:true}); }
+  }
+});
+
+test('R34 restart reconciles a committed Native Diff after crash without invoking apply twice', async () => {
+  let applyCalls = 0;
+  let crashOnce = true;
+  const f = await fixture({
+    nativeDiffRuntimeFactory(base) {
+      return {
+        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 crash after native diff apply');
+          }
+          return result;
+        }
+      };
+    }
+  });
+  try {
+    const goal = await submit(f.runtime,'r34-crash-after-apply');
+    const first = await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    assert.equal(first.status,'input_required');
+    const before = await readFile(path.join(f.project,'x.txt'));
+    const beforeSha = createHash('sha256').update(before).digest('hex');
+    const patch = JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v1',action:'patch',summary:'mutate once',
+      operations:[{kind:'replace',path:'x.txt',expected_sha256:beforeSha,old_string:'x',new_string:'y',expected_replacements:1}]
+    });
+    await assert.rejects(f.runtime.run({goalId:goal.goal_id,maxCycles:2,
+      plannerResponse:{request_id:first.planner_request.request_id,model:'fake',raw_text:patch}}),/simulated crash after native diff apply/);
+    assert.equal(await readFile(path.join(f.project,'x.txt'),'utf8'),'y\n');
+    assert.equal(applyCalls,1);
+
+    const restarted = f.createRuntime();
+    const resumed = await restarted.run({goalId:goal.goal_id,maxCycles:1});
+    assert.notEqual(resumed.status,'paused');
+    assert.equal(applyCalls,1,'restart must reconcile durable mutation evidence instead of invoking apply again');
+    assert.equal(await readFile(path.join(f.project,'x.txt'),'utf8'),'y\n');
+    const journal = await restarted.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    assert.equal(journal.events.filter(event=>event.type==='native_diff_committed').length,1);
+    assert.equal(journal.events.filter(event=>event.type==='action_started').length,1);
+    assert.equal(journal.events.filter(event=>event.type==='action_reconciled').length,1);
+    assert.equal(journal.events.filter(event=>event.type==='action_completed').length,1);
+    const reconciled = journal.events.find(event=>event.type==='action_reconciled');
+    assert.equal(reconciled.payload.classification,'executed_verified');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});

package/test/autonomous-context-engine.test.mjs

@@ -0,0 +1,181 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import {
+  compactLoopContext,
+  deriveProjectMemory,
+  buildLoopContext
+} from '../src/autonomous-context-engine.mjs';
+import { buildPlannerPrompt } from '../src/autonomous-planner.mjs';
+
+const H = c => c.repeat(64);
+
+function oversizedContext() {
+  return {
+    goal:{title:'repair',goal:'repair source',acceptance:'tests pass'},
+    loop:{phase:'INSPECTING',mutation_epoch:1,planner_round:2},
+    working_context:{
+      active_plan:null,
+      current_step:null,
+      recent_contexts:[
+        {path:'old.txt',sha256:H('1'),bytes:20000,content:`OLD_SENTINEL:${'X'.repeat(70000)}`},
+        {path:'latest.txt',sha256:H('2'),bytes:20000,content:`LATEST_SENTINEL:${'L'.repeat(8000)}`}
+      ],
+      recent_observations:[],
+      active_identities:[],
+      recent_decisions:[]
+    },
+    historical_evidence:{
+      compacted_events:[{
+        request_sha256:H('a'),receipt_sha256:H('b'),expected_sha256:H('c'),
+        failure_cause:'test_failed',raw_payload:`OLD_RAW_PAYLOAD_SENTINEL${'Y'.repeat(160000)}`
+      }],
+      failures:[{cause:'test_failed',receipt_sha256:H('d')}],
+      receipts:[{receipt_id:'receipt-1',receipt_sha256:H('e')}],
+      mutation_epochs:[0,1],
+      plan_transitions:[]
+    },
+    project_memory:{
+      acceptance_constraints:['tests pass'],
+      proven_invariants:[`source_sha=${H('f')}`],
+      rejected_approaches:[],
+      important_files:[{path:'latest.txt',sha256:H('2')}],
+      unresolved_blockers:['test_failed']
+    },
+    profiles:[]
+  };
+}
+
+test('compaction preserves proof identity while dropping stale payload bytes', () => {
+  const compacted = compactLoopContext(oversizedContext(),65536);
+  const json = canonicalJson(compacted);
+  assert.ok(Buffer.byteLength(json,'utf8') <= 65536);
+  assert.match(json,/receipt_sha256/);
+  assert.match(json,/request_sha256/);
+  assert.match(json,/expected_sha256/);
+  assert.match(json,/test_failed/);
+  assert.match(json,/unresolved_blockers/);
+  assert.match(json,/LATEST_SENTINEL/);
+  assert.doesNotMatch(json,/OLD_RAW_PAYLOAD_SENTINEL/);
+  assert.doesNotMatch(json,/OLD_SENTINEL/);
+  assert.match(json,/content_elided/);
+});
+
+test('same input always produces byte-identical compacted context', () => {
+  const a = canonicalJson(compactLoopContext(oversizedContext(),65536));
+  const b = canonicalJson(compactLoopContext(oversizedContext(),65536));
+  assert.equal(a,b);
+});
+
+test('secret-like fields are redacted without exposing raw values or a hash oracle', () => {
+  const context = oversizedContext();
+  context.project_memory.credentials = {
+    api_token:'super-secret-token',
+    password:'correct horse battery staple',
+    authorization:'Bearer abc123'
+  };
+  const compacted = compactLoopContext(context,65536);
+  const json = canonicalJson(compacted);
+  assert.doesNotMatch(json,/super-secret-token/);
+  assert.doesNotMatch(json,/correct horse battery staple/);
+  assert.doesNotMatch(json,/Bearer abc123/);
+  assert.match(json,/"reason":"secret"/);
+  const redacted = compacted.project_memory.credentials;
+  assert.equal(redacted.redacted,true);
+  assert.equal(redacted.reason,'secret');
+  assert.equal(Object.hasOwn(redacted,'sha256'),false);
+});
+
+test('project memory derives stable acceptance, failures and unresolved blockers from journal events', () => {
+  const memory = deriveProjectMemory([
+    {type:'goal_created',payload:{acceptance:'build and tests pass'}},
+    {type:'profile_completed',payload:{profile_id:'test',passed:false,receipt_sha256:H('1')}},
+    {type:'native_diff_committed',payload:{paths:['src/a.mjs'],diff_receipt_sha256:H('2')}},
+    {type:'profile_completed',payload:{profile_id:'test',passed:true,receipt_sha256:H('3')}}
+  ]);
+  assert.deepEqual(memory.acceptance_constraints,['build and tests pass']);
+  assert.ok(memory.proven_invariants.some(value => value.includes('test')));
+  assert.equal(memory.unresolved_blockers.length,0);
+  assert.ok(memory.important_files.some(item => item.path === 'src/a.mjs'));
+});
+
+test('buildLoopContext produces the three named layers and respects the policy budget', () => {
+  const built = buildLoopContext({
+    goal:{title:'repair',goal:'repair source',acceptance:'tests pass'},
+    policy:{limits:{max_context_bytes:65536},profiles:{}},
+    loopState:{phase:'INSPECTING',mutation_epoch:0,planner_round:1,plan:null,current_step:null},
+    tree:[{path:'src/a.mjs',type:'file'}],
+    contexts:[{path:'src/a.mjs',sha256:H('1'),bytes:4,content:'code'}],
+    observations:[],
+    decisions:[],
+    projectMemory:null
+  });
+  assert.ok(built.working_context);
+  assert.ok(built.historical_evidence);
+  assert.ok(built.project_memory);
+  assert.ok(Buffer.byteLength(canonicalJson(built),'utf8') <= 65536);
+});
+
+test('R35 buildLoopContext attaches provenance and deduplicates identical retained context by newest observation', () => {
+  const built = buildLoopContext({
+    goal:{title:'repair',goal:'repair source',acceptance:'tests pass'},
+    policy:{limits:{max_context_bytes:65536},profiles:{}},
+    loopState:{phase:'INSPECT',mutation_epoch:3,planner_round:2,plan:null,current_step:null},
+    contexts:[
+      {path:'src/a.mjs',sha256:H('1'),bytes:4,content:'code',observed_at_utc:'2026-09-17T09:00:00.000Z'},
+      {path:'src/a.mjs',sha256:H('1'),bytes:4,content:'code',observed_at_utc:'2026-09-17T09:00:05.000Z'}
+    ],
+    observations:[],decisions:[],tree:[],projectMemory:null
+  });
+  assert.equal(built.working_context.recent_contexts.length,1);
+  const retained=built.working_context.recent_contexts[0];
+  assert.equal(retained.observed_at_utc,'2026-09-17T09:00:05.000Z');
+  assert.equal(retained.provenance.source_kind,'context');
+  assert.equal(retained.provenance.source_id,'src/a.mjs');
+  assert.match(retained.provenance.source_sha256,/^[0-9a-f]{64}$/);
+  assert.equal(retained.provenance.relevance_epoch,3);
+});
+
+test('R35 deterministic compaction elides payload but preserves provenance envelope', () => {
+  const built=buildLoopContext({
+    goal:{title:'repair',goal:'repair source',acceptance:'tests pass'},
+    policy:{limits:{max_context_bytes:32768},profiles:{}},
+    loopState:{phase:'INSPECT',mutation_epoch:7,planner_round:2,plan:null,current_step:null},
+    contexts:[
+      {path:'src/old.mjs',sha256:H('3'),bytes:70000,content:'OLD:'+('X'.repeat(70000)),observed_at_utc:'2026-09-17T09:00:00.000Z'},
+      {path:'src/current.mjs',sha256:H('4'),bytes:7,content:'current',observed_at_utc:'2026-09-17T09:01:00.000Z'}
+    ],observations:[],decisions:[],tree:[],projectMemory:null
+  });
+  const old=built.working_context.recent_contexts.find(item=>item.path==='src/old.mjs');
+  assert.ok(old);
+  assert.equal(old.content,undefined);
+  assert.equal(old.content_elided,true);
+  assert.equal(old.provenance.source_id,'src/old.mjs');
+  assert.match(old.provenance.source_sha256,/^[0-9a-f]{64}$/);
+  assert.match(old.provenance.provenance_id,/^[0-9a-f]{64}$/);
+});
+
+test('planner prompt serializes the R34 three-layer context instead of the legacy flat state', () => {
+  const policy = { limits:{max_context_bytes:65536}, profiles:{} };
+  const prompt = buildPlannerPrompt({
+    goal:{title:'repair',goal:'repair source',acceptance:'tests pass'},
+    policy,
+    view:{
+      mutation_epoch:0,
+      planner_round:1,
+      tree:[{path:'src/a.mjs',type:'file'}],
+      contexts:[{path:'src/a.mjs',sha256:H('1'),bytes:4,content:'code'}],
+      observations:[],
+      active_plan:null,
+      recent_decisions:[]
+    }
+  });
+  const stateText = prompt.match(/STATE=(.*)\nExample shape:/s)?.[1];
+  assert.ok(stateText);
+  const state = JSON.parse(stateText);
+  assert.ok(state.working_context);
+  assert.ok(state.historical_evidence);
+  assert.ok(state.project_memory);
+  assert.equal(Object.hasOwn(state,'contexts'),false);
+  assert.equal(Object.hasOwn(state,'observations'),false);
+});

package/test/autonomous-live-state.test.mjs

@@ -0,0 +1,27 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  promptContexts,
+  promptObservations,
+  promptMutationEpoch
+} from '../src/autonomous-live-state.mjs';
+
+const context = { path:'workspaces/autonomous-live/fixture.txt', content:'READY\n', sha256:'a'.repeat(64), bytes:6 };
+const observation = { profile_id:'quick-test', passed:false };
+
+test('R34 compact planner state projects recent context, observations, and mutation epoch', () => {
+  const state = {
+    loop:{ mutation_epoch:2 },
+    working_context:{ recent_contexts:[context], recent_observations:[observation] }
+  };
+  assert.deepEqual(promptContexts(state), [context]);
+  assert.deepEqual(promptObservations(state), [observation]);
+  assert.equal(promptMutationEpoch(state), 2);
+});
+
+test('legacy planner state remains compatible', () => {
+  const state = { mutation_epoch:1, contexts:[context], observations:[observation] };
+  assert.deepEqual(promptContexts(state), [context]);
+  assert.deepEqual(promptObservations(state), [observation]);
+  assert.equal(promptMutationEpoch(state), 1);
+});