deadbyte-mcp 0.15.74 → 0.15.75

package/test/r202-destination-journal.test.mjs

@@ -0,0 +1,92 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync,createHash,sign} from 'node:crypto';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {openRemoteDestinationJournalR202} from '../src/remote-destination-journal-r202.mjs';
+import {REMOTE_TERMINAL_DOMAIN,REMOTE_TERMINAL_EVIDENCE_SCHEMA} from '../src/remote-terminal-evidence-r200.mjs';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {createRemoteDevicePlaneR44} from '../src/remote-device-r44.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+async function fixture(t){
+ const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r202-journal-'));
+ t.after(()=>rm(base,{recursive:true,force:true}));
+ const keys=generateKeyPairSync('ed25519');
+ const spki=Buffer.from(keys.publicKey.export({type:'spki',format:'der'}));
+ const device={device_id:sha(spki),epoch:1,public_key_spki_base64:spki.toString('base64')};
+ const dir=path.join(base,'terminal-journal');
+ const journal=await openRemoteDestinationJournalR202({directory:dir,device});
+ const request={device_id:device.device_id,epoch:1,request_id:'9'.repeat(64),
+  request_sha256:'a'.repeat(64),capability_id:'machine.fs.write'};
+ const envelope=(terminal,overrides={})=>{
+  const evidence={schema:REMOTE_TERMINAL_EVIDENCE_SCHEMA,...request,terminal,...overrides};
+  const sig=sign(null,Buffer.concat([REMOTE_TERMINAL_DOMAIN,Buffer.from(canonicalJson(evidence),'utf8')]),keys.privateKey).toString('base64');
+  return {evidence,attestation:{algorithm:'ed25519',key_id:device.device_id,signature_base64:sig}};
+ };
+ return {base,dir,journal,device,keys,request,envelope};
+}
+const terminal=(hex='b')=>({status:'completed',result_sha256:hex.repeat(64)});
+test('R202 stores only paired signed evidence; lookup survives restart and is idempotent',async t=>{
+ const f=await fixture(t),proof=f.envelope(terminal());
+ const r=await f.journal.commitSignedTerminal({request:f.request,envelope:proof});
+ assert.equal(r.status,'stored');assert.match(r.terminal_evidence_sha256,/^[a-f0-9]{64}$/);
+ const r2=await f.journal.commitSignedTerminal({request:f.request,envelope:proof});
+ assert.equal(r2.status,'existing');
+ const restarted=await openRemoteDestinationJournalR202({directory:f.dir,device:f.device});
+ assert.deepEqual(await restarted.lookupTerminal(f.request),proof);
+});
+test('R202 a second signed but conflicting terminal cannot overwrite committed evidence',async t=>{
+ const f=await fixture(t),one=f.envelope(terminal('b')),two=f.envelope(terminal('c'));
+ await f.journal.commitSignedTerminal({request:f.request,envelope:one});
+ await assert.rejects(f.journal.commitSignedTerminal({request:f.request,envelope:two}),/conflicting signed terminal/);
+ assert.deepEqual(await f.journal.lookupTerminal(f.request),one);
+});
+test('R202 unsigned, wrong request, epoch and corrupted stored evidence fail closed',async t=>{
+ const f=await fixture(t),proof=f.envelope(terminal());
+ const altered=structuredClone(proof);altered.evidence.terminal.result_sha256='d'.repeat(64);
+ await assert.rejects(f.journal.commitSignedTerminal({request:f.request,envelope:altered}),/signature invalid/);
+ await assert.rejects(f.journal.commitSignedTerminal({request:{...f.request,epoch:2},envelope:proof}),/request identity invalid/);
+ await f.journal.commitSignedTerminal({request:f.request,envelope:proof});
+ const file=path.join(f.dir,f.request.request_id+'.json');
+ await writeFile(file,JSON.stringify(altered)+'\n');
+ await assert.rejects(f.journal.lookupTerminal(f.request),/signature invalid/);
+});
+test('R202 missing or partially written journal remains UNKNOWN and denies bad selectors',async t=>{
+ const f=await fixture(t);
+ assert.equal(await f.journal.lookupTerminal(f.request),null);
+ await assert.rejects(f.journal.lookupTerminal({...f.request,request_id:'../evil'}),/request identity invalid/);
+ await assert.rejects(f.journal.lookupTerminal({...f.request,request_sha256:'f'.repeat(64),device_id:'b'.repeat(64)}),/lookup request identity invalid/);
+ const file=path.join(f.dir,f.request.request_id+'.json');
+ await writeFile(file,'');
+ await assert.rejects(f.journal.lookupTerminal(f.request),/record is not a bounded regular file/);
+});
+test('R202 local relay adapter recovers lost ACK with exactly one remote dispatch',async t=>{
+ const f=await fixture(t);
+ let calls=0;
+ const relay={
+  async probe(x){return {device_id:x.device_id,epoch:x.epoch,nonce:x.nonce,ready:true};},
+  async request(){calls++;return null;},
+  lookupTerminal:args=>f.journal.lookupTerminal(args)
+ };
+ const stateDir=path.join(f.base,'sender');
+ const plane=await createRemoteDevicePlaneR44({stateDir,relay,authorizeCapability:async()=>true,
+  relayTimeoutMs:1000,probeRetries:0,reachableTtlMs:10000});
+ await plane.pair({publicKeySpkiBase64:f.device.public_key_spki_base64,displayName:'R202 simulated destination'});
+ await plane.reportOnline({deviceId:f.device.device_id,epoch:1,connectionId:'R202 local transport'});
+ await plane.probe({deviceId:f.device.device_id,epoch:1});
+ const args={deviceId:f.device.device_id,epoch:1,capabilityId:f.request.capability_id,
+  payload:{path:'readme.txt',content:'one'},requestId:f.request.request_id};
+ const first=await plane.dispatch(args);
+ assert.equal(first.effect_state,'unknown');
+ assert.equal(calls,1);
+ const proof=f.envelope(terminal(),{request_sha256:first.request_sha256});
+ await f.journal.commitSignedTerminal({request:{...f.request,request_sha256:first.request_sha256},envelope:proof});
+ const next=await plane.reconcile({requestId:args.requestId});
+ assert.equal(next.effect_state,'confirmed');assert.equal(next.state,'completed');
+ assert.equal(next.reconciliation_state,'signed_terminal');
+ assert.equal(calls,1,'lookup retried the mutation');
+ const replay=await plane.dispatch(args);
+ assert.equal(replay.replay,true);assert.equal(calls,1);
+});

