deadbyte-mcp 0.15.72 → 0.15.74

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.74');
+ assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.74'/);
+ assert.equal(release.train,'R194');assert.equal(matrix.train,'R194');
+ assert.equal(release.source_predecessor.version,'0.15.73');
+ assert.equal(release.source_predecessor.tarball_sha256,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
+ assert.equal(release.source_predecessor.manifest_sha256,'e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd');
+ assert.equal(release.runtime_predecessor.version,'0.15.72');
+ assert.equal(release.runtime_predecessor.release_id,'v0.15.72-0a5d9436e06e2d9e');
+ assert.equal(provenance.source_predecessor_version,'0.15.73');
  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
- assert.match(sbom.serialNumber,/r192:0\.15\.72$/);
+ assert.match(sbom.serialNumber,/r194:0\.15\.74$/);
 });
 
 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.72-0a5d9436e06e2d9e';
+const publishedManifest='0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90';
+const publishedTarball='15ab5d9808cbca342aee3f64c6d1123e8fbb72964674eab460e355c8675bf84d';
 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.74');
+ for(const train of [release.train,matrix.train])assert.equal(train,'R194');
+ assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r194:0.15.74');
  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.73');
+ assert.equal(release.source_predecessor.manifest_sha256,'e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd');
+ assert.equal(release.source_predecessor.tarball_sha256,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
+ assert.equal(provenance.source_predecessor_version,'0.15.73');
  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,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
+ assert.equal(provenance.source_predecessor_manifest_file_sha256,'e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd');
  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='0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90';
+const prevTar='15ab5d9808cbca342aee3f64c6d1123e8fbb72964674eab460e355c8675bf84d';
+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.74');
+ assert.equal(release.train,'R194');assert.equal(matrix.train,'R194');
+ assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r194:0.15.74');
+ assert.equal(release.parent.release_id,'v0.15.72-0a5d9436e06e2d9e');
  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,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
+ assert.equal(release.source_predecessor.manifest_sha256,'e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd');
  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.r194.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/);
+ }
+});

package/test/r193-native-token.test.mjs

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+import {existsSync,readFileSync} from 'node:fs';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const root=fileURLToPath(new URL('..',import.meta.url));
+const file=path.join(root,'bin','deadbyte-owner-token-r193.exe');
+const binarySha='d554d732872f3d671fd2fb63c11fc0dac1f8cae377259c6d64dd0c5b3762f2b8';
+const sha=x=>createHash('sha256').update(x).digest('hex');
+const onlyWindows={skip:process.platform!=='win32'?'Windows token ABI required':false};
+
+test('R193 native token inspection reports observed privilege, but never owner consent',onlyWindows,()=>{
+ assert.ok(existsSync(file),'compile R193 native Windows token gate before testing');
+ assert.equal(sha(readFileSync(file)),binarySha);
+ const result=spawnSync(file,['--report'],{encoding:'utf8',shell:false,timeout:10000});
+ assert.equal(result.status,0,result.stderr);
+ const v=JSON.parse(result.stdout);
+ assert.equal(v.schema,'deadbyte.r193-native-token.v1');
+ assert.equal(v.parent_independence_verified,false);
+ assert.equal(v.owner_approved,false);
+ assert.equal(v.authority_granted,false);
+ assert.equal(v.token_type,1);
+ const elevated=v.elevated||v.admin_enabled||v.integrity_rid>=12288;
+ assert.equal(v.status,elevated?'BLOCKED':'STANDARD_TOKEN_OBSERVED');
+});
+
+test('R193 native --require-standard denies elevated processes and honors limited tokens',onlyWindows,()=>{
+ const raw=spawnSync(file,['--require-standard'],{encoding:'utf8',shell:false,timeout:10000});
+ const v=JSON.parse(raw.stdout);
+ assert.equal(raw.status,v.status==='STANDARD_TOKEN_OBSERVED'?0:3,raw.stderr);
+ assert.equal(v.owner_approved,false);
+ assert.equal(v.authority_granted,false);
+});
+
+test('R193 native gate does not expose any grant subcommand',onlyWindows,()=>{
+ const raw=spawnSync(file,['--grant'],{encoding:'utf8',shell:false,timeout:10000});
+ assert.equal(raw.status,64);
+ assert.match(raw.stderr,/usage:/i);
+ assert.equal(raw.stdout,'');
+});

package/test/r193-owner-enrollment-entrypoint.test.mjs

