deadbyte-mcp 0.8.9 → 0.9.0

package/test/autonomous-local-supervisor.test.mjs

@@ -0,0 +1,403 @@
+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 { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+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 {
+  observeCurrentProcessIdentity, observeSupervisor, takeoverSupervisor,
+  claimSupervisor, releaseSupervisor, validateSupervisorRecoveryRequest,
+  startLocalSupervisorHost, recoverManagedRuntime, runPinnedControllerOperation
+} from '../src/autonomous-local-supervisor.mjs';
+import { localSupervisorFixture } from './helpers/autonomous-r34-fixture.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const hostPath=path.join(repoRoot,'src','autonomous-supervisor-host.mjs');
+const nonce=()=>randomBytes(32).toString('hex');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function createProviderHostFixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-host-process-'));
+  const project=path.join(root,'project'); const trust=path.join(root,'trust');
+  await mkdir(project); await mkdir(trust); await writeFile(path.join(project,'source.txt'),'READY\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-grant.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-grant.v2',policy_sha256:codingPolicy.policy_sha256,
+    instance_nonce:nonce(),root_ids:['project'],granted_at_utc:new Date().toISOString()}));
+  let round=0;
+  const planner=createServer(async(req,res)=>{ let body=''; for await(const chunk of req) body+=chunk; JSON.parse(body); round+=1;
+    const decision=round===1
+      ? {schema:'deadbyte.autonomous-decision.v1',action:'inspect',summary:'inspect source',reads:[{path:'source.txt',max_bytes:4096}]}
+      : {schema:'deadbyte.autonomous-decision.v1',action:'finish',summary:'verified source observed'};
+    res.writeHead(200,{'content-type':'application/json'}); res.end(JSON.stringify({model:'r34-host-test',choices:[{message:{content:JSON.stringify(decision)}}]}));
+  });
+  await new Promise(resolve=>planner.listen(0,'127.0.0.1',resolve));
+  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'),
+    coding_policy_sha256:codingPolicy.policy_sha256,root_ids:['project'],
+    planner:{backend:'openai_compatible',endpoint:`http://127.0.0.1:${planner.address().port}/v1/chat/completions`,model:'r34-host-test',max_tokens:2048,timeout_ms:30000,max_response_bytes:262144},
+    limits:{max_iterations:8,max_mutations:8,max_wall_ms:null,max_context_bytes:262144,max_diff_bytes:262144,max_files_per_diff:4},profiles:{}}));
+  const autonomousPolicy=await loadAutonomousPolicy(autonomousPath,codingPolicy);
+  await writeFile(autonomousPolicy.lease_file,JSON.stringify({schema:'deadbyte.autonomous-grant.v2',policy_sha256:autonomousPolicy.policy_sha256,
+    instance_nonce:nonce(),root_ids:['project'],granted_at_utc:new Date().toISOString()}));
+  const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const nativeDiffRuntime=createNativeDiffRuntime({policy:autonomousPolicy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const runtime=createAutonomousRuntime({policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+  const markerPath=path.join(root,'supervisor-owner.json');
+  return {root,keys,codingPath,autonomousPath,runtime,markerPath,planner,rounds:()=>round,
+    cleanup:async()=>{await new Promise(resolve=>planner.close(resolve)); await rm(root,{recursive:true,force:true});}};
+}
+
+test('current Windows process identity binds pid creation time image path and image hash', async () => {
+  const identity=await observeCurrentProcessIdentity();
+  assert.ok(identity);
+  assert.equal(identity.pid,process.pid);
+  assert.match(identity.creation_time_utc,/Z$/);
+  assert.equal(typeof identity.image_path,'string');
+  assert.ok(identity.image_path.length>3);
+  assert.match(identity.image_sha256,/^[0-9a-f]{64}$/);
+});
+
+test('local supervisor refuses takeover of live verified owner', async () => {
+  const identity=await observeCurrentProcessIdentity();
+  const f=await localSupervisorFixture({ownerPid:process.pid,ownerIdentity:identity});
+  try {
+    const observed=await observeSupervisor(f.options);
+    assert.equal(observed.reason,'live_verified_owner');
+    await assert.rejects(takeoverSupervisor(f.options),/live verified owner/i);
+  } finally { await f.cleanup(); }
+});
+
+test('stale PID reuse does not inherit ownership', async () => {
+  const identity=await observeCurrentProcessIdentity();
+  const f=await localSupervisorFixture({ownerPid:process.pid,
+    ownerIdentity:{...identity,creation_time_utc:'2000-01-01T00:00:00.000Z'}});
+  try {
+    const state=await observeSupervisor(f.options);
+    assert.equal(state.live,false);
+    assert.equal(state.reason,'pid_reused');
+    const claimed=await takeoverSupervisor(f.options);
+    assert.equal(claimed.status,'claimed');
+    const marker=JSON.parse(await readFile(f.markerPath,'utf8'));
+    assert.equal(marker.pid,process.pid);
+    assert.notEqual(marker.creation_time_utc,'2000-01-01T00:00:00.000Z');
+    assert.match(marker.instance_nonce,/^[0-9a-f]{64}$/);
+  } finally { await f.cleanup(); }
+});
+
+test('exclusive claim and verified release cannot delete another live owner marker', async () => {
+  const f=await localSupervisorFixture({ownerPid:null,ownerIdentity:null});
+  try {
+    const claim=await claimSupervisor(f.options);
+    assert.equal(claim.status,'claimed');
+    const observed=await observeSupervisor(f.options);
+    assert.equal(observed.reason,'live_verified_owner');
+    await assert.rejects(releaseSupervisor({...f.options,instanceNonce:'f'.repeat(64)}),/ownership|nonce/i);
+    const released=await releaseSupervisor({...f.options,instanceNonce:claim.instance_nonce});
+    assert.equal(released.status,'released');
+    assert.equal((await observeSupervisor(f.options)).reason,'no_owner');
+  } finally { await f.cleanup(); }
+});
+
+test('recovery request allowlist permits status resume park and disarm only', () => {
+  for(const operation of ['status','resume','park','disarmautonomous','disarmcoding','disarmprocess','disarmhost']) {
+    assert.deepEqual(validateSupervisorRecoveryRequest({operation}),{operation});
+  }
+  for(const operation of ['armautonomous','armcoding','armprocess','armhost','restart','exec','powershell']) {
+    assert.throws(()=>validateSupervisorRecoveryRequest({operation}),/operation|allowlist/i);
+  }
+  assert.throws(()=>validateSupervisorRecoveryRequest({operation:'status',command:'whoami'}),/field|request/i);
+  assert.throws(()=>validateSupervisorRecoveryRequest({operation:'resume',executable:'cmd.exe'}),/field|request/i);
+  assert.throws(()=>validateSupervisorRecoveryRequest({operation:'park',env:{X:'1'}}),/field|request/i);
+});
+
+test('local supervisor host owns marker, advances durable provider goal, and releases ownership on stop', async () => {
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-local-host-'));
+  const evidence=path.join(root,'evidence');
+  const goalId='1'.repeat(64);
+  await mkdir(path.join(evidence,'goals',goalId),{recursive:true});
+  const markerPath=path.join(root,'owner.json');
+  let state='pending'; let runs=0;
+  const policy={evidence_dir:evidence,planner:{backend:'openai_compatible'}};
+  const runtime={policy,
+    async status({goalId:id}){ assert.equal(id,goalId); return {state}; },
+    async run({goalId:id}){ assert.equal(id,goalId); runs+=1; state='succeeded'; return {status:'completed'}; }
+  };
+  let host;
+  try {
+    host=await startLocalSupervisorHost({runtime,policy,markerPath,idleDelayMs:25,maxCycles:4,logger:{warn(){},error(){}}});
+    const deadline=Date.now()+3000;
+    while(runs<1&&Date.now()<deadline) await new Promise(resolve=>setTimeout(resolve,25));
+    assert.equal(runs,1);
+    assert.equal((await observeSupervisor({markerPath})).reason,'live_verified_owner');
+    await host.stop(); host=null;
+    assert.equal((await observeSupervisor({markerPath})).reason,'no_owner');
+  } finally {
+    if(host) await host.stop().catch(()=>{});
+    await rm(root,{recursive:true,force:true});
+  }
+});
+
+test('managed runtime recovery uses only resume, disarm planes, then exact ONLINE/DISARMED status proof', async () => {
+  const operations=[];
+  const finalText=[
+    'DEADBYTE MCP = ONLINE',
+    'Process plane  : DISARMED [disarmed]',
+    'Coding plane  : DISARMED [disarmed]',
+    'Autonomous     : DISARMED [disarmed]',
+    'Host plane    : DISARMED [disarmed]'
+  ].join('\n');
+  const result=await recoverManagedRuntime({runControllerOperation:async request=>{
+    const checked=validateSupervisorRecoveryRequest(request); operations.push(checked.operation);
+    return {exit_code:0,stdout:checked.operation==='status'?finalText:'OK',stderr:''};
+  }});
+  assert.deepEqual(operations,['resume','disarmautonomous','disarmcoding','disarmprocess','disarmhost','status']);
+  assert.equal(result.status,'recovered');
+  assert.equal(result.runtime_state,'ONLINE');
+  assert.deepEqual(result.authority,{process:'DISARMED',coding:'DISARMED',autonomous:'DISARMED',host:'DISARMED'});
+});
+
+test('managed runtime recovery fails closed when final status is not all disarmed', async () => {
+  const bad=[
+    'DEADBYTE MCP = ONLINE',
+    'Process plane  : DISARMED [disarmed]',
+    'Coding plane  : ARMED [standing-grant]',
+    'Autonomous     : DISARMED [disarmed]',
+    'Host plane    : DISARMED [disarmed]'
+  ].join('\n');
+  await assert.rejects(recoverManagedRuntime({runControllerOperation:async ({operation})=>({
+    exit_code:0,stdout:operation==='status'?bad:'OK',stderr:''
+  })}),/coding|disarmed|recovery/i);
+});
+
+test('pinned controller runner verifies script hash before fixed PowerShell invocation', async () => {
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-controller-runner-'));
+  const controllerPath=path.join(root,'controller.ps1');
+  const script="param([string]$Command)\nif($Command -eq 'status'){ Write-Output 'DEADBYTE MCP = ONLINE' } else { Write-Output ('OK '+$Command) }\n";
+  try {
+    await writeFile(controllerPath,script,'utf8');
+    const controllerSha256=createHash('sha256').update(await readFile(controllerPath)).digest('hex');
+    const result=await runPinnedControllerOperation({controllerPath,controllerSha256,operation:'status'});
+    assert.equal(result.exit_code,0);
+    assert.match(result.stdout,/DEADBYTE MCP = ONLINE/);
+    await assert.rejects(runPinnedControllerOperation({controllerPath,controllerSha256:'0'.repeat(64),operation:'status'}),/hash/i);
+    await assert.rejects(runPinnedControllerOperation({controllerPath,controllerSha256,operation:'armcoding'}),/allowlist|operation/i);
+    await assert.rejects(runPinnedControllerOperation({controllerPath,controllerSha256,operation:'status',executable:'cmd.exe'}),/field|options/i);
+    await assert.rejects(runPinnedControllerOperation({controllerPath,controllerSha256,operation:'status',env:{X:'1'}}),/field|options/i);
+  } finally { await rm(root,{recursive:true,force:true}); }
+});
+
+test('R34 bridge loss is recovered by local supervisor to ONLINE and all-DISARMED', async () => {
+  const f=await createProviderHostFixture();
+  const statePath=path.join(f.root,'managed-runtime.json');
+  const controllerPath=path.join(f.root,'recovery-controller.ps1');
+  const psLiteral=value=>`'${String(value).replaceAll("'","''")}'`;
+  const codingPolicyDoc=JSON.parse(await readFile(f.codingPath,'utf8'));
+  const autonomousPolicyDoc=JSON.parse(await readFile(f.autonomousPath,'utf8'));
+  await writeFile(statePath,JSON.stringify({runtime_state:'ONLINE',process:'ARMED',coding:'ARMED',autonomous:'ARMED',host:'ARMED'}));
+  const controllerScript=[
+    'param([string]$Command)',
+    "$ErrorActionPreference='Stop'",
+    `$StatePath=${psLiteral(statePath)}`,
+    `$CodingLease=${psLiteral(codingPolicyDoc.lease_file)}`,
+    `$AutonomousLease=${psLiteral(autonomousPolicyDoc.lease_file)}`,
+    '$s=Get-Content -LiteralPath $StatePath -Raw -Encoding UTF8 | ConvertFrom-Json',
+    "switch($Command){",
+    "  'park' { $s.runtime_state='PARKED' }",
+    "  'resume' { $s.runtime_state='ONLINE' }",
+    "  'disarmautonomous' { $s.autonomous='DISARMED'; Remove-Item -LiteralPath $AutonomousLease -Force -ErrorAction SilentlyContinue }",
+    "  'disarmcoding' { $s.coding='DISARMED'; Remove-Item -LiteralPath $CodingLease -Force -ErrorAction SilentlyContinue }",
+    "  'disarmprocess' { $s.process='DISARMED' }",
+    "  'disarmhost' { $s.host='DISARMED' }",
+    "  'status' {",
+    "    Write-Output ('DEADBYTE MCP = {0}' -f $s.runtime_state)",
+    "    Write-Output ('Process plane  : {0} [fixture]' -f $s.process)",
+    "    Write-Output ('Coding plane  : {0} [fixture]' -f $s.coding)",
+    "    Write-Output ('Autonomous     : {0} [fixture]' -f $s.autonomous)",
+    "    Write-Output ('Host plane    : {0} [fixture]' -f $s.host)",
+    '    exit 0',
+    '  }',
+    "  default { throw ('unsupported recovery operation: '+$Command) }",
+    '}',
+    '$s | ConvertTo-Json -Compress | Set-Content -LiteralPath $StatePath -Encoding UTF8',
+    "Write-Output ('OK '+$Command)"
+  ].join('\n')+'\n';
+  await writeFile(controllerPath,controllerScript,'utf8');
+  const controllerSha256=sha(await readFile(controllerPath));
+  const runControllerOperation=({operation})=>runPinnedControllerOperation({controllerPath,controllerSha256,operation});
+  let host;
+  try {
+    host=await startLocalSupervisorHost({runtime:f.runtime,policy:f.runtime.policy,markerPath:f.markerPath,
+      idleDelayMs:25,maxCycles:8,logger:{warn(){},error(){}},continuous:true});
+    const ownerBefore=await observeSupervisor({markerPath:f.markerPath});
+    assert.equal(ownerBefore.reason,'live_verified_owner');
+    assert.equal(host.running,true);
+
+    assert.equal((await runControllerOperation({operation:'park'})).exit_code,0);
+    const parked=await runControllerOperation({operation:'status'});
+    assert.equal(parked.exit_code,0);
+    assert.match(parked.stdout,/DEADBYTE MCP = PARKED/);
+    assert.equal(host.running,true,'local supervisor died when managed Bridge was parked');
+
+    const submitted=await f.runtime.submit({submissionId:'bridge-loss-oob',rootId:'project',title:'bridge loss proof',
+      goal:'Inspect source.txt and finish while the managed Bridge is parked.',acceptance:'source stays READY',maxIterations:8});
+    const deadline=Date.now()+5000;
+    let goalStatus=await f.runtime.status({goalId:submitted.goal_id});
+    while(goalStatus.state!=='succeeded'&&Date.now()<deadline){
+      await new Promise(resolve=>setTimeout(resolve,25));
+      goalStatus=await f.runtime.status({goalId:submitted.goal_id});
+    }
+    assert.equal(goalStatus.state,'succeeded','local supervisor did not reconstruct and finish durable goal while Bridge was parked');
+    assert.equal((await f.runtime.verify({goalId:submitted.goal_id})).ok,true);
+    assert.ok(f.rounds()>=2);
+
+    const recovered=await recoverManagedRuntime({runControllerOperation});
+    assert.equal(recovered.status,'recovered');
+    assert.equal(recovered.runtime_state,'ONLINE');
+    assert.deepEqual(recovered.authority,{process:'DISARMED',coding:'DISARMED',autonomous:'DISARMED',host:'DISARMED'});
+    assert.deepEqual(recovered.operations,['resume','disarmautonomous','disarmcoding','disarmprocess','disarmhost','status']);
+    assert.equal(host.running,true,'local supervisor process changed during controlled recovery');
+    const ownerAfter=await observeSupervisor({markerPath:f.markerPath});
+    assert.equal(ownerAfter.reason,'live_verified_owner');
+    assert.equal(ownerAfter.marker.pid,ownerBefore.marker.pid);
+    assert.equal(ownerAfter.marker.instance_nonce,ownerBefore.marker.instance_nonce);
+    await assert.rejects(readFile(codingPolicyDoc.lease_file,'utf8'),error=>error?.code==='ENOENT');
+    await assert.rejects(readFile(autonomousPolicyDoc.lease_file,'utf8'),error=>error?.code==='ENOENT');
+  } finally {
+    if(host) await host.stop().catch(()=>{});
+    await f.cleanup();
+  }
+});
+
+test('client-sampling local supervisor owns recovery without fabricating planner work', async () => {
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r34-client-sampling-host-'));
+  const evidence=path.join(root,'evidence');
+  const goalId='2'.repeat(64);
+  await mkdir(path.join(evidence,'goals',goalId),{recursive:true});
+  const markerPath=path.join(root,'owner.json');
+  let runs=0;
+  const policy={evidence_dir:evidence,planner:{backend:'client_sampling'}};
+  const runtime={policy,
+    async status(){ return {state:'pending'}; },
+    async run(){ runs+=1; return {status:'input_required'}; }
+  };
+  let host;
+  try {
+    host=await startLocalSupervisorHost({runtime,policy,markerPath,idleDelayMs:25,maxCycles:4,logger:{warn(){},error(){}},continuous:true});
+    assert.equal(host.running,true);
+    assert.equal((await observeSupervisor({markerPath})).reason,'live_verified_owner');
+    assert.equal(await host.scanNow(),0);
+    await new Promise(resolve=>setTimeout(resolve,100));
+    assert.equal(runs,0,'client-sampling supervisor must never fabricate or request planner work itself');
+    await host.stop(); host=null;
+    assert.equal((await observeSupervisor({markerPath})).reason,'no_owner');
+  } finally {
+    if(host) await host.stop().catch(()=>{});
+    await rm(root,{recursive:true,force:true});
+  }
+});
+
+test('standalone supervisor host starts in client-sampling recovery-only mode', async () => {
+  const f=await createProviderHostFixture();
+  let child;
+  try {
+    const submitted=await f.runtime.submit({submissionId:'client-sampling-oob',rootId:'project',title:'client sampling recovery host',
+      goal:'Remain durable until an authenticated MCP client supplies planner sampling.',acceptance:'no fabricated planner work',maxIterations:8});
+    const policyDoc=JSON.parse(await readFile(f.autonomousPath,'utf8'));
+    policyDoc.planner={backend:'client_sampling',max_tokens:2048};
+    await writeFile(f.autonomousPath,`${JSON.stringify(policyDoc)}\n`,'utf8');
+    child=spawn(process.execPath,[hostPath],{cwd:repoRoot,windowsHide:true,stdio:['ignore','pipe','pipe'],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_MARKER:f.markerPath,DEADBYTE_SUPERVISOR_ONCE:'1'}});
+    let stdout=''; let stderr=''; child.stdout.on('data',chunk=>stdout+=chunk); child.stderr.on('data',chunk=>stderr+=chunk);
+    const exitCode=await new Promise(resolve=>child.once('exit',code=>resolve(code)));
+    assert.equal(exitCode,0,stderr);
+    const readyLine=stdout.split(/\r?\n/).find(line=>line.includes('deadbyte.autonomous-supervisor-host.v1'));
+    assert.ok(readyLine,stdout);
+    assert.equal(JSON.parse(readyLine).status,'ready');
+    assert.notEqual((await f.runtime.status({goalId:submitted.goal_id})).state,'succeeded');
+    assert.equal(f.rounds(),0,'client-sampling host must not call provider planner');
+    assert.equal((await observeSupervisor({markerPath:f.markerPath})).reason,'no_owner');
+  } finally {
+    if(child && child.exitCode===null) child.kill();
+    await f.cleanup();
+  }
+});
+
+test('continuous standalone supervisor remains alive after READY and hard-stop ownership is takeover-safe', async () => {
+  const f=await createProviderHostFixture();
+  let child;
+  try {
+    const policyDoc=JSON.parse(await readFile(f.autonomousPath,'utf8'));
+    policyDoc.planner={backend:'client_sampling',max_tokens:2048};
+    await writeFile(f.autonomousPath,`${JSON.stringify(policyDoc)}\n`,'utf8');
+    child=spawn(process.execPath,[hostPath],{cwd:repoRoot,windowsHide:true,stdio:['ignore','pipe','pipe'],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_MARKER:f.markerPath,DEADBYTE_SUPERVISOR_ONCE:'0'}});
+    let stdout=''; let stderr=''; child.stdout.on('data',chunk=>stdout+=chunk); child.stderr.on('data',chunk=>stderr+=chunk);
+    const readyDeadline=Date.now()+5000;
+    while(!stdout.includes('deadbyte.autonomous-supervisor-host.v1')&&child.exitCode===null&&Date.now()<readyDeadline) {
+      await new Promise(resolve=>setTimeout(resolve,25));
+    }
+    assert.match(stdout,/deadbyte\.autonomous-supervisor-host\.v1/,stderr||stdout);
+    await new Promise(resolve=>setTimeout(resolve,400));
+    assert.equal(child.exitCode,null,`continuous supervisor exited after READY: ${stderr}`);
+    assert.equal((await observeSupervisor({markerPath:f.markerPath})).reason,'live_verified_owner');
+    child.kill('SIGTERM');
+    await new Promise(resolve=>child.once('exit',()=>resolve()));
+    const stale=await observeSupervisor({markerPath:f.markerPath});
+    assert.equal(stale.live,false);
+    assert.match(stale.reason,/process_unobservable|pid_reused|identity_mismatch/);
+    const claimed=await takeoverSupervisor({markerPath:f.markerPath});
+    assert.equal(claimed.status,'claimed');
+    await releaseSupervisor({markerPath:f.markerPath,instanceNonce:claimed.instance_nonce});
+    assert.equal((await observeSupervisor({markerPath:f.markerPath})).reason,'no_owner');
+  } finally {
+    if(child && child.exitCode===null) child.kill();
+    await f.cleanup();
+  }
+});
+
+test('standalone supervisor host advances durable provider goal without MCP bridge process', async () => {
+  const f=await createProviderHostFixture();
+  let child;
+  try {
+    const submitted=await f.runtime.submit({submissionId:'host-out-of-band',rootId:'project',title:'host proof',
+      goal:'Inspect source.txt and finish from the standalone supervisor host.',acceptance:'source stays READY',maxIterations:8});
+    child=spawn(process.execPath,[hostPath],{cwd:repoRoot,windowsHide:true,stdio:['ignore','pipe','pipe'],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_MARKER:f.markerPath,DEADBYTE_SUPERVISOR_ONCE:'1'}});
+    let stdout=''; let stderr=''; child.stdout.on('data',chunk=>stdout+=chunk); child.stderr.on('data',chunk=>stderr+=chunk);
+    const exitCode=await new Promise(resolve=>child.once('exit',code=>resolve(code)));
+    assert.equal(exitCode,0,stderr);
+    const readyLine=stdout.split(/\r?\n/).find(line=>line.includes('deadbyte.autonomous-supervisor-host.v1'));
+    assert.ok(readyLine,stdout);
+    const ready=JSON.parse(readyLine);
+    assert.equal(ready.pid,child.pid);
+    assert.equal(ready.status,'ready');
+    const status=await f.runtime.status({goalId:submitted.goal_id});
+    assert.equal(status.state,'succeeded');
+    assert.ok(f.rounds()>=2);
+    assert.equal((await observeSupervisor({markerPath:f.markerPath})).reason,'no_owner');
+  } finally {
+    if(child && child.exitCode===null) child.kill();
+    await f.cleanup();
+  }
+});

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

