deadbyte-mcp 0.8.10 → 0.10.0

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);
+});

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();
+  }
+});