package/test/r203-atomic-journal.test.mjs

@@ -0,0 +1,86 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync,createHash,sign} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,readdir,rm,writeFile,stat} from 'node:fs/promises';
+import {spawn} from 'node:child_process';
+import path from 'node:path';
+import os from 'node:os';
+import {fileURLToPath} from 'node:url';
+import {openRemoteDestinationJournalR202} from '../src/remote-destination-journal-r202.mjs';
+import {REMOTE_TERMINAL_DOMAIN,REMOTE_TERMINAL_EVIDENCE_SCHEMA} from '../src/remote-terminal-evidence-r200.mjs';
+import {canonicalJson} from '../src/canonical-json.mjs';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const worker=fileURLToPath(new URL('./fixtures/r203-journal-writer.mjs',import.meta.url));
+async function fixture(t){
+ const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r203-journal-'));
+ t.after(()=>rm(dir,{recursive:true,force:true}));
+ const key=generateKeyPairSync('ed25519'),spki=Buffer.from(key.publicKey.export({format:'der',type:'spki'}));
+ const device={device_id:sha(spki),epoch:1,public_key_spki_base64:spki.toString('base64')};
+ const journalDir=path.join(dir,'journal');
+ const journal=await openRemoteDestinationJournalR202({directory:journalDir,device});
+ const request={device_id:device.device_id,epoch:1,request_id:'a'.repeat(64),request_sha256:'b'.repeat(64),capability_id:'machine.fs.write'};
+ const signEvidence=terminal=>{
+  const evidence={schema:REMOTE_TERMINAL_EVIDENCE_SCHEMA,...request,terminal};
+  const signature_base64=sign(null,Buffer.concat([REMOTE_TERMINAL_DOMAIN,Buffer.from(canonicalJson(evidence))]),key.privateKey).toString('base64');
+  return {evidence,attestation:{algorithm:'ed25519',key_id:device.device_id,signature_base64}};
+ };
+ return {dir,journalDir,journal,device,request,signEvidence};
+}
+const completed={status:'completed',result_sha256:'c'.repeat(64)};
+test('R203 orphan unpublished temp never poisons absent destination terminal',async t=>{
+ const f=await fixture(t);
+ const garbage=path.join(f.journalDir,'.'+f.request.request_id+'.1234567890abcdef12345678.tmp');
+ await writeFile(garbage,'{broken');
+ assert.equal(await f.journal.lookupTerminal(f.request),null);
+ const record=f.signEvidence(completed);
+ assert.equal((await f.journal.commitSignedTerminal({request:f.request,envelope:record})).status,'stored');
+ assert.deepEqual(await f.journal.lookupTerminal(f.request),record);
+ assert.equal((await readFile(garbage,'utf8')),'{broken','the orphan is left to explicit cleanup, not silently deleted');
+});
+test('R203 8 independent Windows processes race for the same terminal; exactly one publication',async t=>{
+ const f=await fixture(t),envelope=f.signEvidence(completed);
+ const fixturePath=path.join(f.dir,'case.json');
+ await writeFile(fixturePath,JSON.stringify({directory:f.journalDir,device:f.device,request:f.request,envelope}));
+ const spawnWorker=()=>new Promise((resolve,reject)=>{
+  const child=spawn(process.execPath,[worker,fixturePath],{shell:false,windowsHide:true,stdio:['ignore','pipe','pipe']});
+  let stdout='',stderr='';
+  child.stdout.setEncoding('utf8');child.stderr.setEncoding('utf8');
+  child.stdout.on('data',s=>stdout+=s);child.stderr.on('data',s=>stderr+=s);
+  child.once('error',reject);child.once('close',code=>code===0?resolve(JSON.parse(stdout.trim())):reject(Error('worker exit '+code+' '+stderr)));
+ });
+ const results=await Promise.all(Array.from({length:8},spawnWorker));
+ assert.equal(results.filter(r=>r.status==='stored').length,1);
+ assert.equal(results.filter(r=>r.status==='existing').length,7);
+ assert.deepEqual(await f.journal.lookupTerminal(f.request),envelope);
+ const children=(await readdir(f.journalDir)).filter(x=>x.endsWith('.tmp'));
+ assert.deepEqual(children,[],'all successful writers removed private temp files');
+});
+test('R203 competing distinct signed terminal results cannot overwrite a winner',async t=>{
+ const f=await fixture(t);
+ const first=f.signEvidence(completed);
+ const second=f.signEvidence({status:'completed',result_sha256:'d'.repeat(64)});
+ const results=await Promise.allSettled([f.journal.commitSignedTerminal({request:f.request,envelope:first}),
+  f.journal.commitSignedTerminal({request:f.request,envelope:second})]);
+ assert.equal(results.filter(r=>r.status==='fulfilled').length,1);
+ assert.equal(results.filter(r=>r.status==='rejected'&&/conflicting signed terminal/.test(r.reason?.message)).length,1);
+ const actual=await f.journal.lookupTerminal(f.request);
+ assert.ok([first,second].some(p=>p.evidence.terminal.result_sha256===actual.evidence.terminal.result_sha256));
+});
+test('R203 preexisting directory or oversized forged final record is never overwritten',async t=>{
+ const f=await fixture(t),file=path.join(f.journalDir,f.request.request_id+'.json');
+ await mkdir(file);
+ await assert.rejects(f.journal.commitSignedTerminal({request:f.request,envelope:f.signEvidence(completed)}),/bounded regular file/);
+ await rm(file,{recursive:true});
+ await writeFile(file,' '.repeat(17000));
+ await assert.rejects(f.journal.lookupTerminal(f.request),/bounded regular file/);
+});
+test('R203 signed record read uses bounded handle and detects invalid mutable payload',async t=>{
+ const f=await fixture(t),envelope=f.signEvidence(completed);
+ await f.journal.commitSignedTerminal({request:f.request,envelope});
+ const file=path.join(f.journalDir,f.request.request_id+'.json');
+ const initial=await stat(file);
+ assert.ok(initial.size>64);
+ const bad={...envelope,evidence:{...envelope.evidence,terminal:{...completed,result_sha256:'d'.repeat(64)}}};
+ await writeFile(file,JSON.stringify(bad));
+ await assert.rejects(f.journal.lookupTerminal(f.request),/signature invalid/);
+});

