deadbyte-mcp 0.15.71 → 0.15.74

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

@@ -13,8 +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.68');
- assert.equal(release.parent.version,'0.15.68');
+ assert.equal(release.runtime_predecessor.version,'0.15.72');
+ assert.equal(release.parent.version,'0.15.72');
+ assert.equal(release.runtime_predecessor.release_id,'v0.15.72-0a5d9436e06e2d9e');
+ assert.equal(release.parent.release_id,'v0.15.72-0a5d9436e06e2d9e');
  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.71');
-  assert.equal(release.train,'R191'); assert.equal(matrix.train,'R191');
-  assert.equal(release.source_predecessor.version,'0.15.70');
-  assert.equal(release.source_predecessor.manifest_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
-  assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
-  assert.equal(release.runtime_predecessor.release_id,'v0.15.68-ff29dbb2fbb89862');
+  for(const value of versions)assert.equal(value,'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.manifest_sha256,'e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd');
+  assert.equal(release.source_predecessor.tarball_sha256,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.72-0a5d9436e06e2d9e');
   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.71');
-  assert.equal(lock.version,'0.15.71');
-  assert.equal(lock.packages[''].version,'0.15.71');
-  assert.equal(bridge.version,'0.15.71');
-  assert.equal(release.version,'0.15.71');
-  assert.equal(release.train,'R191');
-  assert.equal(matrix.version,'0.15.71');
-  assert.equal(matrix.train,'R191');
-  assert.equal(sbom.metadata.component.version,'0.15.71');
-  assert.equal(release.source_predecessor.version,'0.15.70');
-  assert.equal(release.source_predecessor.train,'R190');
-  assert.equal(release.source_predecessor.manifest_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
-  assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
-  assert.equal(release.runtime_predecessor.version,'0.15.68');
-  assert.equal(provenance.version,'0.15.71');
-  assert.equal(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
+  assert.equal(pkg.version,'0.15.74');
+  assert.equal(lock.version,'0.15.74');
+  assert.equal(lock.packages[''].version,'0.15.74');
+  assert.equal(bridge.version,'0.15.74');
+  assert.equal(release.version,'0.15.74');
+  assert.equal(release.train,'R194');
+  assert.equal(matrix.version,'0.15.74');
+  assert.equal(matrix.train,'R194');
+  assert.equal(sbom.metadata.component.version,'0.15.74');
+  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(release.runtime_predecessor.version,'0.15.72');
+  assert.equal(provenance.version,'0.15.74');
+  assert.equal(provenance.parent_tarball_sha256,'15ab5d9808cbca342aee3f64c6d1123e8fbb72964674eab460e355c8675bf84d');
   assert.equal(provenance.source_predecessor_manifest_file_sha256,release.source_predecessor.manifest_sha256);
 });

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

@@ -7,26 +7,26 @@ 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.68-ff29dbb2fbb89862';
-const manifest='ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885';
-const generation='2887d4a8d54ea6fc6b28869072f72491c892dfe28178b3537936dce958147bd2';
+const parent='v0.15.72-0a5d9436e06e2d9e';
+const manifest='0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90';
+const generation='aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0';
 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.71');
- assert.equal(release.train,'R191');assert.equal(matrix.train,'R191');
- assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r191:0.15.71');
+  matrix.version,sbom.metadata.component.version,DEADBYTE_VERSION])assert.equal(version,'0.15.74');
+ assert.equal(release.train,'R194');assert.equal(matrix.train,'R194');
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r194:0.15.74');
  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.70');
- assert.equal(release.source_predecessor.manifest_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
- assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
+ 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(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.parent_tarball_sha256,'15ab5d9808cbca342aee3f64c6d1123e8fbb72964674eab460e355c8675bf84d');
  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
 });
 test('R179 does not misrepresent owner Autonomous enrollment, protected regression or publication as finished',async()=>{
@@ -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.70');
+ assert.equal(release.source_predecessor.version,'0.15.73');
  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.71');
- assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.71'/);
- assert.equal(release.train,'R191');assert.equal(matrix.train,'R191');
- assert.equal(release.source_predecessor.version,'0.15.70');
- assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
- assert.equal(release.source_predecessor.manifest_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
- assert.equal(release.runtime_predecessor.version,'0.15.68');
- assert.equal(release.runtime_predecessor.release_id,'v0.15.68-ff29dbb2fbb89862');
- assert.equal(provenance.source_predecessor_version,'0.15.70');
+  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,/r191:0\.15\.71$/);
+ 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.68-ff29dbb2fbb89862';
-const publishedManifest='df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3';
-const publishedTarball='1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e';
+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.71');
- for(const train of [release.train,matrix.train])assert.equal(train,'R191');
- assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r191:0.15.71');
+ 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.70');
- assert.equal(release.source_predecessor.manifest_sha256,publishedManifest);
- assert.equal(release.source_predecessor.tarball_sha256,publishedTarball);
- assert.equal(provenance.source_predecessor_version,'0.15.70');
+ 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-live-log-hardening.test.mjs

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {formatRuntimeDiagnosticLine,createLiveTimelineTracker,
+  pruneLiveLogReaders} from '../src/remote-live-log.mjs';
+
+const compact=(reason)=>'[TOOL] 2026-10-28T14:00:00.000Z #12 ✗ coding_command_run 10ms — '+reason;
+
+test('R192 runtime verbose diagnostics never disclose secret-bearing reasons',()=>{
+  const raw=compact('password=canaryNotForConsole123');
+  const out=formatRuntimeDiagnosticLine('bridge.stdout.log',raw,{verbose:true,displayMode:'ascii'});
+  assert.equal(typeof out,'string');
+  assert.match(out,/coding_command_run/);
+  assert.match(out,/REDACTED/);
+  assert.doesNotMatch(out,/canaryNotForConsole123/);
+  assert.equal(formatRuntimeDiagnosticLine('bridge.stdout.log',raw,{verbose:false}),null);
+});
+
+test('R192 runtime diagnostic detail is short, single-line and status-preserving',()=>{
+  const out=formatRuntimeDiagnosticLine('bridge.stdout.log',compact('slow write rejected '+('x'.repeat(800))),{verbose:true,displayMode:'ascii'});
+  assert.match(out,/\[BRIDGE.STDOUT.DEBUG\].*coding_command_run 10ms/);
+  assert.ok(out.length<350,'a single runtime diagnostic cannot flood the foreground');
+  assert.equal(out.split(/\r?\n/).length,1);
+});
+
+test('R192 audit result redacts secrets without hiding outcome classification',()=>{
+  const tracker=createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  tracker.observe({event_type:'tool.request',request_id:'123456789012',tool:'host_exec',args:{root_id:'core',mode:'native'}});
+  const out=tracker.observe({event_type:'tool.result',request_id:'123456789012',tool:'host_exec',
+    outcome:{status:'denied',is_error:true,duration_ms:24,reason:'authorization: Bearer supersensitive123456'}});
+  assert.match(out,/ERR/);
+  assert.doesNotMatch(out,/supersensitive123456/);
+  assert.match(out,/REDACTED/);
+});
+
+test('R192 rotation prunes stale cursors and partial line fragments without touching current streams',()=>{
+  const live=new Map([['current.log',{offset:12}],['gone.log',{offset:77}]]);
+  const fragments=new Map([['current.log','half'],['gone.log','secret']]);
+  const result=pruneLiveLogReaders(live,fragments,['current.log','other.log']);
+  assert.deepEqual(result,{cursors_removed:1,fragments_removed:1});
+  assert.deepEqual([...live.keys()],['current.log']);
+  assert.deepEqual([...fragments], [['current.log','half']]);
+});
+
+test('R192 reject malformed discovery before mutating any reader state',()=>{
+  const live=new Map([['current.log',{offset:12}]]);
+  const fragments=new Map([['current.log','half']]);
+  assert.throws(()=>pruneLiveLogReaders(live,fragments,[123]),/invalid/i);
+  assert.equal(live.has('current.log'),true);
+  assert.equal(fragments.get('current.log'),'half');
+});

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

@@ -0,0 +1,40 @@
+import test from 'node:test';import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';import {createHash} from 'node:crypto';import path from 'node:path';import {fileURLToPath} from 'node:url';
+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='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.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,'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');
+ assert.equal(release.r192.public_tool_schema_changed,false);
+ assert.equal(release.r192.authority_grants_changed,false);
+});
+test('R192 foreground reader enforces caller-safe telemetry rather than changing authority',async()=>{
+ const [cli,log]=await Promise.all([
+ readFile(path.join(root,'src','deadbyte-cli.mjs'),'utf8'),
+ readFile(path.join(root,'src','remote-live-log.mjs'),'utf8')]);
+ assert.match(cli,/pruneLiveLogReaders\(activeOffsets,partialLines,liveFiles\)/);
+ assert.match(log,/export function pruneLiveLogReaders/);
+ assert.match(log,/sanitizeAuditArgs\(compact\[6\]\)/);
+ const [policy,release]=await Promise.all([
+ read('controller/deadbyte-process-policy.json'),read('RELEASE.json')]);
+ 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);}
+});