@@ -0,0 +1,126 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createPlan, replanPlan } from '../src/autonomous-plan.mjs';
+import { deriveLoopState } from '../src/autonomous-loop-state.mjs';
+
+const H = c => c.repeat(64);
+const goal = { goal_id:H('1') };
+
+function initialPlan() {
+  return createPlan({
+    goalId:goal.goal_id,
+    title:'Repair',
+    reasonHash:H('2'),
+    steps:[
+      {step_id:'inspect',intent:'Inspect source'},
+      {step_id:'fix',intent:'Apply repair'}
+    ]
+  });
+}
+
+function eventsOf(items) {
+  return items.map(([type,payload],index) => ({
+    schema:'deadbyte.autonomous-event.v1',
+    seq:index + 1,
+    goal_id:goal.goal_id,
+    prev_sha256:index === 0 ? '0'.repeat(64) : String((index % 8) + 1).repeat(64),
+    event_sha256:String(((index + 1) % 8) + 1).repeat(64),
+    type,
+    payload
+  }));
+}
+
+test('restart replay derives byte-equivalent logical loop state', () => {
+  const plan = initialPlan();
+  const events = eventsOf([
+    ['goal_created',{}],
+    ['plan_created',{plan}],
+    ['phase_changed',{from:'PLANNING',to:'INSPECTING',reason:'plan_ready'}],
+    ['inspection_completed',{evidence_head_sha256:H('a')}],
+    ['phase_changed',{from:'INSPECTING',to:'ACTING',reason:'evidence_ready'}]
+  ]);
+  const first = deriveLoopState(goal,events);
+  const replay = deriveLoopState(goal,structuredClone(events));
+  assert.deepEqual(replay,first);
+  assert.equal(first.phase,'ACT');
+  assert.equal(first.plan_id,plan.plan_id);
+  assert.equal(first.plan_version,1);
+  assert.equal(first.current_step.step_id,'inspect');
+  assert.equal(first.journal_head_sha256,events.at(-1).event_sha256);
+});
+
+test('action started without completion remains pending after replay', () => {
+  const plan = initialPlan();
+  const state = deriveLoopState(goal,eventsOf([
+    ['goal_created',{}],
+    ['plan_created',{plan}],
+    ['phase_changed',{from:'PLANNING',to:'ACTING',reason:'action_ready'}],
+    ['action_started',{action_id:H('b'),request_sha256:H('c'),kind:'patch'}]
+  ]));
+  assert.equal(state.phase,'ACT');
+  assert.equal(state.pending_action.action_id,H('b'));
+  assert.equal(state.pending_action.request_sha256,H('c'));
+});
+
+test('verified action completion clears pending action and phase may advance to verifying', () => {
+  const plan = initialPlan();
+  const state = deriveLoopState(goal,eventsOf([
+    ['goal_created',{}],
+    ['plan_created',{plan}],
+    ['phase_changed',{from:'PLANNING',to:'ACTING',reason:'action_ready'}],
+    ['action_started',{action_id:H('b'),request_sha256:H('c'),kind:'patch'}],
+    ['action_completed',{action_id:H('b'),receipt_sha256:H('d'),verified:true}],
+    ['phase_changed',{from:'ACTING',to:'VERIFYING',reason:'action_verified'}]
+  ]));
+  assert.equal(state.pending_action,null);
+  assert.equal(state.phase,'VERIFY');
+});
+
+test('replan and waiting state are durable and expose approval reason', () => {
+  const first = initialPlan();
+  const second = replanPlan(first,{
+    reasonHash:H('e'),
+    steps:[
+      {step_id:'diagnose',intent:'Diagnose failure'},
+      {step_id:'fix2',intent:'Apply corrected repair'}
+    ]
+  });
+  const state = deriveLoopState(goal,eventsOf([
+    ['goal_created',{}],
+    ['plan_created',{plan:first}],
+    ['phase_changed',{from:'PLANNING',to:'REPLANNING',reason:'verification_failed'}],
+    ['plan_replanned',{plan:second}],
+    ['progress_judged',{verdict:'stalled',score:0,reason_codes:['equivalent_decision_no_new_evidence']}],
+    ['waiting_entered',{reason:'no_progress_after_replan',requires_approval:true}]
+  ]));
+  assert.equal(state.phase,'WAITING');
+  assert.equal(state.plan_version,2);
+  assert.equal(state.replan_count,1);
+  assert.equal(state.wait_reason,'no_progress_after_replan');
+  assert.equal(state.pending_approval,true);
+  assert.equal(state.progress.verdict,'stalled');
+});
+
+test('release completion is terminal and cannot regress to a mutable phase', () => {
+  const plan = initialPlan();
+  const completed = eventsOf([
+    ['goal_created',{}],
+    ['plan_created',{plan}],
+    ['release_completed',{receipt_sha256:H('f')}]
+  ]);
+  assert.equal(deriveLoopState(goal,completed).phase,'SUCCEEDED');
+  assert.throws(() => deriveLoopState(goal,[...completed,{
+    schema:'deadbyte.autonomous-event.v1',seq:4,goal_id:goal.goal_id,
+    prev_sha256:completed.at(-1).event_sha256,event_sha256:H('7'),type:'phase_changed',
+    payload:{from:'COMPLETE',to:'ACTING',reason:'illegal'}
+  }]),/complete|terminal/i);
+});
+
+test('phase transition from a stale source phase fails closed', () => {
+  const plan = initialPlan();
+  assert.throws(() => deriveLoopState(goal,eventsOf([
+    ['goal_created',{}],
+    ['plan_created',{plan}],
+    ['phase_changed',{from:'ACTING',to:'VERIFYING',reason:'stale'}]
+  ])),/phase.*mismatch/i);
+});