package/test/r205-candidate-selection-cli.test.mjs

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const cli=fileURLToPath(new URL('../scripts/r205-candidate-selection.mjs',import.meta.url));
+const H=c=>c.repeat(64);
+const fixture=H('a'),env=H('b');
+function input(status='PASS'){
+ const artifact=H('4');
+ const correct=(h,s)=>({status:s,artifact_sha256:h,fixture_sha256:fixture,receipt_sha256:H('2')});
+ const benchmark=(h,samples)=>({artifact_sha256:h,fixture_sha256:fixture,environment_sha256:env,receipt_sha256:H('3'),samples_ms:samples});
+ return {schema:'deadbyte.candidate-selection.r205.v1',fixture_sha256:fixture,environment_sha256:env,
+  baseline:{artifact_sha256:H('1'),correctness:correct(H('1'),'PASS'),benchmark:benchmark(H('1'),Array(7).fill(100))},
+  candidates:[{candidate_id:'candidate',artifact_sha256:artifact,correctness:correct(artifact,status),...(status==='PASS'?{benchmark:benchmark(artifact,Array(7).fill(75))}:{})}]};
+}
+const run=stdin=>spawnSync(process.execPath,[cli],{input:stdin,encoding:'utf8',windowsHide:true,timeout:10000,stdio:['pipe','pipe','pipe']});
+test('R205 CLI returns provisional evidence only, no release authorization',()=>{
+ const r=run(JSON.stringify(input()));assert.equal(r.status,0,r.stderr);
+ const j=JSON.parse(r.stdout);assert.equal(j.state,'PROVISIONAL_CANDIDATE');assert.equal(j.release_authorized,false);assert.equal(j.evidence_verified,false);
+});
+test('R205 CLI exits 2 for ungraded result without turning uncertainty into failure score',()=>{
+ const r=run(JSON.stringify(input('UNKNOWN')));assert.equal(r.status,2,r.stderr);
+ const j=JSON.parse(r.stdout);assert.equal(j.candidates[0].verdict,'UNGRADED');assert.equal(j.state,'NO_QUALIFIED_CANDIDATE');
+});
+test('R205 CLI refuses malformed JSON with exit 3',()=>{
+ const r=run('{invalid');assert.equal(r.status,3);assert.match(r.stderr,/R205_SELECTION_REFUSED/);
+});
+test('R205 CLI refuses oversized stdin before evaluation',()=>{
+ const r=run('x'.repeat(65537));assert.equal(r.status,3);assert.match(r.stderr,/R205_INPUT_LIMIT_EXCEEDED/);
+});