@@ -0,0 +1,38 @@
+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('R193 one-time enrollment has fixed owner path, no key export and no grant operation',async()=>{
+ const keygen=await readFile(path.join(root,'scripts','r193-owner-keygen.mjs'),'utf8');
+ const installer=await readFile(path.join(root,'scripts','r193-owner-uac-enroll-and-approve.ps1'),'utf8');
+ assert.match(keygen,/const OWNER='C:\\\\Program Files\\\\DEADBYTE-OwnerAuthority'/);
+ assert.match(keygen,/process\.argv\.length!==2/);
+ assert.match(keygen,/private_key_exported:false/);
+ assert.doesNotMatch(keygen,/issueR186AutonomousGrant|createAuthorityEpochStore|Arm-Autonomous|armautonomous/i);
+ assert.match(installer,/#requires -RunAsAdministrator/);
+ assert.match(installer,/SetAccessRuleProtection\(\$true,\$false\)/);
+ assert.doesNotMatch(installer,/BuiltinUsers|S-1-5-32-545|Users.*Read/i);
+ assert.match(installer,/FileMode\]::CreateNew/);
+ assert.match(installer,/Read-Host/);
+ assert.doesNotMatch(installer,/Start-Process.*-Verb\s+RunAs/i);
+});
+test('R193 keygen refuses mutable development bytes before creating owner material',async t=>{
+ let trusted=false;
+ try{
+  trusted=(await inspectTrustedInstallation(privilegedEpochInstallFiles(root,process.execPath))).trusted===true;
+ }catch{}
+ if(trusted){
+  t.skip('protected installation: executing keygen would cross the owner-enrollment boundary');
+  return;
+ }
+ const cli=path.join(root,'scripts','r193-owner-keygen.mjs');
+ const result=spawnSync(process.execPath,[cli],{cwd:root,encoding:'utf8',windowsHide:true,
+  timeout:20000,maxBuffer:256*1024});
+ assert.equal(result.status,2);
+ assert.match(result.stderr,/R89 privileged installation not protected|R193/i);
+ assert.equal(result.stdout,'');
+});

package/test/r193-owner-secret-acl.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {evaluateR193OwnerSecretAcl} from '../src/r193-owner-secret-acl.mjs';
+const admin='S-1-5-32-544',system='S-1-5-18',users='S-1-5-32-545';
+const files=['C:\\Program Files\\DEADBYTE-OwnerAuthority','C:\\Program Files\\DEADBYTE-OwnerAuthority\\owner-private.der'];
+const records=()=>[
+ {path:files[0],owner:admin,reparse:false,protected:true,directory:true,
+  aces:[{sid:admin,type:'Allow',mask:0x1f01ff,inherited:false},{sid:system,type:'Allow',mask:0x1f01ff,inherited:false}]},
+ {path:files[1],owner:admin,reparse:false,protected:true,directory:false,
+  aces:[{sid:admin,type:'Allow',mask:0x1f01ff,inherited:false},{sid:system,type:'Allow',mask:0x1f01ff,inherited:false}]}
+];
+test('R193 owner secret ACL accepts only protected Administrator and SYSTEM access',()=>{
+ assert.deepEqual(evaluateR193OwnerSecretAcl(records(),files),
+  {trusted:true,reason:'OWNER_SECRET_ADMIN_SYSTEM_ONLY'});
+});
+test('R193 owner secret ACL rejects Users read, inheritance, reparse and wrong owner',()=>{
+ const cases=[
+  x=>x[1].aces.push({sid:users,type:'Allow',mask:0x120089,inherited:false}),
+  x=>x[1].aces[0].inherited=true,x=>x[0].reparse=true,x=>x[0].owner=users
+ ];
+ for(const mutate of cases){const value=records();mutate(value);
+  assert.equal(evaluateR193OwnerSecretAcl(value,files).trusted,false);}
+});

package/test/r193-owner-uac-broker.test.mjs