package/test/autonomous-loop-v2.test.mjs

@@ -0,0 +1,105 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createPlan, replanPlan } from '../src/autonomous-plan.mjs';
+import {
+  AUTONOMOUS_LOOP_PHASES,
+  deriveLoopState,
+  deriveTodoProjection,
+  repairFingerprint
+} from '../src/autonomous-loop-state.mjs';
+import { canonicalJson } from '../src/canonical-json.mjs';
+
+const H = c => c.repeat(64);
+const goal = { goal_id:H('1') };
+
+function planA() {
+  return createPlan({ goalId:goal.goal_id,title:'Repair',reasonHash:H('2'),steps:[
+    {step_id:'inspect',intent:'Inspect failing source'},
+    {step_id:'fix',intent:'Apply repair'}
+  ]});
+}
+
+function eventsOf(items) {
+  return items.map(([type,payload],index) => ({
+    schema:'deadbyte.autonomous-event.v1',seq:index+1,goal_id:goal.goal_id,
+    prev_sha256:index===0?'0'.repeat(64):String((index%8)+1).repeat(64),
+    event_sha256:String(((index+1)%8)+1).repeat(64),type,payload
+  }));
+}
+
+test('R35 loop exposes the exact production phase enum', () => {
+  assert.deepEqual([...AUTONOMOUS_LOOP_PHASES],[
+    'PLAN','INSPECT','ACT','VERIFY','CRITIC','REPAIR','RELEASE','WAITING','SUCCEEDED','FAILED'
+  ]);
+});
+
+test('failed VERIFY enters CRITIC and records bounded failure classification', () => {
+  const plan=planA();
+  const state=deriveLoopState(goal,eventsOf([
+    ['goal_created',{}],
+    ['plan_created',{plan}],
+    ['phase_changed',{from:'PLAN',to:'INSPECT',reason:'plan_ready'}],
+    ['phase_changed',{from:'INSPECT',to:'ACT',reason:'evidence_ready'}],
+    ['phase_changed',{from:'ACT',to:'VERIFY',reason:'action_observed'}],
+    ['progress_judged',{verdict:'regressed',score:-1,reason_codes:['acceptance_failures_increased'],fingerprint:H('a')}],
+    ['critic_classified',{failure_class:'verification_failure',evidence_fingerprint:H('a'),detail:'required profile regressed'}],
+    ['phase_changed',{from:'VERIFY',to:'CRITIC',reason:'verification_failed'}]
+  ]));
+  assert.equal(state.phase,'CRITIC');
+  assert.deepEqual(state.critic,{failure_class:'verification_failure',evidence_fingerprint:H('a'),detail:'required profile regressed'});
+});
+
+test('REPAIR must change plan/hypothesis fingerprint before another ACT', () => {
+  const first=planA();
+  const second=replanPlan(first,{reasonHash:H('3'),steps:[
+    {step_id:'diagnose',intent:'Inspect narrower cause'},
+    {step_id:'fix2',intent:'Apply corrected repair'}
+  ]});
+  const before=repairFingerprint({plan:first,hypothesis:'profile failure'});
+  const after=repairFingerprint({plan:second,hypothesis:'stale precondition caused wrong edit'});
+  assert.notEqual(before,after);
+  const state=deriveLoopState(goal,eventsOf([
+    ['goal_created',{}],
+    ['plan_created',{plan:first}],
+    ['phase_changed',{from:'PLAN',to:'VERIFY',reason:'probe'}],
+    ['critic_classified',{failure_class:'verification_failure',evidence_fingerprint:H('a'),detail:'failed'}],
+    ['phase_changed',{from:'VERIFY',to:'CRITIC',reason:'verification_failed'}],
+    ['phase_changed',{from:'CRITIC',to:'REPAIR',reason:'critic_ready'}],
+    ['repair_started',{previous_fingerprint:before,hypothesis:'profile failure'}],
+    ['plan_replanned',{plan:second}],
+    ['repair_completed',{previous_fingerprint:before,repair_fingerprint:after,hypothesis:'stale precondition caused wrong edit'}],
+    ['phase_changed',{from:'REPAIR',to:'ACT',reason:'repair_changed'}]
+  ]));
+  assert.equal(state.phase,'ACT');
+  assert.equal(state.repair.repair_fingerprint,after);
+  assert.notEqual(state.repair.previous_fingerprint,state.repair.repair_fingerprint);
+});
+
+test('unchanged repair fingerprint fails closed before ACT', () => {
+  const plan=planA();
+  const fp=repairFingerprint({plan,hypothesis:'same'});
+  assert.throws(()=>deriveLoopState(goal,eventsOf([
+    ['goal_created',{}],['plan_created',{plan}],
+    ['phase_changed',{from:'PLAN',to:'CRITIC',reason:'failed'}],
+    ['phase_changed',{from:'CRITIC',to:'REPAIR',reason:'critic_ready'}],
+    ['repair_started',{previous_fingerprint:fp,hypothesis:'same'}],
+    ['repair_completed',{previous_fingerprint:fp,repair_fingerprint:fp,hypothesis:'same'}],
+    ['phase_changed',{from:'REPAIR',to:'ACT',reason:'illegal_retry'}]
+  ])),/repair.*fingerprint.*change/i);
+});
+
+test('todo projection is restart-safe and byte-equivalent from journal replay', () => {
+  const plan=planA();
+  const events=eventsOf([
+    ['goal_created',{}],['plan_created',{plan}],
+    ['phase_changed',{from:'PLAN',to:'INSPECT',reason:'plan_ready'}]
+  ]);
+  const first=deriveTodoProjection(goal,events);
+  const replay=deriveTodoProjection(goal,structuredClone(events));
+  assert.equal(canonicalJson(first),canonicalJson(replay));
+  assert.equal(first.schema,'deadbyte.autonomous-todo-projection.v1');
+  assert.equal(first.plan_id,plan.plan_id);
+  assert.deepEqual(first.items.map(item=>[item.step_id,item.status]),[
+    ['inspect','active'],['fix','pending']
+  ]);
+});