package/test/r205-candidate-selection.test.mjs

@@ -0,0 +1,83 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {CANDIDATE_SELECTION_SCHEMA,buildBlindCandidateViewR205,evaluateCandidateSelectionR205} from '../src/candidate-selection-r205.mjs';
+const H=c=>c.repeat(64);
+const fixture=H('a'),environment=H('b');
+const evidence=(status,artifact,tag)=>({status,artifact_sha256:artifact,fixture_sha256:fixture,receipt_sha256:H(tag)});
+const bench=(artifact,times,tag,env=environment)=>({artifact_sha256:artifact,fixture_sha256:fixture,environment_sha256:env,receipt_sha256:H(tag),samples_ms:times});
+const candidate=(id,artifact,status,times,tag='5')=>({candidate_id:id,artifact_sha256:artifact,correctness:evidence(status,artifact,tag),...(times?{benchmark:bench(artifact,times,'6')}:{})});
+const input=()=>({schema:CANDIDATE_SELECTION_SCHEMA,fixture_sha256:fixture,environment_sha256:environment,
+ baseline:{artifact_sha256:H('1'),correctness:evidence('PASS',H('1'),'2'),benchmark:bench(H('1'),[100,100,100,100,100,100,100],'3')},
+ candidates:[candidate('fast',H('4'),'PASS',[80,81,79,80,81,79,80]) ]});
+test('R205 fast and correct candidate is provisional, never a release authorization',()=>{
+ const r=evaluateCandidateSelectionR205(input());
+ assert.equal(r.state,'PROVISIONAL_CANDIDATE');assert.equal(r.winner_candidate_id,'fast');
+ assert.equal(r.evidence_verified,false);assert.equal(r.release_authorized,false);assert.match(r.report_sha256,/^[0-9a-f]{64}$/);
+});
+test('R205 faster incorrect candidate is rejected even if its benchmark looks good',()=>{
+ const i=input();i.candidates.push(candidate('bad',H('7'),'FAIL',[1,1,1,1,1,1,1]));
+ const r=evaluateCandidateSelectionR205(i);
+ assert.equal(r.candidates.find(x=>x.candidate_id==='bad').verdict,'REJECT_CORRECTNESS');
+ assert.equal(r.winner_candidate_id,'fast');
+});
+test('R205 unknown grader verdict stays UNGRADED not score zero',()=>{
+ const i=input();i.candidates=[candidate('unknown',H('7'),'UNKNOWN',null)];
+ const r=evaluateCandidateSelectionR205(i);
+ assert.equal(r.state,'NO_QUALIFIED_CANDIDATE');assert.equal(r.candidates[0].verdict,'UNGRADED');
+});
+test('R205 invalid and untested grader status stay UNGRADED',()=>{
+ for(const state of ['INVALID','UNTESTED']){
+  const i=input();i.candidates=[candidate(state,H('7'),state,null)];
+  assert.equal(evaluateCandidateSelectionR205(i).candidates[0].verdict,'UNGRADED');
+ }
+});
+test('R205 unstable or noisy benchmark cannot win',()=>{
+ const i=input();i.candidates=[candidate('noisy',H('7'),'PASS',[75,75,75,75,150,150,150])];
+ assert.equal(evaluateCandidateSelectionR205(i).state,'NO_QUALIFIED_CANDIDATE');
+});
+test('R205 no meaningful speedup cannot win',()=>{
+ const i=input();i.candidates=[candidate('tiny',H('7'),'PASS',[98,98,98,98,98,98,98])];
+ assert.equal(evaluateCandidateSelectionR205(i).state,'NO_QUALIFIED_CANDIDATE');
+});
+test('R205 close candidates produce AMBIGUOUS, never arbitrary promotion',()=>{
+ const i=input();i.candidates.push(candidate('near',H('7'),'PASS',[81,81,81,81,81,81,81]));
+ const r=evaluateCandidateSelectionR205(i);
+ assert.equal(r.state,'AMBIGUOUS');assert.equal(r.winner_candidate_id,null);
+});
+test('R205 candidate ordering and names do not alter blind evaluation hash',()=>{
+ const i=input();i.candidates.push(candidate('other',H('7'),'FAIL',null));
+ const hash1=evaluateCandidateSelectionR205(i).blind_evaluation_sha256;
+ i.candidates.reverse();i.candidates[0].candidate_id='new_other';i.candidates[1].candidate_id='new_fast';
+ assert.equal(evaluateCandidateSelectionR205(i).blind_evaluation_sha256,hash1);
+ assert.equal(JSON.stringify(buildBlindCandidateViewR205(i)).includes('new_fast'),false);
+});
+test('R205 disallows proposer identity and hidden metadata from evaluation',()=>{
+ const i=input();i.candidates[0].proposer='model-b';
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/unexpected field proposer/);
+});
+test('R205 refuses forged correctness artifact identity',()=>{
+ const i=input();i.candidates[0].correctness.artifact_sha256=H('f');
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/identity mismatch/);
+});
+test('R205 refuses benchmark environment drift',()=>{
+ const i=input();i.candidates[0].benchmark.environment_sha256=H('f');
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/identity mismatch/);
+});
+test('R205 refuses duplicate candidate artifact or baseline artifact',()=>{
+ const i=input();i.candidates.push(candidate('copy',H('4'),'PASS',[90,90,90,90,90,90,90]));
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/duplicated/);
+ i.candidates=[candidate('base',H('1'),'PASS',[70,70,70,70,70,70,70])];
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/duplicated/);
+});
+test('R205 refuses missing/insufficient samples rather than accepting ungraded benchmark',()=>{
+ const i=input();i.candidates[0].benchmark.samples_ms=[80,80];
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/samples invalid/);
+ i.candidates=[candidate('no',H('5'),'PASS',null)];
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/benchmark missing/);
+});
+test('R205 refuses mismatched paired sample counts and malformed values',()=>{
+ const i=input();i.candidates[0].benchmark.samples_ms=[80,80,80,80,80,80,80,80];
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/length mismatch/);
+ i.candidates[0].benchmark.samples_ms=[80,80,80,80,80,80,NaN];
+ assert.throws(()=>evaluateCandidateSelectionR205(i),/samples invalid/);
+});

