deadbyte-mcp 0.15.74 → 0.15.76

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('R207 retains R206 evidence while binding R206 source separately from active 0.15.75 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.76');
+  assert.equal(lock.version,'0.15.76');
+  assert.equal(lock.packages[''].version,'0.15.76');
+  assert.equal(bridge.version,'0.15.76');
+  assert.equal(release.version,'0.15.76');assert.equal(release.train,'R207');
+  assert.equal(release.source_predecessor.train,'R206');
+  assert.equal(release.source_predecessor.manifest_sha256,'9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248');
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.75-9039fff265696091');
+  assert.equal(provenance.builder,'deadbyte-r207-owner-enrollment-fix');
+  assert.equal(provenance.source_predecessor_train,'R206');
+  assert.equal(provenance.source_predecessor_manifest_sha256,'9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248');
+  assert.equal(matrix.train,'R207');
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r207:0.15.76');
+});
+
+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/r207-owner-enrollment-io.test.mjs

@@ -0,0 +1,37 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,readFile,rm,symlink,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {ensureOwnerConsentDirectory,parseOwnerEnrollmentJson} from '../src/r207-owner-enrollment-io.mjs';
+
+test('R207 parses Windows PowerShell UTF-8 BOM supervisor ledgers',()=>{
+  const value=parseOwnerEnrollmentJson(Buffer.concat([Buffer.from([0xef,0xbb,0xbf]),Buffer.from('{"schema":"deadbyte.supervisor.instance.v1","pid":17}')]),'supervisor ledger');
+  assert.equal(value.schema,'deadbyte.supervisor.instance.v1');
+  assert.equal(value.pid,17);
+  assert.throws(()=>parseOwnerEnrollmentJson(Buffer.from('\uFEFF[]'),'supervisor ledger'),/must be an object/);
+});
+
+test('R207 initializes the bounded owner-consent state directory before no-clobber request creation',async()=>{
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r207-owner-'));
+  try{
+    const runtime=path.join(base,'runtime');await mkdir(runtime);
+    const consent=await ensureOwnerConsentDirectory(runtime);
+    assert.equal(consent.toLowerCase(),path.join(runtime,'owner-consent').toLowerCase());
+    const request=path.join(consent,'request.json');
+    await writeFile(request,'{}\n',{flag:'wx'});
+    await assert.rejects(writeFile(request,'{}\n',{flag:'wx'}),error=>error?.code==='EEXIST');
+    assert.equal(await readFile(request,'utf8'),'{}\n');
+  }finally{await rm(base,{recursive:true,force:true});}
+});
+
+test('R207 rejects an owner-consent junction or symlink escape',async t=>{
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r207-owner-link-'));
+  try{
+    const runtime=path.join(base,'runtime'),outside=path.join(base,'outside');
+    await mkdir(runtime);await mkdir(outside);
+    try{await symlink(outside,path.join(runtime,'owner-consent'),process.platform==='win32'?'junction':'dir');}
+    catch(error){if(error?.code==='EPERM'){t.skip('Windows symlink privilege unavailable');return;}throw error;}
+    await assert.rejects(ensureOwnerConsentDirectory(runtime),/real directory|escapes/);
+  }finally{await rm(base,{recursive:true,force:true});}
+});

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

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const root = new URL('../', import.meta.url);
+const json = async name => JSON.parse(await readFile(new URL(name, root), 'utf8'));
+
+test('R207 identity binds exact R206 source and active 0.15.75 runtime predecessors', async () => {
+  const [pkg, lock, bridge, release, provenance, matrix, sbom, versionSource] = 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'),
+    readFile(new URL('src/version.mjs', root), 'utf8')
+  ]);
+  for (const value of [pkg.version, lock.version, lock.packages[''].version, bridge.version,
+    release.version, provenance.version, matrix.version, sbom.metadata.component.version]) {
+    assert.equal(value, '0.15.76');
+  }
+  assert.match(versionSource, /DEADBYTE_VERSION = '0\.15\.76'/);
+  assert.equal(release.train, 'R207');
+  assert.equal(matrix.train, 'R207');
+  assert.equal(sbom.serialNumber, 'urn:cdx:deadbyte-mcp:r207:0.15.76');
+  assert.deepEqual(release.source_predecessor, {
+    version: '0.15.75',
+    train: 'R206',
+    source_path: 'D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.75-r206-release-closure',
+    release_status: 'RELEASED',
+    manifest_status: 'R206_MANIFEST_VERIFIED',
+    manifest_sha256: '9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248',
+    tarball_sha256: 'c2ebb079e7725f3a2f2c7d8f98ef42059e94e51f402d99c1825f46e020237ee9'
+  });
+  assert.deepEqual(release.runtime_predecessor, {
+    version: '0.15.75',
+    release_id: 'v0.15.75-9039fff265696091',
+    manifest_sha256: '9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248',
+    generation_manifest_sha256: '83a212e01173c73f78cff2a6d26e6f3f50f476a8c0ea3cbbf592a466071909e9'
+  });
+});
+
+test('R207 keeps authority surface stable and fixes only protected owner-enrollment IO', 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.r207.scope, 'PROTECTED_OWNER_ENROLLMENT_IO_RECOVERY');
+  assert.equal(release.r207.public_tool_delta, 0);
+  assert.equal(release.r207.authority_scope_delta, 0);
+  assert.equal(release.r207.r70_weakened, false);
+  assert.equal(release.r207.r89_weakened, false);
+  assert.equal(release.r207.owner_private_key_access, false);
+  assert.equal(release.r207.owner_consent_directory_initialization, 'FAIL_CLOSED_CONTAINED_NON_REPARSE');
+  assert.equal(release.r207.supervisor_ledger_utf8_bom, 'ACCEPT_ONE_LEADING_BOM_ONLY');
+});

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

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {assertR207NpmPublishReady,assertR207PackedIdentity} from '../scripts/npm-release-readiness-r207.mjs';
+const base={version:'0.15.76',train:'R207',
+ parent:{version:'0.15.75',release_id:'v0.15.75-9039fff265696091',manifest_sha256:'9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248',generation_manifest_sha256:'83a212e01173c73f78cff2a6d26e6f3f50f476a8c0ea3cbbf592a466071909e9'},
+ source_predecessor:{train:'R206',manifest_sha256:'9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248'},
+ r207:{scope:'PROTECTED_OWNER_ENROLLMENT_IO_RECOVERY',public_tool_delta:0,authority_scope_delta:0,owner_private_key_access:false,r70_weakened:false,r89_weakened:false}};
+test('R207 refuses publish absent independently verified closure',async()=>{
+ await assert.rejects(assertR207NpmPublishReady(base,{root:'D:\\candidate'}),/PUBLISH_BLOCKED R207.*closure root absent/);
+});
+test('R207 refuses any authority increase or private-key access',async()=>{
+ for(const key of ['owner_private_key_access','r70_weakened','r89_weakened']){
+  const altered=structuredClone(base);altered.r207[key]=true;
+  await assert.rejects(assertR207NpmPublishReady(altered,{root:'D:\\candidate'}),/PUBLISH_BLOCKED R207.*public authority surface widened/);
+ }
+});
+test('R207 rejects mismatched parent release before reading any closure',async()=>{
+ const altered=structuredClone(base);altered.parent.release_id='v0.15.74-e84bf4eed16e9443';
+ await assert.rejects(assertR207NpmPublishReady(altered,{root:'D:\\candidate'}),/PUBLISH_BLOCKED R207.*lineage mismatch/);
+});
+test('R207 refuses repacked artifact identity drift',()=>{
+ assert.throws(()=>assertR207PackedIdentity({tarball_sha256:'a'.repeat(64),tarball_integrity:'sha512-proof',tarball_shasum:'b'.repeat(40),observedSha256:'c'.repeat(64),observedIntegrity:'sha512-another',observedShasum:'d'.repeat(40)}),/PUBLISH_BLOCKED R207.*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','0.15.76'].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();
   }
 });