@@ -0,0 +1,82 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync} from 'node:crypto';
+import {mkdtemp,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {createR188OwnerUacRequest} from '../src/r188-owner-uac.mjs';
+import {verifyProjectOwnerApproval} from '../src/r70-owner-approval.mjs';
+import {approveR193OwnerRequest} from '../src/r193-owner-uac-broker.mjs';
+
+const h=c=>c.repeat(64);
+async function fixture(){
+ const projectRoot=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r193-broker-'));
+ const now=new Date('2026-10-29T08:00:00.000Z');
+ const expected={machineEpoch:h('e'),releaseManifestSha256:h('a'),
+  codingPolicySha256:h('b'),autonomousPolicySha256:h('c'),
+  rootId:'core',projectRoot,maxSeconds:600};
+ const request=createR188OwnerUacRequest({...expected,now,expiresInMs:120000});
+ const pair=generateKeyPairSync('ed25519');
+ const privateKeyDer=pair.privateKey.export({format:'der',type:'pkcs8'});
+ const processes=['bridge','core','cloud','supervisor'].map((component,index)=>({
+  component,pid:1000+index,creation_time_utc:`2026-10-29T07:5${index}:00.000Z`,
+  alive:true,identity_verified:true,elevated:false,admin_enabled:false,
+  integrity_rid:8192,token_type:'primary'
+ }));
+ const boundary={schema:'deadbyte.r193-owner-runtime-boundary.v1',
+  broker_r89_trusted:true,key_acl_trusted:true,enable_uac:true,
+  secure_desktop:true,prompt_mode:'explicit_secure_desktop',
+  owner_gesture:'approved',live_epoch_verified:true,live_policies_verified:true,
+  live_release_verified:true,agent_processes:processes};
+ return {projectRoot,now,expected,request,pair,privateKeyDer,boundary};
+}
+const cleanup=f=>rm(f.projectRoot,{recursive:true,force:true});
+const approve=(f,patch={})=>approveR193OwnerRequest({request:f.request,
+ expected:f.expected,privateKeyDer:f.privateKeyDer,
+ boundary:{...f.boundary,...patch},now:new Date(f.now.getTime()+1000)});
+
+test('R193 protected UAC broker signs exact R70 approval only after a fully Limited live boundary',async()=>{
+ const f=await fixture();
+ try{
+  const out=approve(f);
+  assert.equal(out.status,'OWNER_APPROVED_FOR_SINGLE_USE_GRANT');
+  assert.equal(out.authority_granted,false);
+  assert.equal(out.owner_approved,true);
+  assert.equal(out.private_key_material_returned,false);
+  assert.equal(Object.hasOwn(out,'privateKeyDer'),false);
+  assert.equal(out.request_sha256,f.request.request_sha256);
+  const verified=await verifyProjectOwnerApproval({approval:out.approval,
+   ownerPublicKey:out.owner_public_key_pem,expected:{rootId:'core',
+    projectRoot:f.projectRoot,codingPolicySha256:h('b'),
+    autonomousPolicySha256:h('c'),reviewedArtifactSha256:h('a')},
+   now:new Date(f.now.getTime()+1000)});
+  assert.equal(verified.approved,true);
+ }finally{await cleanup(f);}
+});
+
+test('R193 broker refuses any elevated, unverified, missing, duplicate or dead agent process',async()=>{
+ const f=await fixture();
+ try{
+  for(const agent_processes of [
+   f.boundary.agent_processes.map((x,i)=>i?x:{...x,elevated:true,integrity_rid:12288}),
+   f.boundary.agent_processes.map((x,i)=>i?x:{...x,identity_verified:false}),
+   f.boundary.agent_processes.map((x,i)=>i?x:{...x,alive:false}),
+   f.boundary.agent_processes.slice(0,3),
+   [...f.boundary.agent_processes,f.boundary.agent_processes[0]]
+  ])assert.throws(()=>approve(f,{agent_processes}),/R193.*process|Limited|identity/i);
+ }finally{await cleanup(f);}
+});
+
+test('R193 broker refuses untrusted key/package, insecure UAC, absent gesture and live identity drift',async()=>{
+ const f=await fixture();
+ try{
+  for(const patch of [
+   {broker_r89_trusted:false},{key_acl_trusted:false},{enable_uac:false},
+   {secure_desktop:false},{prompt_mode:'silent'},{owner_gesture:'rejected'},
+   {live_epoch_verified:false},{live_policies_verified:false},{live_release_verified:false}
+  ])assert.throws(()=>approve(f,patch),/R193/);
+  assert.throws(()=>approveR193OwnerRequest({request:f.request,
+   expected:{...f.expected,machineEpoch:h('0')},privateKeyDer:f.privateKeyDer,
+   boundary:f.boundary,now:f.now}),/R188|R193/);
+ }finally{await cleanup(f);}
+});

package/test/r193-owner-uac-entrypoint.test.mjs

@@ -0,0 +1,36 @@
+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('R193 owner entrypoint is fixed-scope, protected and exposes no caller-selected key or state root',async()=>{
+ const cli=await readFile(path.join(root,'scripts','r193-owner-uac-broker.mjs'),'utf8');
+ const ps=await readFile(path.join(root,'scripts','r193-owner-uac-approve.ps1'),'utf8');
+ assert.match(cli,/const STATE='C:\\\\Users\\\\DEADBYTE\\\\\.deadbyte-mcp'/);
+ assert.match(cli,/const OWNER='C:\\\\Program Files\\\\DEADBYTE-OwnerAuthority'/);
+ assert.match(cli,/inspectTrustedInstallation/);
+ assert.match(cli,/verifyManifestTreeExact/);
+ assert.match(cli,/inspectR193OwnerSecretAcl/);
+ assert.match(cli,/exactOrWrite/);
+ assert.doesNotMatch(cli,/private-key|owner-dir|state-root/);
+ assert.match(ps,/#requires -RunAsAdministrator/);
+ assert.match(ps,/Read-Host/);
+ assert.doesNotMatch(ps,/Start-Process.*-Verb\s+RunAs/i);
+ assert.doesNotMatch(ps,/armautonomous|authority_granted\s*=\s*\$true/i);
+});
+test('R193 owner entrypoint fails closed before approval when its request is absent',async()=>{
+ let trusted=false;
+ try{
+  trusted=(await inspectTrustedInstallation(privilegedEpochInstallFiles(root,process.execPath))).trusted===true;
+ }catch{}
+ const cli=path.join(root,'scripts','r193-owner-uac-broker.mjs');
+ const result=spawnSync(process.execPath,[cli,'preflight','D:\\missing-request.json'],{
+  cwd:root,encoding:'utf8',windowsHide:true,timeout:20000,maxBuffer:512*1024});
+ assert.equal(result.status,2);
+ if(trusted)assert.match(result.stderr,/ENOENT.*missing-request\.json/i);
+ else assert.match(result.stderr,/R193_OWNER_UAC_BROKER_BLOCKED|R89 privileged installation not protected/i);
+ assert.equal(result.stdout,'');
+});

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

@@ -0,0 +1,56 @@
+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));
+const json=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
+const parent={
+ version:'0.15.72',
+ release_id:'v0.15.72-0a5d9436e06e2d9e',
+ manifest_sha256:'0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90',
+ generation_manifest_sha256:'aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0'
+};
+const parentTarball='15ab5d9808cbca342aee3f64c6d1123e8fbb72964674eab460e355c8675bf84d';
+
+test('R193 package identity binds exact active and published 0.15.72 predecessor',async()=>{
+ const [pkg,bridge,release,provenance,matrix,sbom,versionSource]=await Promise.all([
+  json('package.json'),json('bridge/package.json'),json('RELEASE.json'),json('PROVENANCE.json'),
+  json('TEST-MATRIX.json'),json('SBOM.cdx.json'),readFile(path.join(root,'src','version.mjs'),'utf8')]);
+ assert.equal(pkg.version,'0.15.74');
+ assert.equal(bridge.version,'0.15.74');
+ assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.74'/);
+ assert.equal(release.version,'0.15.74');
+ assert.equal(release.train,'R194');
+ for(const key of Object.keys(parent)){
+  assert.equal(release.parent[key],parent[key]);
+  assert.equal(release.runtime_predecessor[key],parent[key]);
+ }
+ assert.equal(release.source_predecessor.version,'0.15.73');
+ assert.equal(release.source_predecessor.train,'R193');
+ assert.equal(release.source_predecessor.manifest_sha256,'e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd');
+ assert.equal(release.source_predecessor.tarball_sha256,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
+ assert.equal(provenance.version,'0.15.74');
+ assert.equal(provenance.parent_release_id,parent.release_id);
+ assert.equal(provenance.parent_manifest_sha256,parent.manifest_sha256);
+ assert.equal(provenance.parent_generation_manifest_sha256,parent.generation_manifest_sha256);
+ assert.equal(provenance.source_predecessor_version,'0.15.73');
+ assert.equal(provenance.source_predecessor_tarball_sha256,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
+ assert.equal(matrix.version,'0.15.74');
+ assert.equal(matrix.train,'R194');
+ assert.equal(sbom.metadata.component.version,'0.15.74');
+ assert.match(sbom.serialNumber,/r194:0\.15\.74$/);
+});
+
+test('R193 manifest binds every protected owner-boundary implementation file',async()=>{
+ const manifest=await readFile(path.join(root,'MANIFEST.SHA256'),'utf8');
+ for(const file of [
+  'bin/deadbyte-owner-token-r193.exe','native/deadbyte-owner-token-r193.cpp',
+  'scripts/r193-migrate-runtime-limited.ps1','scripts/r193-owner-keygen.mjs',
+  'scripts/r193-owner-request-live.mjs','scripts/r193-owner-uac-approve.ps1',
+  'scripts/r193-owner-uac-broker.mjs','scripts/r193-owner-uac-enroll-and-approve.ps1',
+  'src/r193-live-owner-subject.mjs','src/r193-owner-secret-acl.mjs',
+  'src/r193-owner-uac-broker.mjs','test/r193-release-identity.test.mjs'
+ ]) assert.match(manifest,new RegExp('  '+file.replaceAll('.','\\.')+'(?:\\r?\\n|$)'));
+});