package/test/r206-candidate-evidence.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import { verifyCandidateSelectionEvidenceR206 } from '../src/candidate-selection-evidence-r206.mjs';
+
+const H=c=>c.repeat(64);
+const fixture=H('a'),environment=H('b');
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+const samples={baseline:[100,100,100,100,100,100,100],candidate:[75,75,75,75,75,75,75]};
+const input=()=>({
+  schema:'deadbyte.candidate-selection.r205.v1',fixture_sha256:fixture,environment_sha256:environment,
+  baseline:{artifact_sha256:H('1'),correctness:{status:'PASS',artifact_sha256:H('1'),fixture_sha256:fixture,receipt_sha256:H('2')},
+    benchmark:{artifact_sha256:H('1'),fixture_sha256:fixture,environment_sha256:environment,receipt_sha256:H('3'),samples_ms:samples.baseline}},
+  candidates:[{candidate_id:'candidate',artifact_sha256:H('4'),
+    correctness:{status:'PASS',artifact_sha256:H('4'),fixture_sha256:fixture,receipt_sha256:H('5')},
+    benchmark:{artifact_sha256:H('4'),fixture_sha256:fixture,environment_sha256:environment,receipt_sha256:H('6'),samples_ms:samples.candidate}}]
+});
+const receipts=()=>new Map([
+  [H('2'),{verified:true,receipt_sha256:H('2'),evidence_kind:'correctness',signer_role:'independent_correctness_oracle',artifact_sha256:H('1'),fixture_sha256:fixture,status:'PASS'}],
+  [H('3'),{verified:true,receipt_sha256:H('3'),evidence_kind:'benchmark',signer_role:'independent_benchmark_runner',artifact_sha256:H('1'),fixture_sha256:fixture,environment_sha256:environment,samples_sha256:sha(samples.baseline)}],
+  [H('5'),{verified:true,receipt_sha256:H('5'),evidence_kind:'correctness',signer_role:'independent_correctness_oracle',artifact_sha256:H('4'),fixture_sha256:fixture,status:'PASS'}],
+  [H('6'),{verified:true,receipt_sha256:H('6'),evidence_kind:'benchmark',signer_role:'independent_benchmark_runner',artifact_sha256:H('4'),fixture_sha256:fixture,environment_sha256:environment,samples_sha256:sha(samples.candidate)}]
+]);
+const verifier=map=>async receiptSha=>map.get(receiptSha)??{verified:false,receipt_sha256:receiptSha};
+
+test('R206 independently verifies every decision-bearing receipt but never authorizes release',async()=>{
+  const result=await verifyCandidateSelectionEvidenceR206(input(),{verifyReceipt:verifier(receipts())});
+  assert.equal(result.state,'PROVISIONAL_CANDIDATE');
+  assert.equal(result.evidence_verified,true);
+  assert.equal(result.verified_receipt_count,4);
+  assert.equal(result.release_authorized,false);
+  assert.match(result.evidence_binding_sha256,/^[0-9a-f]{64}$/);
+});
+
+test('R206 rejects a forged or unverifiable receipt',async()=>{
+  const map=receipts();map.set(H('5'),{...map.get(H('5')),verified:false});
+  await assert.rejects(()=>verifyCandidateSelectionEvidenceR206(input(),{verifyReceipt:verifier(map)}),/receipt verification failed/);
+});
+
+test('R206 rejects correctness status or artifact drift after grading',async()=>{
+  for(const change of [{status:'FAIL'},{artifact_sha256:H('7')}]){
+    const map=receipts();map.set(H('5'),{...map.get(H('5')),...change});
+    await assert.rejects(()=>verifyCandidateSelectionEvidenceR206(input(),{verifyReceipt:verifier(map)}),/correctness receipt binding mismatch/);
+  }
+});
+
+test('R206 rejects benchmark sample or environment drift',async()=>{
+  for(const change of [{samples_sha256:H('7')},{environment_sha256:H('7')}]){
+    const map=receipts();map.set(H('6'),{...map.get(H('6')),...change});
+    await assert.rejects(()=>verifyCandidateSelectionEvidenceR206(input(),{verifyReceipt:verifier(map)}),/benchmark receipt binding mismatch/);
+  }
+});
+
+test('R206 rejects proposer-controlled signer roles and receipt reuse',async()=>{
+  const proposer=receipts();proposer.set(H('5'),{...proposer.get(H('5')),signer_role:'candidate_proposer'});
+  await assert.rejects(()=>verifyCandidateSelectionEvidenceR206(input(),{verifyReceipt:verifier(proposer)}),/correctness receipt binding mismatch/);
+  const reused=input();reused.candidates[0].correctness.receipt_sha256=H('2');
+  await assert.rejects(()=>verifyCandidateSelectionEvidenceR206(reused,{verifyReceipt:verifier(receipts())}),/receipt reused/);
+});
+
+test('R206 refuses a missing verifier instead of trusting hash-shaped claims',async()=>{
+  await assert.rejects(()=>verifyCandidateSelectionEvidenceR206(input(),{}),/independent receipt verifier required/);
+});

