deadbyte-mcp 0.15.72 → 0.15.75

package/test/r130-release-security-contract.test.mjs

@@ -14,14 +14,14 @@ test('current successor retains the R130 security baseline with truthful R190 id
     read('SBOM.cdx.json'),readReleaseLock(root),read('TEST-MATRIX.json')]);
   assert.equal(pkg.name,'deadbyte-mcp');
   for(const actual of [pkg.version,release.version,provenance.version,matrix.version,bom.metadata.component.version,lock.version,lock.packages[''].version,DEADBYTE_VERSION])
-    assert.equal(actual,'0.15.72');
-  assert.equal(release.train,'R192');
-  assert.equal(matrix.train,'R192');
-  assert.equal(release.source_predecessor.version,'0.15.71');
-  assert.equal(release.source_predecessor.train,'R191');
-  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.71\.tgz/i);
-  assert.equal(release.source_predecessor.manifest_status,'PUBLISHED_EXACT_MANIFEST_VERIFIED_ACTIVE_PRODUCTION');
-  assert.equal(release.runtime_predecessor.version,'0.15.71');
+    assert.equal(actual,'0.15.75');
+  assert.equal(release.train,'R206');
+  assert.equal(matrix.train,'R206');
+  assert.equal(release.source_predecessor.version,'0.15.75');
+  assert.equal(release.source_predecessor.train,'R205');
+  assert.match(release.source_predecessor.source_path,/r205-evidence-selection-dev/i);
+  assert.equal(release.source_predecessor.manifest_status,'R205_MANIFEST_VERIFIED');
+  assert.equal(release.runtime_predecessor.version,'0.15.74');
   assert.equal(provenance.r160.source_predecessor_manifest_status,'STALE_REJECTED');
   assert.equal(pkg.dependencies['@modelcontextprotocol/client'],'2.3.1');
   assert.equal(pkg.dependencies['@modelcontextprotocol/server'],'2.3.1');

package/test/r132-release-identity.test.mjs

@@ -16,17 +16,17 @@ test('R190 package identity preserves R132 evidence and published R179 source pr
   for(const value of [pkg.version,lock.version,lock.packages[''].version,release.version,prov.version,bom.metadata.component.version,matrix.version,DEADBYTE_VERSION]){
     assert.equal(value,pkg.version);
   }
-  assert.equal(release.train,'R192');
-  assert.equal(matrix.train,'R192');
-  assert.equal(release.source_predecessor.version,'0.15.71');
-  assert.equal(release.source_predecessor.train,'R191');
-  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.71\.tgz/i);
+  assert.equal(release.train,'R206');
+  assert.equal(matrix.train,'R206');
+  assert.equal(release.source_predecessor.version,'0.15.75');
+  assert.equal(release.source_predecessor.train,'R205');
+  assert.match(release.source_predecessor.source_path,/r205-evidence-selection-dev/i);
   assert.equal(prov.r160.source_predecessor_manifest_status,'STALE_REJECTED');
   assert.equal(release.r165.published_source_manifest_sha256,'4adf7d94682fbb71c4a91eb3147ecc48076bbc5d79cb67fcb875cde6a1bb4805');
   assert.equal(release.r165.published_source_tarball_sha256,'812e97609b7c51353ed25f2202129737e43bb4fbe0778c3adec43ec065352641');
-  assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
+  assert.equal(release.source_predecessor.tarball_sha256,null);
   assert.notEqual(release.r179.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
-  assert.equal(release.runtime_predecessor.version,'0.15.71');
+  assert.equal(release.runtime_predecessor.version,'0.15.74');
   assert.equal(prov.runtime_predecessor.release_id,release.runtime_predecessor.release_id);
   assert.equal(prov.runtime_predecessor.manifest_sha256,release.runtime_predecessor.manifest_sha256);
   assert.equal(prov.runtime_predecessor.generation_manifest_sha256,release.runtime_predecessor.generation_manifest_sha256);

package/test/r153-prepublish-identity.test.mjs

@@ -26,7 +26,7 @@ test('R153 historical verifier refuses current successor package identity',async
  const state={pkg:JSON.parse(await readFile(path.join(root,'package.json'),'utf8')),
   release:JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8')),
   bridge:JSON.parse(await readFile(path.join(root,'bridge/package.json'),'utf8'))};
- assert.equal(state.pkg.version,'0.15.72');
+ assert.equal(state.pkg.version,'0.15.75');
  assert.throws(()=>verifyR153Lineage(state),/package version/);
  await assert.rejects(verifyR153IdentityTree(root),/package version/);
 });

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

