deadbyte-mcp 0.8.7

package/test/autonomous-adversarial.test.mjs

@@ -0,0 +1,329 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { randomBytes } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+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';
+
+const nonce = () => randomBytes(32).toString('hex');
+async function fixture(delegates = {}) {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r24-adv-'));
+  const project = path.join(root, 'project'); const trust = path.join(root, 'trust');
+  await mkdir(project); await mkdir(trust); await writeFile(path.join(project,'x.txt'),'x\n');
+  const keys = await generateTrustKeypair({ privateKeyPath:path.join(trust,'private.pem'), publicKeyPath:path.join(trust,'public.pem') });
+  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-lease.json'), evidence_dir:path.join(root,'coding-evidence'),
+    roots:{ project:{ path:project, read:true, write:true, exec:false, deny_paths:[] } }, commands:{} }));
+  const codingPolicy = await loadCodingPolicy(codingPath);  await writeFile(codingPolicy.lease_file, JSON.stringify({ schema:'deadbyte.coding-lease.v1', policy_sha256:codingPolicy.policy_sha256,
+    instance_nonce:nonce(), root_ids:['project'], armed_at_utc:new Date().toISOString(), expires_at_utc:new Date(Date.now()+3600000).toISOString() }));
+  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-lease.json'), evidence_dir:path.join(root,'autonomous-evidence'), root_ids:['project'],
+    coding_policy_sha256:codingPolicy.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 } }));
+  const policy = await loadAutonomousPolicy(autonomousPath,codingPolicy);
+  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 autonomousCodingRuntime = codingRuntimeFactory ? codingRuntimeFactory(codingRuntime) : codingRuntime;
+  if (observationRuntimeFactory) runtimeDelegates.observationRuntime = observationRuntimeFactory({ codingPolicy,keys });
+  const runtime = createAutonomousRuntime({ policy,codingRuntime:autonomousCodingRuntime,nativeDiffRuntime,...runtimeDelegates,
+    signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath });
+  return { root,project,keys,codingPolicy,policy,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.' });
+}
+test('planner prompt compacts stale context payloads before failing the byte budget', () => {
+  const policy = { limits:{ max_context_bytes:65536 }, profiles:{} };
+  const contexts = Array.from({ length:8 }, (_,index) => ({
+    path:`context-${index}.txt`, sha256:String(index).repeat(64).slice(0,64), bytes:20000,
+    content:index === 7 ? `LATEST_SENTINEL:${'L'.repeat(19980)}` : `OLD_SENTINEL_${index}:${'X'.repeat(19980)}`
+  }));
+  const prompt = buildPlannerPrompt({
+    goal:{ title:'compact', goal:'keep current evidence', acceptance:'fit the planner byte budget' },
+    policy,
+    view:{ mutation_epoch:0, planner_round:0, tree:[], contexts, observations:[], recent_decisions:[] }
+  });
+  assert.match(prompt,/LATEST_SENTINEL/);
+  assert.doesNotMatch(prompt,/OLD_SENTINEL_0/);
+  assert.match(prompt,/content_elided/);
+  const stateText = prompt.match(/STATE=(.*)\nExample shape:/s)?.[1];
+  assert.ok(stateText);
+  assert.ok(Buffer.byteLength(stateText,'utf8') <= policy.limits.max_context_bytes);
+});
+
+test('planner accepts a strict authoritative plan snapshot without adding a new agent round', async () => {
+  const f = await fixture();
+  try {
+    const decision = parsePlannerDecision(JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'inspect under plan',
+      reads:[{path:'x.txt',max_bytes:4096}],
+      plan:{ title:'Inspect safely', steps:[
+        { step_id:'inspect', title:'Inspect x.txt', status:'running' },
+        { step_id:'finish', title:'Finish with evidence', status:'pending' }
+      ] }
+    }),f.policy);
+    assert.equal(decision.plan.title,'Inspect safely');
+    assert.equal(decision.plan.steps[0].status,'running');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('completed authoritative plan hard-blocks further work before native diff mutation', async () => {
+  const f = await fixture();
+  try {
+    const goal = await submit(f.runtime,'plan-complete-guard');
+    const first = await f.runtime.run({ goalId:goal.goal_id, maxCycles:4 });
+    const initialPlan = { title:'Guarded work', steps:[
+      { step_id:'inspect', title:'Inspect x.txt', status:'running' },
+      { step_id:'finish', title:'Finish', status:'pending' }
+    ] };
+    let result = await f.runtime.run({ goalId:goal.goal_id, maxCycles:4,
+      plannerResponse:{ request_id:first.planner_request.request_id, model:'fake', raw_text:JSON.stringify({
+        schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'inspect x', reads:[{path:'x.txt',max_bytes:4096}], plan:initialPlan
+      }) } });
+    assert.equal(result.status,'input_required');
+    const completedPlan = { title:'Guarded work', steps:[
+      { step_id:'inspect', title:'Inspect x.txt', status:'completed' },
+      { step_id:'finish', title:'Finish', status:'completed' }
+    ] };
+    result = await f.runtime.run({ goalId:goal.goal_id, maxCycles:4,
+      plannerResponse:{ request_id:result.planner_request.request_id, model:'fake', raw_text:JSON.stringify({
+        schema:'deadbyte.autonomous-decision.v1', action:'patch', summary:'must be blocked after plan complete', plan:completedPlan,
+        operations:[{kind:'replace',path:'x.txt',expected_sha256:'0'.repeat(64),old_string:'x',new_string:'y',expected_replacements:1}]
+      }) } });
+    assert.equal(result.status,'input_required');
+    assert.equal(await readFile(path.join(f.project,'x.txt'),'utf8'),'x\n');
+    const status = await f.runtime.status({ goalId:goal.goal_id });
+    assert.equal(status.active_plan.steps.every(step => step.status === 'completed'),true);
+    const journal = await f.runtime.events({ goalId:goal.goal_id, fromSeq:1, limit:100 });
+    assert.ok(journal.events.some(event => event.type === 'plan_guard_blocked' && event.payload?.reason === 'plan_complete_requires_finish'));
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('planner parser rejects malformed JSON and unknown top-level fields', async () => {
+  const f = await fixture();
+  try {
+    assert.throws(() => parsePlannerDecision('not-json',f.policy), /strict JSON/);
+    assert.throws(() => parsePlannerDecision(JSON.stringify({ schema:'deadbyte.autonomous-decision.v1', action:'pause', summary:'x', reason:'x', surprise:true }),f.policy), /unknown field/);
+    assert.throws(() => parsePlannerDecision(JSON.stringify({ schema:'deadbyte.autonomous-decision.v1', action:'delegate', summary:'inject',
+      operation:{kind:'process_action',session_id:'0'.repeat(64),action_id:'ping',raw_input:'whoami\\r\\n'} }),f.policy), /unknown field/);
+    assert.throws(() => parsePlannerDecision(JSON.stringify({ schema:'deadbyte.autonomous-decision.v1', action:'delegate', summary:'widen',
+      operation:{kind:'process_start',profile_id:'safe',cwd:'.',executable:'cmd.exe'} }),f.policy), /unknown field/);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+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}; } } });
+  try {
+    const goal=await submit(f.runtime,'r33-machine-stat');
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2,plannerResponse:{request_id:result.planner_request.request_id,model:'fake',raw_text:JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v1',action:'delegate',summary:'bounded stat',operation:{kind:'machine_stat',path:'x.txt',hash:true}
+    })}});
+    assert.equal(result.status,'input_required');
+    assert.deepEqual(calls,[{rootId:'project',relativePath:'x.txt',hash:true}]);
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:100});
+    const completed=journal.events.find(event=>event.type==='delegated_action_completed');
+    assert.equal(completed.payload.operation.kind,'machine_stat');
+    assert.match(completed.payload.evidence.result_sha256,/^[0-9a-f]{64}$/);
+    result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2,plannerResponse:{request_id:result.planner_request.request_id,model:'fake',raw_text:JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v1',action:'finish',summary:'delegated evidence complete'
+    })}});
+    assert.equal(result.status,'completed');
+    const verified=await f.runtime.verify({goalId:goal.goal_id});
+    assert.equal(verified.ok,true);
+    assert.equal(verified.delegated_actions_verified,1);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R33 stale delegated identities fail closed into a signed pause', async () => {
+  const f = await fixture({ processRuntime:{ async status(){ throw new Error('unknown process session'); } } });
+  try {
+    const goal=await submit(f.runtime,'r33-stale-session');
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2,plannerResponse:{request_id:result.planner_request.request_id,model:'fake',raw_text:JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v1',action:'delegate',summary:'stale status',operation:{kind:'process_status',session_id:'1'.repeat(64)}
+    })}});
+    assert.equal(result.status,'paused');
+    assert.equal(result.reason,'delegated_action_failed');
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:100});
+    assert.ok(journal.events.some(event=>event.type==='goal_paused'&&/stale or belongs to another goal/.test(event.payload.detail)));
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R33 delegated output over the planner context budget fails closed', async () => {
+  const f = await fixture({ machineFsRuntime:{ async read(){ return {status:'ok',data_base64:'A'.repeat(300000)}; } } });
+  try {
+    const goal=await submit(f.runtime,'r33-output-bound');
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2,plannerResponse:{request_id:result.planner_request.request_id,model:'fake',raw_text:JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v1',action:'delegate',summary:'bounded read',operation:{kind:'machine_read',path:'x.txt',max_bytes:16}
+    })}});
+    assert.equal(result.status,'paused');
+    assert.equal(result.reason,'delegated_action_failed');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R33 rechecks authority immediately before a delegated process mutation', async () => {
+  let checks=0,actions=0;
+  const f = await fixture({
+    codingRuntimeFactory(base){ return { ...base, async sessionStatus(){ checks++; const status=await base.sessionStatus();
+      return checks>=4?{...status,armed:false,reason:'revoked mid-run'}:status; } }; },
+    processRuntime:{ async start(){ actions++; return {session_id:'3'.repeat(64)}; }, async verifyEventJournal(){ return {ok:true,event_count:1,head_sha256:'2'.repeat(64)}; } }
+  });
+  try {
+    const goal=await submit(f.runtime,'r33-mid-run-revoke');
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2,plannerResponse:{request_id:result.planner_request.request_id,model:'fake',raw_text:JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v1',action:'delegate',summary:'must recheck',operation:{kind:'process_start',profile_id:'safe',cwd:'.'}
+    })}});
+    assert.equal(result.status,'paused');
+    assert.equal(result.reason,'delegated_action_failed');
+    assert.equal(actions,0);
+    assert.equal(checks,4);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R33 process delegates retain owned-session identity and verified journal evidence', async () => {
+  const sessionId='4'.repeat(64),calls=[];
+  const processRuntime={
+    async start(args){calls.push(['start',args]);return {session_id:sessionId,state:'running'};},
+    async action(args){calls.push(['action',args]);return {action_id:args.actionId,logical_bytes:4,logical_sha256:'5'.repeat(64),session:{session_id:sessionId,state:'running'}};},
+    async terminate(args){calls.push(['terminate',args]);return {session_id:sessionId,state:'terminated'};},
+    async verifyEventJournal(){return {ok:true,event_count:calls.length,head_sha256:String(5+calls.length).repeat(64)};}
+  };
+  const f=await fixture({processRuntime});
+  try {
+    const goal=await submit(f.runtime,'r33-owned-process');
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    const decisions=[
+      {kind:'process_start',profile_id:'safe',cwd:'.'},
+      {kind:'process_action',session_id:sessionId,action_id:'ping'},
+      {kind:'process_terminate',session_id:sessionId}
+    ];
+    for(const [index,operation] of decisions.entries()){
+      result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2,plannerResponse:{request_id:result.planner_request.request_id,model:'fake',raw_text:JSON.stringify({
+        schema:'deadbyte.autonomous-decision.v1',action:'delegate',summary:`process ${index}`,operation
+      })}});
+      assert.equal(result.status,'input_required');
+    }
+    assert.deepEqual(calls.map(item=>item[0]),['start','action','terminate']);
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:200});
+    const completed=journal.events.filter(event=>event.type==='delegated_action_completed');
+    assert.equal(completed.length,3);
+    assert.ok(completed.every(event=>event.payload.evidence.kind==='process_journal'));
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('R33 rejects a delegated observation result whose signed receipt cannot be verified', async () => {
+  const f = await fixture({ observationRuntimeFactory:({codingPolicy})=>({ policy:codingPolicy, async systemStatus(){
+    return {status:'ok',receipt_id:'a'.repeat(24),receipt_sha256:'b'.repeat(64),request_sha256:'c'.repeat(64)};
+  } }) });
+  try {
+    const goal=await submit(f.runtime,'r33-observation-receipt-mismatch');
+    let result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2});
+    result=await f.runtime.run({goalId:goal.goal_id,maxCycles:2,plannerResponse:{request_id:result.planner_request.request_id,model:'fake',raw_text:JSON.stringify({
+      schema:'deadbyte.autonomous-decision.v1',action:'delegate',summary:'bad receipt',operation:{kind:'observation_system_status'}
+    })}});
+    assert.equal(result.status,'paused');
+    assert.equal(result.reason,'delegated_action_failed');
+    const journal=await f.runtime.events({goalId:goal.goal_id,fromSeq:1,limit:100});
+    assert.ok(journal.events.some(event=>event.type==='goal_paused'&&/receipt mismatch/.test(event.payload.detail)));
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('client sampling response must bind the exact pending request id', async () => {
+  const f = await fixture();
+  try {
+    const goal = await submit(f.runtime,'wrong-request');
+    const first = await f.runtime.run({ goalId:goal.goal_id, maxCycles:2 });
+    assert.equal(first.status,'input_required');
+    await assert.rejects(f.runtime.run({ goalId:goal.goal_id, maxCycles:2,
+      plannerResponse:{ request_id:'0'.repeat(64), model:'fake', raw_text:'{}' } }), /request_id mismatch/);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+test('invalid client planner contract yields a signed repair request', async () => {
+  const f = await fixture();
+  try {
+    const goal = await submit(f.runtime,'planner-repair');
+    const first = await f.runtime.run({ goalId:goal.goal_id, maxCycles:2 });
+    assert.equal(first.status,'input_required');
+    const bad = JSON.stringify({ schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'missing reads' });
+    const repaired = await f.runtime.run({ goalId:goal.goal_id, maxCycles:2,
+      plannerResponse:{ request_id:first.planner_request.request_id, model:'fake', raw_text:bad } });
+    assert.equal(repaired.status,'input_required');
+    assert.notEqual(repaired.planner_request.request_id,first.planner_request.request_id);
+    assert.match(repaired.planner_request.prompt,/PREVIOUS_RESPONSE_REJECTED/);
+    assert.match(repaired.planner_request.prompt,/planner inspect reads invalid/);
+    const journal = await f.runtime.events({ goalId:goal.goal_id, fromSeq:1, limit:100 });
+    const rejected = journal.events.find(event => event.type === 'planner_rejected');
+    assert.ok(rejected);
+    assert.equal(rejected.payload.request_id,first.planner_request.request_id);
+    assert.match(rejected.payload.response_sha256,/^[0-9a-f]{64}$/);
+    assert.match(rejected.payload.reason,/planner inspect reads invalid/);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('three invalid planner contracts pause instead of retrying forever', async () => {
+  const f = await fixture();
+  try {
+    const goal = await submit(f.runtime,'planner-repair-limit');
+    let result = await f.runtime.run({ goalId:goal.goal_id, maxCycles:2 });
+    const bad = JSON.stringify({ schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'missing reads' });
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+      result = await f.runtime.run({ goalId:goal.goal_id, maxCycles:2,
+        plannerResponse:{ request_id:result.planner_request.request_id, model:'fake', raw_text:bad } });
+      if (attempt < 3) assert.equal(result.status,'input_required');
+    }
+    assert.equal(result.status,'paused');
+    assert.equal(result.reason,'planner_contract_repeated_failure');
+    const journal = await f.runtime.events({ goalId:goal.goal_id, fromSeq:1, limit:100 });
+    assert.equal(journal.events.filter(event => event.type === 'planner_rejected').length,3);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('autonomous execution fails closed when coding authority is revoked', async () => {
+  const f = await fixture();
+  try {
+    const goal = await submit(f.runtime,'coding-revoked');
+    await rm(f.codingPolicy.lease_file,{force:true});
+    await assert.rejects(f.runtime.run({ goalId:goal.goal_id, maxCycles:1 }), /coding plane is disarmed/);
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+
+test('three identical planner decisions trigger no-progress pause', async () => {
+  const f = await fixture();
+  try {
+    const goal = await submit(f.runtime,'no-progress');
+    let result = await f.runtime.run({ goalId:goal.goal_id, maxCycles:4 });
+    const decision = JSON.stringify({ schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'same read', reads:[{path:'x.txt',max_bytes:4096}] });
+    for (let i=0; i<3 && result.status === 'input_required'; i += 1) {
+      result = await f.runtime.run({ goalId:goal.goal_id, maxCycles:4,
+        plannerResponse:{ request_id:result.planner_request.request_id, model:'fake', raw_text:decision } });
+    }
+    assert.equal(result.status,'paused');
+    assert.equal(result.reason,'no_progress_repeated_decision');
+  } finally { await rm(f.root,{recursive:true,force:true}); }
+});
+test('signed autonomous journal tamper is rejected before state is trusted', async () => {
+  const f = await fixture();
+  try {
+    const goal = await submit(f.runtime,'journal-tamper');
+    const eventFile = path.join(f.policy.evidence_dir,'goals',goal.goal_id,'events','000001.json');
+    const event = JSON.parse(await readFile(eventFile,'utf8'));
+    event.payload.title = 'forged';
+    await writeFile(eventFile,JSON.stringify(event));
+    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}); }
+});

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

@@ -0,0 +1,10 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+const fixture = fileURLToPath(new URL('../workspaces/autonomous-live/fixture.txt', import.meta.url));
+
+test('R24 live autonomous fixture is restored to release state', async () => {
+  assert.equal(await readFile(fixture, 'utf8'), 'READY\n');
+});

package/test/autonomous-loop.test.mjs

@@ -0,0 +1,188 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+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 { startAutonomousSupervisor } from '../src/autonomous-supervisor.mjs';
+
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+async function startPlanner(decisions) {
+  const prompts = [];
+  const server = createServer(async (req,res) => {
+    let body = '';
+    for await (const chunk of req) body += chunk;
+    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'); }
+    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 } }] }));
+  });
+  await new Promise(resolve => server.listen(0,'127.0.0.1',resolve));
+  return { server, prompts, endpoint:`http://127.0.0.1:${server.address().port}/v1/chat/completions` };
+}
+async function fixture(decisionPrefix = []) {
+  const root = await mkdtemp(path.join(os.tmpdir(),'deadbyte-autonomous-loop-'));
+  const project = path.join(root,'project'); const trust = path.join(root,'trust');
+  await mkdir(project); await mkdir(trust);
+  const keys = await generateTrustKeypair({
+    privateKeyPath:path.join(trust,'private.pem'), publicKeyPath:path.join(trust,'public.pem')
+  });
+  const program = path.join(project,'program.mjs');
+  await writeFile(program,"export const value = 'broken';\n");
+  await writeFile(path.join(project,'build.mjs'),
+    "const m=await import('./program.mjs?build='+Date.now()); console.log(typeof m.value);\n");
+  await writeFile(path.join(project,'test.mjs'),
+    "const m=await import('./program.mjs?test='+Date.now()); if(m.value!=='fixed'){console.error('expected fixed got '+m.value);process.exit(1)} console.log('TEST_OK');\n");
+  await writeFile(path.join(project,'bench.mjs'),
+    "const m=await import('./program.mjs?bench='+Date.now()); let x=0; for(let i=0;i<10000;i++)x+=m.value.length; if(x<1)process.exit(2); console.log('BENCH_OK');\n");
+  const nodeHash = sha(await readFile(process.execPath));
+  const codingPolicyPath = path.join(root,'coding-policy.json');
+  await writeFile(codingPolicyPath,JSON.stringify({ schema:'deadbyte.coding-policy.v1', enabled:true,
+    lease_file:path.join(root,'coding-lease.json'), evidence_dir:path.join(root,'coding-evidence'),
+    roots:{ project:{ path:project, read:true, write:true, exec:true, deny_paths:[] } },
+    commands:{ node_script:{ kind:'script', executable:process.execPath, executable_sha256:nodeHash,
+      root_ids:['project'], prefix_args:[], extensions:['.mjs'], timeout_ms:120000, max_output_bytes:1048576 } }
+  },null,2));
+  const codingPolicy = await loadCodingPolicy(codingPolicyPath);
+  await writeFile(codingPolicy.lease_file,JSON.stringify({ schema:'deadbyte.coding-lease.v1',
+    policy_sha256:codingPolicy.policy_sha256, instance_nonce:randomBytes(32).toString('hex'), root_ids:['project'],
+    armed_at_utc:new Date().toISOString(), expires_at_utc:new Date(Date.now()+3600000).toISOString() }));
+  const buildHash = sha(await readFile(path.join(project,'build.mjs')));
+  const testHash = sha(await readFile(path.join(project,'test.mjs')));
+  const benchHash = sha(await readFile(path.join(project,'bench.mjs')));
+  const initialHash = sha(await readFile(program));
+  const almostBytes = Buffer.from("export const value = 'almost';\n");
+  const almostHash = sha(almostBytes);
+  const fixedBytes = Buffer.from("export const value = 'fixed';\n");
+  const fixedHash = sha(fixedBytes);
+  const decisions = [...decisionPrefix,
+    { schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'inspect program', reads:[{path:'program.mjs',max_bytes:4096}] },
+    { schema:'deadbyte.autonomous-decision.v1', action:'patch', summary:'first repair attempt', operations:[
+      {kind:'replace',path:'program.mjs',expected_sha256:initialHash,old_string:"'broken'",new_string:"'almost'",expected_replacements:1}] },
+    { schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'diagnose failed test', reads:[{path:'program.mjs',max_bytes:4096}] },
+    { schema:'deadbyte.autonomous-decision.v1', action:'patch', summary:'correct after test evidence', operations:[
+      {kind:'replace',path:'program.mjs',expected_sha256:almostHash,old_string:"'almost'",new_string:"'fixed'",expected_replacements:1}] },
+    { schema:'deadbyte.autonomous-decision.v1', action:'finish', summary:'all acceptance evidence passes' }
+  ];
+  const planner = await startPlanner(decisions);
+  const autonomousPolicyPath = path.join(root,'autonomous-policy.json');
+  await writeFile(autonomousPolicyPath,JSON.stringify({ schema:'deadbyte.autonomous-policy.v1', enabled:true,
+    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 },
+    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,
+        description:'syntax/import build check' },
+      test:{ kind:'command', root_id:'project', command_id:'node_script', script_path:'test.mjs',
+        script_sha256:testHash, args:[], cwd:'.', required_for_release:true, run_after_mutation:true,
+        description:'behavior regression test' },
+      bench:{ kind:'benchmark', root_id:'project', command_id:'node_script', script_path:'bench.mjs',
+        script_sha256:benchHash, args:[], cwd:'.', warmups:0, iterations:2, baseline_median_ms:null,
+        max_regression_pct:5, required_for_release:true, run_after_mutation:true,
+        description:'bounded benchmark' }
+    }, limits:{ max_iterations:10, max_mutations:8, max_wall_ms:300000,
+      max_context_bytes:524288, max_diff_bytes:262144, max_files_per_diff:4 }
+  },null,2));
+  const policy = await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy);
+  await writeFile(policy.lease_file,JSON.stringify({ schema:'deadbyte.autonomous-lease.v1',
+    policy_sha256:policy.policy_sha256, instance_nonce:randomBytes(32).toString('hex'), 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 nativeDiff = createNativeDiffRuntime({ policy,codingRuntime,
+    signingKeyPath:keys.privateKeyPath, verifyKeyPath:keys.publicKeyPath });
+  const runtime = createAutonomousRuntime({ policy,codingRuntime,nativeDiffRuntime:nativeDiff,
+    signingKeyPath:keys.privateKeyPath, verifyKeyPath:keys.publicKeyPath });
+  return { root,project,program,keys,policy,codingRuntime,nativeDiff,runtime,planner,
+    initialHash,almostHash,fixedHash };
+}
+
+test('R24 autonomous goal diagnoses a failing test, replans with native diff, benchmarks, and releases', async () => {
+  const f = await fixture();
+  try {
+    const submitted = await f.runtime.submit({ submissionId:'full-loop', rootId:'project',
+      title:'repair program', goal:'make exported value equal fixed', acceptance:'build, test, and benchmark must pass',
+      maxIterations:10 });
+    assert.equal(submitted.status,'accepted');
+    const result = await f.runtime.run({ goalId:submitted.goal_id, maxCycles:16 });
+    assert.equal(result.status,'completed');
+    assert.equal(await readFile(f.program,'utf8'),"export const value = 'fixed';\n");
+    const status = await f.runtime.status({ goalId:submitted.goal_id });
+    assert.equal(status.state,'succeeded');
+    assert.equal(status.mutation_epoch,2);
+    assert.equal(status.mutation_count,2);
+    assert.ok(status.observations.some(item => item.profile_id === 'test' && item.passed === false));
+    assert.ok(status.observations.some(item => item.profile_id === 'test' && item.passed === true && item.mutation_epoch === 2));
+    assert.ok(status.observations.some(item => item.profile_id === 'bench' && item.passed === true && item.mutation_epoch === 2));
+    assert.equal(f.planner.prompts.length,5);
+    assert.match(f.planner.prompts[2],/expected fixed got almost/);
+    const verified = await f.runtime.verify({ goalId:submitted.goal_id });
+    assert.equal(verified.ok,true);
+    assert.equal(verified.native_diffs_verified,2);
+    assert.equal(verified.required_profiles_verified,3);
+    const gate = await f.runtime.releaseGate({ goalId:submitted.goal_id });
+    assert.equal(gate.status,'existing');
+    assert.equal(gate.ready,true);
+  } finally {
+    await new Promise(resolve => f.planner.server.close(resolve));
+    await rm(f.root,{recursive:true,force:true});
+  }
+});
+
+test('provider planner repairs an invalid structured decision inside the same run', async () => {
+  const f = await fixture(['not-json']);
+  try {
+    const submitted = await f.runtime.submit({ submissionId:'provider-repair', rootId:'project',
+      title:'repair after planner contract error', goal:'make exported value equal fixed',
+      acceptance:'build, test, and benchmark must pass', maxIterations:10 });
+    const result = await f.runtime.run({ goalId:submitted.goal_id, maxCycles:16 });
+    assert.equal(result.status,'completed');
+    assert.equal(await readFile(f.program,'utf8'),"export const value = 'fixed';\n");
+    assert.equal(f.planner.prompts.length,6);
+    assert.match(f.planner.prompts[1],/PREVIOUS_RESPONSE_REJECTED/);
+    const journal = await f.runtime.events({ goalId:submitted.goal_id, fromSeq:1, limit:200 });
+    const rejected = journal.events.filter(event => event.type === 'planner_rejected');
+    assert.equal(rejected.length,1);
+    assert.match(rejected[0].payload.reason,/strict JSON/);
+    assert.equal((await f.runtime.verify({ goalId:submitted.goal_id })).ok,true);
+  } finally {
+    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,
+    logger:{ warn(){} } });
+  try {
+    const submitted = await f.runtime.submit({ submissionId:'background-loop', rootId:'project',
+      title:'background repair', goal:'make exported value equal fixed',
+      acceptance:'build, test, and benchmark must pass', maxIterations:10 });
+    const deadline = Date.now() + 20_000;
+    let status;
+    do {
+      status = await f.runtime.status({ goalId:submitted.goal_id });
+      if (status.state === 'succeeded') break;
+      if (status.state === 'paused' || status.state === 'cancelled') throw new Error(`supervisor stopped in ${status.state}: ${status.reason}`);
+      await new Promise(resolve => setTimeout(resolve, 25));
+    } while (Date.now() < deadline);
+    assert.equal(status.state, 'succeeded');
+    assert.equal(await readFile(f.program,'utf8'), "export const value = 'fixed';\n");
+    assert.equal((await f.runtime.verify({ goalId:submitted.goal_id })).ok, true);
+  } finally {
+    await supervisor.stop();
+    await new Promise(resolve => f.planner.server.close(resolve));
+    await rm(f.root,{recursive:true,force:true});
+  }
+});

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

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  autonomousGoalVerifyOutputSchema,
+  autonomousStructuredResult
+} from '../src/autonomous-output-contracts.mjs';
+
+test('autonomous_goal_verify structured contract preserves delegated action evidence count', () => {
+  const value = {
+    ok:true,
+    goal_id:'1'.repeat(64),
+    receipt_sha256:'2'.repeat(64),
+    signature_valid:true,
+    mutation_epoch:1,
+    mutation_count:1,
+    planner_round:2,
+    required_profiles_verified:4,
+    native_diffs_verified:1,
+    delegated_actions_verified:1,
+    journal_head_sha256:'3'.repeat(64)
+  };
+  const result = autonomousStructuredResult(autonomousGoalVerifyOutputSchema,value);
+  assert.equal(result.structuredContent.delegated_actions_verified,1);
+});

package/test/autonomous-runtime.test.mjs

@@ -0,0 +1,93 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { generateTrustKeypair } from '../src/trust.mjs';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(here, '..');
+const serverPath = path.join(repoRoot, 'src', 'mcp-server.mjs');
+const workspaceRoot = path.join(repoRoot, 'workspaces');
+const r24Tools = [
+  'autonomous_goal_approve', 'autonomous_goal_cancel', 'autonomous_goal_events',
+  'autonomous_goal_run', 'autonomous_goal_status', 'autonomous_goal_submit',
+  'autonomous_goal_verify', 'autonomous_release_gate', 'autonomous_session_status',
+  'native_diff_apply', 'native_diff_preview', 'native_diff_verify'
+];
+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_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'
+];
+const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
+async function sha256File(file) { return sha256(await readFile(file)); }
+
+async function fixture() {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r24-catalog-'));
+  const project = path.join(root, 'project');
+  const trust = path.join(root, 'trust');
+  await mkdir(project); await mkdir(trust);
+  const keys = await generateTrustKeypair({
+    privateKeyPath: path.join(trust, 'private.pem'),
+    publicKeyPath: path.join(trust, 'public.pem')
+  });
+  const codingPolicyPath = path.join(root, 'coding-policy.json');
+  const codingPolicy = {
+    schema:'deadbyte.coding-policy.v1', enabled:true,
+    lease_file:path.join(root,'coding-lease.json'), evidence_dir:path.join(root,'coding-evidence'),
+    roots:{ project:{ path:project, read:true, write:true, exec:true, deny_paths:['.git','node_modules'] } },
+    commands:{ node_script:{ kind:'script', executable:process.execPath,
+      executable_sha256:await sha256File(process.execPath), root_ids:['project'], prefix_args:[],
+      extensions:['.mjs','.js'], timeout_ms:120000, max_output_bytes:1048576 } }
+  };
+  await writeFile(codingPolicyPath, JSON.stringify(codingPolicy, null, 2));
+  const autonomousPolicyPath = path.join(root, 'autonomous-policy.json');
+  await writeFile(autonomousPolicyPath, JSON.stringify({
+    schema:'deadbyte.autonomous-policy.v1', enabled:true,
+    lease_file:path.join(root,'autonomous-lease.json'),
+    evidence_dir:path.join(root,'autonomous-evidence'),
+    root_ids:['project'],
+    coding_policy_sha256:sha256(await readFile(codingPolicyPath)),
+    planner:{ backend:'client_sampling', max_tokens:4096 },
+    limits:{ max_iterations:12, max_mutations:24, max_wall_ms:1800000,
+      max_context_bytes:1048576, max_diff_bytes:1048576 },
+    profiles:{}
+  }, null, 2));
+  const client = new Client({ name:'deadbyte-r24-catalog-test', version:'0.8.0' },
+    { versionNegotiation:{ mode:{ pin:'2026-07-28' } } });
+  const transport = new StdioClientTransport({
+    command:process.execPath, args:[serverPath], cwd:repoRoot,
+    env:{ ...getDefaultEnvironment(), DEADBYTE_WORKSPACE_ROOT:workspaceRoot,
+      DEADBYTE_SIGNING_KEY:keys.privateKeyPath, DEADBYTE_VERIFY_KEY:keys.publicKeyPath,
+      DEADBYTE_AGENT_RUNTIME:'1', DEADBYTE_CODING_RUNTIME:'1',
+      DEADBYTE_CODING_POLICY:codingPolicyPath, DEADBYTE_AUTONOMOUS_RUNTIME:'1',
+      DEADBYTE_AUTONOMOUS_POLICY:autonomousPolicyPath }, stderr:'pipe'
+  });
+  return { root, client, transport };
+}
+
+test('R30 hermetic autonomous fixture exposes the exact 41-tool no-host catalog', async () => {
+  const f = await fixture();
+  try {
+    await f.client.connect(f.transport);
+    const listed = await f.client.listTools();
+    const names = listed.tools.map(tool => tool.name).sort();
+    assert.deepEqual(names, [...r23Tools, ...r24Tools].sort());
+    for (const tool of listed.tools.filter(item => r24Tools.includes(item.name))) {
+      assert.equal(tool.outputSchema?.type, 'object', `${tool.name} output schema missing`);
+      assert.equal(tool.outputSchema?.additionalProperties, false, `${tool.name} output schema must be strict`);
+    }
+  } finally {
+    await f.client.close().catch(() => {});
+    await rm(f.root, { recursive:true, force:true }).catch(() => {});
+  }
+});