package/test/r206-release-contract.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const json=async name=>JSON.parse(await readFile(path.join(root,name),'utf8'));
+
+test('R206 identity binds R205 source separately from active 0.15.74 runtime',async()=>{
+  const [pkg,lock,bridge,release,provenance,matrix,sbom]=await Promise.all([
+    json('package.json'),json('docs/R184-package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
+    json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json')
+  ]);
+  assert.equal(pkg.version,'0.15.75');
+  assert.equal(lock.version,'0.15.75');
+  assert.equal(lock.packages[''].version,'0.15.75');
+  assert.equal(bridge.version,'0.15.75');
+  assert.equal(release.version,'0.15.75');assert.equal(release.train,'R206');
+  assert.equal(release.source_predecessor.train,'R205');
+  assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.74-e84bf4eed16e9443');
+  assert.equal(provenance.builder,'deadbyte-r206-release-closure');
+  assert.equal(provenance.source_predecessor_train,'R205');
+  assert.equal(provenance.source_predecessor_manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+  assert.equal(matrix.train,'R206');
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r206:0.15.75');
+});
+
+test('R206 release contract keeps public surface stable and deferred work truthful',async()=>{
+  const release=await json('RELEASE.json');
+  assert.equal(release.capabilities.compact_tool_count,43);
+  assert.equal(release.capabilities.full_tool_count,117);
+  assert.equal(release.r206.public_tool_delta,0);
+  assert.equal(release.r206.authority_scope_delta,0);
+  assert.equal(release.r206.selector_release_authority,false);
+  assert.deepEqual(release.r206.deferred_unverified,[
+    'REMOTE_TWO_MACHINE_E2E','NATIVE_UIA_APPLICATION_EFFECT','BOUNDED_CDP_HARNESS2','REA_WINDOWS_209_TOOL_PARITY'
+  ]);
+  assert.equal(release.r206.npm_publish,'NOT_RUN');
+  assert.equal(release.r206.production_activation,'NOT_RUN');
+});

package/test/r206-release-readiness.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {assertR206NpmPublishReady,assertR206PackedIdentity} from '../scripts/npm-release-readiness-r206.mjs';
+
+const release={
+  version:'0.15.75',train:'R206',
+  parent:{version:'0.15.74',release_id:'v0.15.74-e84bf4eed16e9443',
+    manifest_sha256:'e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47',
+    generation_manifest_sha256:'598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7'},
+  source_predecessor:{train:'R205',manifest_sha256:'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92'},
+  r206:{scope:'EVIDENCE_BOUND_CANDIDATE_SELECTION_RELEASE_CLOSURE',public_tool_delta:0,authority_scope_delta:0,selector_release_authority:false}
+};
+
+test('R206 publication refuses an absent exact-byte closure before pack or registry effects',async()=>{
+  await assert.rejects(assertR206NpmPublishReady(release,{root:'D:\\candidate'}),/PUBLISH_BLOCKED R206.*closure root absent/);
+});
+
+test('R206 packed identity refuses any artifact differing from the protected closure',()=>{
+  assert.throws(()=>assertR206PackedIdentity({
+    tarball_sha256:'a'.repeat(64),tarball_integrity:'sha512-expected',tarball_shasum:'b'.repeat(40),
+    observedSha256:'c'.repeat(64),observedIntegrity:'sha512-other',observedShasum:'d'.repeat(40)
+  }),/PUBLISH_BLOCKED R206.*repacked tarball/);
+});

package/test/r59-tool-surface-compat.test.mjs

@@ -83,7 +83,7 @@ test('R72 compact baseline permits only R64 read offset and authorized coding-on
   assert.deepEqual(diff.added,[]);
   assert.deepEqual(diff.removed,[]);
   const packageVersion=JSON.parse(await readFile(path.join(repoRoot,'package.json'),'utf8')).version;
-  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54','0.15.55','0.15.56','0.15.57','0.15.58','0.15.59','0.15.60','0.15.61','0.15.62','0.15.63','0.15.64','0.15.65','0.15.66','0.15.67','0.15.68','0.15.69','0.15.70','0.15.71','0.15.72','0.15.73','0.15.74'].includes(packageVersion)){
+  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54','0.15.55','0.15.56','0.15.57','0.15.58','0.15.59','0.15.60','0.15.61','0.15.62','0.15.63','0.15.64','0.15.65','0.15.66','0.15.67','0.15.68','0.15.69','0.15.70','0.15.71','0.15.72','0.15.73','0.15.74','0.15.75'].includes(packageVersion)){
     assert.deepEqual([...diff.schema_changed].sort(),['machine_fs','native_diff_preview']);
     assert.equal(diff.unchanged.length,41);
     const prior=baseline.tools.find(tool=>tool.name==='machine_fs');

package/test/r64-machine-fs-large-read.test.mjs

@@ -9,6 +9,7 @@ import {tmpdir} from 'node:os';
 import path from 'node:path';
 import {loadCodingPolicy} from '../src/coding-plane.mjs';
 import {createMachineFsRuntime} from '../src/machine-fs.mjs';
+import {readRangeFromHandle} from '../src/machine-fs-handle-read-r196.mjs';
 import {generateTrustKeypair} from '../src/trust.mjs';
 import {machineFsGatewayInputSchema} from '../src/compact-gateway-mcp-tools.mjs';
 import {registerMachineFsTools} from '../src/machine-fs-mcp-tools.mjs';
@@ -106,31 +107,44 @@ test('R64 large-offset read retains bounded worker cancellation',async t=>{
   await assert.rejects(()=>runtime.read({rootId:'project',relativePath:'large.bin',offset:PAGE+1,maxBytes:1,timeoutMs:100}),/timed out after 100ms/);
 });
 
-test('R64 default hash stream is abort-bound to read timeout',async()=>{
+test('R64 default hash stream uses the retained handle and remains abort-bound',async()=>{
   const source=await readFile(new URL('../src/machine-fs.mjs',import.meta.url),'utf8');
-  assert.ok(/createReadStream\(file,\s*\{\s*signal\s*\}\)/.test(source),'hash stream must receive the read abort signal');
+  const handleSource=await readFile(new URL('../src/machine-fs-handle-read-r196.mjs',import.meta.url),'utf8');
+  assert.ok(/readRangeFromHandle\(handle,/.test(source),'read must use opened handle');
+  assert.ok(/handle\.createReadStream\(\{start:0,autoClose:false,signal\}\)/.test(handleSource),
+    'hash must stream through the retained FileHandle with abort signal');
   assert.ok(/abortController\.abort\(\)/.test(source),'read timeout must abort its hash stream');
 });
 
-test('R64 timed-out default hash stream receives abort and stops',async t=>{
+test('R64 fallback FileHandle hash stream obeys abort independently of the new native backend',async t=>{
   const f=await fixture(t);
-  await writeFile(path.join(f.project,'large.bin'),Buffer.alloc(PAGE+16));
-  const original=fs.createReadStream;
-  let observedAbort=false;
-  fs.createReadStream=(_file,options={})=>{
+  const file=path.join(f.project,'large.bin');
+  await writeFile(file,Buffer.alloc(PAGE+16));
+  const handle=await fs.promises.open(file,'r');
+  const proto=Object.getPrototypeOf(handle);
+  const original=proto.createReadStream;
+  let started,called=false,observedAbort=false;
+  const entered=new Promise(resolve=>started=resolve);
+  proto.createReadStream=function(options={}){
+    called=true;
     const stream=new EventEmitter();
     options.signal?.addEventListener('abort',()=>{
       observedAbort=true;
       queueMicrotask(()=>stream.emit('error',new Error('aborted')));
     },{once:true});
+    started();
     return stream;
   };
-  syncBuiltinESMExports();
+  const controller=new AbortController();
   try{
-    await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:PAGE+1,maxBytes:1,hashFile:true,timeoutMs:100}),/timed out after 100ms/);
-    assert.equal(observedAbort,true,'default hash stream continued after timeout');
+    const operation=readRangeFromHandle(handle,{offset:PAGE+1,length:1,hashFile:true,signal:controller.signal});
+    await entered;
+    controller.abort();
+    await assert.rejects(operation,/aborted/);
+    assert.equal(called,true,'fallback handle hash was not started');
+    assert.equal(observedAbort,true,'fallback hash stream ignored abort');
   }finally{
-    fs.createReadStream=original;
-    syncBuiltinESMExports();
+    proto.createReadStream=original;
+    await handle.close();
   }
 });