@@ -8,9 +8,9 @@ const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 
 test('R160 historical contract remains distinct from the current package identity',async()=>{
   const [release,provenance]=await Promise.all([read('RELEASE.json'),read('PROVENANCE.json')]);
-  assert.equal(release.runtime_predecessor.version,'0.15.71');
-  assert.equal(release.runtime_predecessor.release_id,'v0.15.71-1818abc327478a96');
-  assert.equal(release.runtime_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
+  assert.equal(release.runtime_predecessor.version,'0.15.74');
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.74-e84bf4eed16e9443');
+  assert.equal(release.runtime_predecessor.manifest_sha256,'e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47');
   assert.equal(release.r160.runtime_predecessor_version,'0.15.61');
   assert.equal(release.r160.source_predecessor_train,'R159');
   assert.equal(release.r160.public_tool_delta,0);

package/test/r165-live-cli-skew.test.mjs

@@ -17,7 +17,7 @@ const hashMarker=c=>c.repeat(64);
 async function fixture(t,kind){
   assert.equal(typeof envRoot,'string'); assert.ok(path.isAbsolute(envRoot));
   assert.match(sha(await readFile(path.join(envRoot,'MANIFEST.SHA256'))),/^[0-9a-f]{64}$/);
-  assert.equal(JSON.parse(await readFile(path.join(envRoot,'package.json'),'utf8')).version,'0.15.72');
+  assert.equal(JSON.parse(await readFile(path.join(envRoot,'package.json'),'utf8')).version,'0.15.75');
   const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r164-skew-e2e-'));
   t.after(async()=>{await rm(dir,{recursive:true,force:true,maxRetries:10,retryDelay:150});});
   const state=path.join(dir,'state'),bin=path.join(state,'bin');

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

@@ -8,7 +8,7 @@ import {DEADBYTE_VERSION} from '../src/version.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 const readOptional=async rel=>{try{return await read(rel);}catch(error){if(error?.code==='ENOENT')return null;throw error;}};
-const VERSION='0.15.72';
+const VERSION='0.15.75';
 const R166_MANIFEST='ad3c091fbbe2bac6d234548724008b67305fd483ad6542f92d5aeb1aa84f5849';
 const R166_TARBALL='3d22412c3cebabd66bfa92ca4dbaaf3ef49acba7f92436a16485d7e4cb18c653';
 
@@ -20,20 +20,20 @@ test('current package identity retains the immutable R167/R173 activation lineag
     provenance.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION];
   if(lock)versions.push(lock.version,lock.packages[''].version);
   for(const version of versions)assert.equal(version,VERSION);
-  assert.equal(release.train,'R192');
-  assert.equal(matrix.train,'R192');
-  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r192:0.15.72');
+  assert.equal(release.train,'R206');
+  assert.equal(matrix.train,'R206');
+  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r206:0.15.75');
   assert.deepEqual(release.runtime_predecessor,{
-    version:'0.15.71',release_id:'v0.15.71-1818abc327478a96',
-    manifest_sha256:'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c',
-    generation_manifest_sha256:'aef437280102171a9b68da754fca16a03202104db7d5c420751624580ad6fadc'
+    version:'0.15.74',release_id:'v0.15.74-e84bf4eed16e9443',
+    manifest_sha256:'e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47',
+    generation_manifest_sha256:'598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7'
   });
-  assert.equal(release.source_predecessor.version,'0.15.71');
-  assert.equal(release.source_predecessor.train,'R191');
-  assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
+  assert.equal(release.source_predecessor.version,'0.15.75');
+  assert.equal(release.source_predecessor.train,'R205');
+  assert.equal(release.source_predecessor.tarball_sha256,null);
   assert.equal(release.r173.source_predecessor_version,'0.15.67');
   assert.equal(release.r167.source_predecessor_manifest_sha256,R166_MANIFEST);
-  assert.equal(provenance.source_predecessor_manifest_file_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
   assert.equal(provenance.r173.source_predecessor_manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
   assert.equal(release.r172.source_predecessor_manifest_sha256,'962e227dace247d59aa860211388fbde461c5f9c8a7e8a878e34a14a27d355f8');
   assert.equal(release.r172.source_predecessor_tarball_sha256,'31b194a4fbff7dbdb9f4f275b4ea49c5115f7b0bb2241c0c72d72ef690311a5d');

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

@@ -13,10 +13,10 @@ const predecessorTarball='fc3ae5b1505e316bc9dfedf8d063cb00641754c8f5f1306a31f8cc
 
 test('R172 preserves the immutable R168 publication lineage separately from current identity',async()=>{
  const release=await read('RELEASE.json');
- assert.equal(release.runtime_predecessor.version,'0.15.71');
- assert.equal(release.parent.version,'0.15.71');
- assert.equal(release.runtime_predecessor.release_id,'v0.15.71-1818abc327478a96');
- assert.equal(release.parent.release_id,'v0.15.71-1818abc327478a96');
+ assert.equal(release.runtime_predecessor.version,'0.15.74');
+ assert.equal(release.parent.version,'0.15.74');
+ assert.equal(release.runtime_predecessor.release_id,'v0.15.74-e84bf4eed16e9443');
+ assert.equal(release.parent.release_id,'v0.15.74-e84bf4eed16e9443');
  assert.notEqual(release.runtime_predecessor.release_id,parent);
  assert.notEqual(release.parent.release_id,parent);
  assert.equal(release.r168.scope,'REMOTE_VERSION_SKEW_FAIL_CLOSED_AND_READONLY_RECONCILIATION');

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

@@ -16,12 +16,12 @@ test('R190 binds the published source predecessor separately from the active run
   const versions=[pkg.version,bridge.version,release.version,provenance.version,matrix.version,
     bom.metadata.component.version,DEADBYTE_VERSION];
   if(lock)versions.push(lock.version,lock.packages[''].version);
-  for(const value of versions)assert.equal(value,'0.15.72');
-  assert.equal(release.train,'R192'); assert.equal(matrix.train,'R192');
-  assert.equal(release.source_predecessor.version,'0.15.71');
-  assert.equal(release.source_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
-  assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
-  assert.equal(release.runtime_predecessor.release_id,'v0.15.71-1818abc327478a96');
+  for(const value of versions)assert.equal(value,'0.15.75');
+  assert.equal(release.train,'R206'); assert.equal(matrix.train,'R206');
+  assert.equal(release.source_predecessor.version,'0.15.75');
+  assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+  assert.equal(release.source_predecessor.tarball_sha256,null);
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.74-e84bf4eed16e9443');
   assert.equal(release.r173.public_tool_delta,0); assert.equal(release.r173.authority_scope_delta,0);
 });
 

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

@@ -13,21 +13,21 @@ test('R190 package identity binds the exact published R179 source and live runti
     json('package.json'),readReleaseLock(root),json('bridge/package.json'),json('RELEASE.json'),
     json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json')
   ]);
-  assert.equal(pkg.version,'0.15.72');
-  assert.equal(lock.version,'0.15.72');
-  assert.equal(lock.packages[''].version,'0.15.72');
-  assert.equal(bridge.version,'0.15.72');
-  assert.equal(release.version,'0.15.72');
-  assert.equal(release.train,'R192');
-  assert.equal(matrix.version,'0.15.72');
-  assert.equal(matrix.train,'R192');
-  assert.equal(sbom.metadata.component.version,'0.15.72');
-  assert.equal(release.source_predecessor.version,'0.15.71');
-  assert.equal(release.source_predecessor.train,'R191');
-  assert.equal(release.source_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
-  assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
-  assert.equal(release.runtime_predecessor.version,'0.15.71');
-  assert.equal(provenance.version,'0.15.72');
-  assert.equal(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
+  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(matrix.version,'0.15.75');
+  assert.equal(matrix.train,'R206');
+  assert.equal(sbom.metadata.component.version,'0.15.75');
+  assert.equal(release.source_predecessor.version,'0.15.75');
+  assert.equal(release.source_predecessor.train,'R205');
+  assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+  assert.equal(release.source_predecessor.tarball_sha256,null);
+  assert.equal(release.runtime_predecessor.version,'0.15.74');
+  assert.equal(provenance.version,'0.15.75');
+  assert.equal(provenance.parent_tarball_sha256,'5da436a3f8068107e74caf6da58ff1e211d4a62f94266853136b601762f36f0c');
   assert.equal(provenance.source_predecessor_manifest_file_sha256,release.source_predecessor.manifest_sha256);
 });

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

@@ -7,27 +7,27 @@ import {DEADBYTE_VERSION} from '../src/version.mjs';
 import {readReleaseLock} from './helpers/release-lock.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
-const parent='v0.15.71-1818abc327478a96';
-const manifest='1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c';
-const generation='aef437280102171a9b68da754fca16a03202104db7d5c420751624580ad6fadc';
+const parent='v0.15.74-e84bf4eed16e9443';
+const manifest='e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47';
+const generation='598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7';
 const tarball='1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf';
 test('R190 version, lock snapshot, bridge, matrix, SBOM and provenance identify exact 0.15.70 successor',async()=>{
  const [pkg,lock,bridge,release,provenance,matrix,sbom]=await Promise.all([
   read('package.json'),readReleaseLock(root),read('bridge/package.json'),read('RELEASE.json'),
   read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
  for(const version of [pkg.version,lock.version,lock.packages[''].version,bridge.version,release.version,provenance.version,
-  matrix.version,sbom.metadata.component.version,DEADBYTE_VERSION])assert.equal(version,'0.15.72');
- assert.equal(release.train,'R192');assert.equal(matrix.train,'R192');
- assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r192:0.15.72');
+  matrix.version,sbom.metadata.component.version,DEADBYTE_VERSION])assert.equal(version,'0.15.75');
+ assert.equal(release.train,'R206');assert.equal(matrix.train,'R206');
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r206:0.15.75');
  assert.equal(release.parent.release_id,parent);assert.equal(release.parent.manifest_sha256,manifest);
  assert.equal(release.parent.generation_manifest_sha256,generation);
- assert.equal(release.source_predecessor.version,'0.15.71');
- assert.equal(release.source_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
- assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
+ assert.equal(release.source_predecessor.version,'0.15.75');
+ assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+ assert.equal(release.source_predecessor.tarball_sha256,null);
  assert.equal(release.runtime_predecessor.release_id,parent);
  assert.equal(provenance.runtime_predecessor.release_id,parent);
- assert.equal(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
- assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+ assert.equal(provenance.parent_tarball_sha256,'5da436a3f8068107e74caf6da58ff1e211d4a62f94266853136b601762f36f0c');
+ assert.equal(provenance.source_predecessor_tarball_sha256,null);
 });
 test('R179 does not misrepresent owner Autonomous enrollment, protected regression or publication as finished',async()=>{
  const [release,prov,matrix]=await Promise.all(['RELEASE.json','PROVENANCE.json','TEST-MATRIX.json'].map(read));
@@ -48,7 +48,7 @@ test('R190 retains historical R179 and R173 source evidence without promoting it
  assert.equal(release.r173.source_predecessor_version,'0.15.67');
  assert.equal(release.r173.source_predecessor_manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
  assert.equal(prov.r173.source_predecessor_version,'0.15.67');
- assert.equal(release.source_predecessor.version,'0.15.71');
+ assert.equal(release.source_predecessor.version,'0.15.75');
  assert.notEqual(release.source_predecessor.tarball_sha256,release.r173.source_predecessor_tarball_sha256);
 });
 test('R184 ships a semantic lock snapshot matching installed package identity and dependencies',async()=>{

package/test/r188-owner-uac.test.mjs

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createR188OwnerUacRequest,verifyR188OwnerUacRequest} from '../src/r188-owner-uac.mjs';
+const h=c=>c.repeat(64);
+const issued=new Date('2026-10-28T06:00:00.000Z');
+const fixture={
+ machineEpoch:h('e'),releaseManifestSha256:h('a'),
+ codingPolicySha256:h('b'),autonomousPolicySha256:h('c'),
+ rootId:'core',projectRoot:'D:\\Projects\\deadbyte-mcp',
+ maxSeconds:600,now:issued,expiresInMs:120000
+};
+test('R188 no-Windows-Hello UAC review is project-scoped, short lived and not a grant',()=>{
+ const a=createR188OwnerUacRequest(fixture),b=createR188OwnerUacRequest(fixture);
+ assert.equal(a.schema,'deadbyte.r188-owner-uac-request.v1');
+ assert.equal(a.subject.root_id,'core');
+ assert.equal(a.subject.operation,'autonomous_goal_run');
+ assert.equal(a.subject.max_seconds,600);
+ assert.equal(a.subject.expires_at_utc,'2026-10-28T06:02:00.000Z');
+ assert.notEqual(a.challenge,b.challenge);
+ assert.equal(a.authority_granted,false);
+ assert.equal(a.owner_approved,false);
+ assert.equal(a.require_interactive_uac,true);
+ assert.match(a.review_phrase,/^APPROVE-[A-F0-9]{12}$/);
+ assert.match(a.request_sha256,/^[a-f0-9]{64}$/);
+ const r=verifyR188OwnerUacRequest({request:a,expected:fixture,now:new Date(issued.getTime()+1000)});
+ assert.equal(r.status,'VERIFIED_FOR_REVIEW_ONLY');
+ assert.equal(r.authority_granted,false);
+ assert.equal(r.request_sha256,a.request_sha256);
+});
+test('R188 disallows broad scopes and unsafe timestamps before preparing a review',()=>{
+ for(const change of [
+  {rootId:'all'}, {maxSeconds:3601}, {maxSeconds:0},
+  {machineEpoch:'a'}, {codingPolicySha256:h('g')},
+  {projectRoot:'D:\\'},{projectRoot:'relative'},
+  {expiresInMs:300001},{expiresInMs:-1}
+ ])assert.throws(()=>createR188OwnerUacRequest({...fixture,...change}),/R188/);
+});
+test('R188 rejects changed release, policy, epoch, path, signature-like receipt or expired request',()=>{
+ const request=createR188OwnerUacRequest(fixture);
+ for(const change of [
+  {releaseManifestSha256:h('f')},{codingPolicySha256:h('d')},
+  {autonomousPolicySha256:h('0')},{machineEpoch:h('1')},
+  {projectRoot:'D:\\Other'}
+ ])assert.throws(()=>verifyR188OwnerUacRequest({request,expected:{...fixture,...change},now:issued}),/R188/);
+ assert.throws(()=>verifyR188OwnerUacRequest({request:{...request,owner_approved:true},expected:fixture,now:issued}),/R188/);
+ assert.throws(()=>verifyR188OwnerUacRequest({request:{...request,challenge:'A'.repeat(43)},expected:fixture,now:issued}),/R188/);
+ assert.throws(()=>verifyR188OwnerUacRequest({request,expected:fixture,now:new Date(issued.getTime()+120000)}),/R188/);
+});

package/test/r188-uac-boundary.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+import {inspectTrustedInstallation,privilegedEpochInstallFiles} from '../src/privileged-install-trust-r89.mjs';
+const root=fileURLToPath(new URL('..',import.meta.url));
+test('R188 owner review is explicitly manual, protected, with UAC secure desktop and expiry review',async()=>{
+ const script=await readFile(path.join(root,'scripts','r188-owner-uac-review.ps1'),'utf8');
+ assert.match(script,/#requires -RunAsAdministrator/);
+ assert.match(script,/EnableLUA/);
+ assert.match(script,/PromptOnSecureDesktop/);
+ assert.match(script,/ConsentPromptBehaviorAdmin/);
+ assert.match(script,/Read-Host/);
+ assert.match(script,/REVIEWED_NO_GRANT/);
+ assert.match(script,/authority_granted=\$false/);
+ assert.match(script,/grant_issued=\$false/);
+ assert.match(script,/FileMode\]::CreateNew/);
+ assert.doesNotMatch(script,/Start-Process\s+.*-Verb\s+RunAs/i);
+ assert.doesNotMatch(script,/Arm-Autonomous|transaction_revoke|autonomous-grant\.json/);
+});
+test('R188 UAC preflight fails closed at the applicable trust or request boundary',async()=>{
+ let trusted=false;
+ try{
+  trusted=(await inspectTrustedInstallation(privilegedEpochInstallFiles(root,process.execPath))).trusted===true;
+ }catch{}
+ const script=path.join(root,'scripts','r188-uac-review-preview.mjs');
+ const r=spawnSync(process.execPath,[script,'D:\\bad-request.json'],{
+  encoding:'utf8',cwd:root,windowsHide:true,timeout:12000,maxBuffer:512*1024});
+ assert.equal(r.status,2);
+ if(trusted)assert.match(r.stderr,/ENOENT.*bad-request\.json/i);
+ else assert.match(r.stderr,/R188_UAC_REVIEW_BLOCKED|R89_PROTECTED_INSTALLATION_REQUIRED|R89 privileged installation not protected: UNTRUSTED_WRITE_ACE/);
+ assert.doesNotMatch(r.stdout,/authority_granted":true/);
+});
+test('R188 broker cannot pretend owner-reviewed data is a current epoch or signed grant',async()=>{
+ const script=await readFile(path.join(root,'scripts','r188-uac-review-preview.mjs'),'utf8');
+ assert.match(script,/live_epoch_verified:false/);
+ assert.match(script,/live_policies_verified:false/);
+ assert.match(script,/authority_granted:false/);
+ assert.match(script,/R89_PROTECTED_INSTALLATION_REQUIRED/);
+});

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

@@ -8,17 +8,17 @@ test('R190 candidate identity separates published source 0.15.69 from active run
   json('package.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',import.meta.url),'utf8')]);
  for(const value of [pkg.version,bridge.version,release.version,provenance.version,matrix.version,
-  sbom.metadata.component.version])assert.equal(value,'0.15.72');
- assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.72'/);
- assert.equal(release.train,'R192');assert.equal(matrix.train,'R192');
- assert.equal(release.source_predecessor.version,'0.15.71');
- assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
- assert.equal(release.source_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
- assert.equal(release.runtime_predecessor.version,'0.15.71');
- assert.equal(release.runtime_predecessor.release_id,'v0.15.71-1818abc327478a96');
- assert.equal(provenance.source_predecessor_version,'0.15.71');
+  sbom.metadata.component.version])assert.equal(value,'0.15.75');
+ assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.75'/);
+ assert.equal(release.train,'R206');assert.equal(matrix.train,'R206');
+ assert.equal(release.source_predecessor.version,'0.15.75');
+ assert.equal(release.source_predecessor.tarball_sha256,null);
+ assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+ assert.equal(release.runtime_predecessor.version,'0.15.74');
+ assert.equal(release.runtime_predecessor.release_id,'v0.15.74-e84bf4eed16e9443');
+ assert.equal(provenance.source_predecessor_version,'0.15.75');
  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
- assert.match(sbom.serialNumber,/r192:0\.15\.72$/);
+ assert.match(sbom.serialNumber,/r206:0\.15\.75$/);
 });
 
 test('R190 release metadata records verified recovery without claiming publication or activation',async()=>{

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

@@ -6,23 +6,23 @@ import path from 'node:path';
 import {DEADBYTE_VERSION} from '../src/version.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const json=async f=>JSON.parse(await readFile(path.join(root,f),'utf8'));
-const predecessor='v0.15.71-1818abc327478a96';
-const publishedManifest='1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c';
-const publishedTarball='20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27';
+const predecessor='v0.15.74-e84bf4eed16e9443';
+const publishedManifest='e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47';
+const publishedTarball='5da436a3f8068107e74caf6da58ff1e211d4a62f94266853136b601762f36f0c';
 test('R191 exact version identity includes bundled bridge, lock snapshot, SBOM, provenance and matrix',async()=>{
  const [pkg,bridge,lock,release,provenance,matrix,bom]=await Promise.all(['package.json','bridge/package.json','docs/R184-package-lock.json','RELEASE.json','PROVENANCE.json','TEST-MATRIX.json','SBOM.cdx.json'].map(json));
- for(const ver of [pkg.version,bridge.version,lock.version,lock.packages[''].version,release.version,provenance.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION])assert.equal(ver,'0.15.72');
- for(const train of [release.train,matrix.train])assert.equal(train,'R192');
- assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r192:0.15.72');
+ for(const ver of [pkg.version,bridge.version,lock.version,lock.packages[''].version,release.version,provenance.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION])assert.equal(ver,'0.15.75');
+ for(const train of [release.train,matrix.train])assert.equal(train,'R206');
+ assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r206:0.15.75');
  assert.equal(release.parent.release_id,predecessor);
  assert.equal(provenance.parent_release_id,predecessor);
- assert.equal(release.source_predecessor.version,'0.15.71');
- assert.equal(release.source_predecessor.manifest_sha256,publishedManifest);
- assert.equal(release.source_predecessor.tarball_sha256,publishedTarball);
- assert.equal(provenance.source_predecessor_version,'0.15.71');
+ assert.equal(release.source_predecessor.version,'0.15.75');
+ assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+ assert.equal(release.source_predecessor.tarball_sha256,null);
+ assert.equal(provenance.source_predecessor_version,'0.15.75');
  assert.equal(provenance.parent_tarball_sha256,publishedTarball);
- assert.equal(provenance.source_predecessor_tarball_sha256,publishedTarball);
- assert.equal(provenance.source_predecessor_manifest_file_sha256,publishedManifest);
+ assert.equal(provenance.source_predecessor_tarball_sha256,null);
+ assert.equal(provenance.source_predecessor_manifest_file_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
  assert.equal(release.r191_activation_repair.npm_publish,'NOT_RUN');
  assert.equal(release.r191_activation_repair.production_activation,'NOT_RUN');
  assert.equal(release.r190_foreground_recovery.status,'PREPUBLISH_VERIFIED');

package/test/r192-release-identity.test.mjs

@@ -3,21 +3,21 @@ import {readFile} from 'node:fs/promises';import {createHash} from 'node:crypto'
 import {DEADBYTE_VERSION} from '../src/version.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async name=>JSON.parse(await readFile(path.join(root,name),'utf8'));
-const prevHash='1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c';
-const prevTar='20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27';
-test('R192 exact package, bridge, lock, metadata and runtime version are 0.15.72',async()=>{
+const prevHash='e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47';
+const prevTar='5da436a3f8068107e74caf6da58ff1e211d4a62f94266853136b601762f36f0c';
+test('R193 current identity retains exact published R192 predecessor evidence',async()=>{
  const [pkg,bridge,lock,release,prov,matrix,bom]=await Promise.all([
  read('package.json'),read('bridge/package.json'),read('docs/R184-package-lock.json'),
  read('RELEASE.json'),read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
  for(const actual of [pkg.version,bridge.version,lock.version,lock.packages[''].version,
  release.version,prov.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION])
-   assert.equal(actual,'0.15.72');
- assert.equal(release.train,'R192');assert.equal(matrix.train,'R192');
- assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r192:0.15.72');
- assert.equal(release.parent.release_id,'v0.15.71-1818abc327478a96');
+   assert.equal(actual,'0.15.75');
+ assert.equal(release.train,'R206');assert.equal(matrix.train,'R206');
+ assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r206:0.15.75');
+ assert.equal(release.parent.release_id,'v0.15.74-e84bf4eed16e9443');
  assert.equal(release.parent.manifest_sha256,prevHash);
- assert.equal(release.source_predecessor.tarball_sha256,prevTar);
- assert.equal(release.source_predecessor.manifest_sha256,prevHash);
+ assert.equal(release.source_predecessor.tarball_sha256,null);
+ assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
  assert.equal(prov.parent_tarball_sha256,prevTar);
  assert.equal(prov.parent_manifest_sha256,prevHash);
  assert.equal(release.r192.production_activation,'NOT_RUN');
@@ -33,7 +33,7 @@ test('R192 foreground reader enforces caller-safe telemetry rather than changing
  assert.match(log,/sanitizeAuditArgs\(compact\[6\]\)/);
  const [policy,release]=await Promise.all([
  read('controller/deadbyte-process-policy.json'),read('RELEASE.json')]);
- const approved=release.r192.development_policy_root;
+ const approved=release.r206.development_policy_root;
  assert.equal(typeof approved,'string');
  assert.ok(path.isAbsolute(approved));
  assert.equal(path.resolve(policy.roots.core.path),path.resolve(approved));

package/test/r193-limited-migration-contract.test.mjs

@@ -0,0 +1,26 @@
+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=fileURLToPath(new URL('..',import.meta.url));
+test('R193 Limited migration uses supported lifecycle, Limited tasks and never silently rearms',async()=>{
+ const source=await readFile(path.join(root,'scripts','r193-migrate-runtime-limited.ps1'),'utf8');
+ assert.match(source,/#requires -RunAsAdministrator/);
+ assert.match(source,/Invoke-Controller supervisorstop/);
+ assert.match(source,/Invoke-Controller stop/);
+ assert.match(source,/DEADBYTE-MCP-Runtime-Logon/);
+ assert.match(source,/RunLevel Limited/);
+ assert.match(source,/desktop_reapproval_required=\$true/);
+ assert.doesNotMatch(source,/armdesktop|armprocess|armcoding|armhost|armautonomous/i);
+ assert.doesNotMatch(source,/Stop-Process|taskkill|TerminateProcess/i);
+});
+test('R193 owner request is generated only from fixed protected live state after migration',async()=>{
+ const source=await readFile(path.join(root,'scripts','r193-owner-request-live.mjs'),'utf8');
+ assert.match(source,/process\.argv\.length!==2/);
+ assert.match(source,/createR193LiveMachineEpoch/);
+ assert.match(source,/verifyManifestTreeExact/);
+ assert.match(source,/observation\.state!=='ONLINE'/);
+ assert.match(source,/authority_granted:false/);
+ assert.doesNotMatch(source,/createPrivateKey|issueR186AutonomousGrant|createAuthorityEpochStore|armautonomous/i);
+});

package/test/r193-live-owner-subject.test.mjs

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {createR188OwnerUacRequest} from '../src/r188-owner-uac.mjs';
+import {buildR193LiveOwnerBoundary,createR193LiveMachineEpoch} from '../src/r193-live-owner-subject.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const filetime=iso=>{
+ const m=/^(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d)\.(\d{1,7})Z$/.exec(iso);
+ return (BigInt(Date.parse(m[1]+'.000Z')+11644473600000)*10000n+BigInt(m[2].padEnd(7,'0'))).toString(16).padStart(16,'0');
+};
+function fixture(){
+ const manifest=Buffer.from('manifest'),coding=Buffer.from('coding'),autonomous=Buffer.from('autonomous');
+ const pointer={release_id:'v0.15.72-test',version:'0.15.72',manifest_sha256:sha(manifest),
+  generation_manifest_sha256:'d'.repeat(64),release_root:'C:\\Program Files\\DEADBYTE-Test'};
+ const authority={process:{configured:true,armed:true,reason:'standing-grant',epoch_seq:1,epoch_sha256:'1'.repeat(64)},
+  coding:{configured:true,armed:true,reason:'standing-grant',epoch_seq:2,epoch_sha256:'2'.repeat(64)},
+  autonomous:{configured:true,armed:false,reason:'disarmed'},
+  desktop:{configured:true,armed:true,reason:'standing-grant',epoch_seq:3,epoch_sha256:'3'.repeat(64)},
+  host:{configured:true,armed:true,reason:'standing-grant',epoch_seq:4,epoch_sha256:'4'.repeat(64)}};
+ const times={bridge:'2026-10-29T08:00:00.1234567Z',core:'2026-10-29T08:00:01.0000000Z',
+  cloud:'2026-10-29T08:00:02.7654321Z',supervisor:'2026-10-29T08:00:03.1000000Z'};
+ const observation={schema:'deadbyte.controller-observation.v1',core_root:pointer.release_root,
+  bridge:{alive:true,pid:101,creation_time_utc:times.bridge},core:{alive:true,pid:102,creation_time_utc:times.core},
+  cloud:{alive:true,pid:103,creation_time_utc:times.cloud},supervisor:{running:true},authority};
+ const supervisor={pid:104,creation_time_utc:times.supervisor};
+ const reports=Object.fromEntries(['bridge','core','cloud','supervisor'].map((component,index)=>[component,{
+  schema:'deadbyte.r193-native-process-token.v1',pid:101+index,creation_filetime_hex:filetime(times[component]),
+  alive:true,identity_verified:true,elevated:false,admin_enabled:false,integrity_rid:8192,token_type:'primary'}]));
+ const machineEpoch=createR193LiveMachineEpoch({activePointer:pointer,controllerObservation:observation});
+ const now=new Date('2026-10-29T08:01:00.000Z');
+ const request=createR188OwnerUacRequest({machineEpoch,releaseManifestSha256:sha(manifest),
+  codingPolicySha256:sha(coding),autonomousPolicySha256:sha(autonomous),rootId:'core',
+  projectRoot:'D:\\Projects\\deadbyte-mcp',maxSeconds:600,now,expiresInMs:120000});
+ return {manifest,coding,autonomous,pointer,observation,supervisor,reports,request,now};
+}
+const build=(f,changes={})=>buildR193LiveOwnerBoundary({request:f.request,activePointer:f.pointer,
+ installedManifestBytes:f.manifest,codingPolicyBytes:f.coding,autonomousPolicyBytes:f.autonomous,
+ controllerObservation:f.observation,supervisorLedger:f.supervisor,processReports:f.reports,
+ brokerR89Trusted:true,keyAclTrusted:true,uac:{enable_uac:true,secure_desktop:true,prompt_mode:'explicit_secure_desktop'},
+ ownerGesture:'approved',now:new Date(f.now.getTime()+1000),...changes});
+
+test('R193 derives exact owner boundary from live release, policies, epoch and kernel process identities',()=>{
+ const f=fixture(),out=build(f);
+ assert.equal(out.expected.machineEpoch,f.request.subject.machine_epoch);
+ assert.equal(out.boundary.agent_processes.length,4);
+ assert.equal(out.boundary.agent_processes.every(x=>x.identity_verified&&!x.elevated),true);
+});
+
+test('R193 live subject rejects release, policy, authority and process identity drift',()=>{
+ const f=fixture();
+ for(const changes of [
+  {installedManifestBytes:Buffer.from('changed')},
+  {codingPolicyBytes:Buffer.from('changed')},
+  {autonomousPolicyBytes:Buffer.from('changed')},
+  {activePointer:{...f.pointer,generation_manifest_sha256:'e'.repeat(64)}},
+  {processReports:{...f.reports,core:{...f.reports.core,pid:999}}},
+  {processReports:{...f.reports,cloud:{...f.reports.cloud,creation_filetime_hex:'0'.repeat(16)}}},
+  {controllerObservation:{...f.observation,authority:{...f.observation.authority,host:{...f.observation.authority.host,epoch_seq:5}}}}
+ ])assert.throws(()=>build(f,changes),/R193|R188/);
+});

package/test/r193-native-process-observer.test.mjs

@@ -0,0 +1,36 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const root=fileURLToPath(new URL('..',import.meta.url));
+const binary=path.join(root,'bin','deadbyte-owner-token-r193.exe');
+
+test('R193 native observer reports target process token and kernel creation identity',()=>{
+ const result=spawnSync(binary,['--inspect-pid',String(process.pid)],{
+  cwd:root,encoding:'utf8',windowsHide:true,timeout:10000,maxBuffer:256*1024});
+ assert.equal(result.status,0,result.stderr);
+ const report=JSON.parse(result.stdout);
+ assert.equal(report.schema,'deadbyte.r193-native-process-token.v1');
+ assert.equal(report.pid,process.pid);
+ assert.equal(report.alive,true);
+ assert.equal(report.identity_verified,true);
+ assert.match(report.creation_filetime_hex,/^[0-9a-f]{16}$/);
+ assert.equal(typeof report.elevated,'boolean');
+ assert.equal(typeof report.admin_enabled,'boolean');
+ assert.ok(Number.isSafeInteger(report.integrity_rid));
+ assert.equal(report.token_type,'primary');
+ assert.equal(report.owner_approved,false);
+ assert.equal(report.authority_granted,false);
+});
+
+test('R193 native observer rejects missing, malformed and nonexistent target PIDs',()=>{
+ for(const args of [['--inspect-pid'],['--inspect-pid','0'],['--inspect-pid','x'],
+  ['--inspect-pid','2147483647']]){
+  const result=spawnSync(binary,args,{cwd:root,encoding:'utf8',windowsHide:true,
+   timeout:10000,maxBuffer:256*1024});
+  assert.notEqual(result.status,0);
+  assert.doesNotMatch(result.stdout,/"identity_verified":true/);
+ }
+});