deadbyte-mcp 0.15.72 → 0.15.75

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,58 @@
+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.74',
+ release_id:'v0.15.74-e84bf4eed16e9443',
+ manifest_sha256:'e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47',
+ generation_manifest_sha256:'598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7'
+};
+const parentTarball='5da436a3f8068107e74caf6da58ff1e211d4a62f94266853136b601762f36f0c';
+
+test('R206 package identity preserves the R193 owner boundary and separates R205 source from active R194 runtime',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.75');
+ assert.equal(bridge.version,'0.15.75');
+ assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.75'/);
+ assert.equal(release.version,'0.15.75');
+ assert.equal(release.train,'R206');
+ 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.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(provenance.version,'0.15.75');
+ 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.75');
+ assert.equal(provenance.source_predecessor_train,'R205');
+ assert.equal(provenance.source_predecessor_tarball_sha256,null);
+ assert.equal(matrix.version,'0.15.75');
+ assert.equal(matrix.train,'R206');
+ assert.equal(sbom.metadata.component.version,'0.15.75');
+ assert.match(sbom.serialNumber,/r206:0\.15\.75$/);
+});
+
+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/r195-canonical-owner-observation.mjs',
+  '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|$)'));
+});

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

@@ -0,0 +1,87 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {spawnSync} from 'node:child_process';
+import {mkdtemp,mkdir,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {assertR193NpmPublishReady,assertR193PackedIdentity} from '../scripts/npm-release-readiness-r193.mjs';
+
+const sha256=value=>createHash('sha256').update(value).digest('hex');
+const parent={
+  version:'0.15.72',train:'R192',release_id:'v0.15.72-0a5d9436e06e2d9e',
+  manifest_sha256:'0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90',
+  generation_manifest_sha256:'aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0'
+};
+const release={
+  version:'0.15.73',train:'R193',parent,
+  r193:{scope:'PROTECTED_OWNER_AUTHORIZATION_AND_LIMITED_RUNTIME_MIGRATION',public_tool_delta:0,authority_scope_delta:0}
+};
+
+async function fixture(){
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r193-readiness-'));
+  const root=path.join(base,'development','candidate');
+  const evidence=path.join(base,'testing','r193-final-closure');
+  await mkdir(root,{recursive:true});await mkdir(evidence,{recursive:true});
+  const manifest=Buffer.from(`${'a'.repeat(64)}  package.json\n`);
+  await writeFile(path.join(root,'MANIFEST.SHA256'),manifest);
+  const files={
+    'protected-install-receipt.json':JSON.stringify({status:'PASS',package_version:'0.15.73',source_manifest_sha256:sha256(manifest),protected_manifest_sha256:sha256(manifest)}),
+    'windows-focused.stdout.log':'# tests 61\n# suites 0\n# pass 60\n# fail 0\n# cancelled 0\n# skipped 1\nR193_STAGE_PASS=focused\n',
+    'windows-full.stdout.log':'# tests 2187\n# suites 0\n# pass 2136\n# fail 0\n# cancelled 0\n# skipped 51\nR193_STAGE_PASS=full\n',
+    'npm-verify.stdout.log':'Artifact isolation gate PASS\nVERIFIED_TARBALL {"filename":"deadbyte-mcp-0.15.73.tgz","bytes":123,"sha256":"'+ 'b'.repeat(64) +'","integrity":"sha512-test","shasum":"'+ 'c'.repeat(40) +'"}\nVERIFY-ONLY PIPELINE PASS\n'
+  };
+  for(const [name,content] of Object.entries(files))await writeFile(path.join(evidence,name),content);
+  const closure={schema:'deadbyte.r193-release-closure.v1',status:'RELEASE_READY',version:'0.15.73',train:'R193',
+    production_release_id:parent.release_id,production_manifest_sha256:parent.manifest_sha256,
+    production_generation_manifest_sha256:parent.generation_manifest_sha256,
+    manifest_sha256:sha256(manifest),compact_tools:43,full_tools:117,
+    owner_enrollment:'NOT_RUN',limited_runtime_migration:'NOT_RUN',production_activation:'NOT_RUN',
+    protected_receipt_sha256:sha256(files['protected-install-receipt.json']),
+    focused_stdout_sha256:sha256(files['windows-focused.stdout.log']),
+    full_stdout_sha256:sha256(files['windows-full.stdout.log']),
+    verify_stdout_sha256:sha256(files['npm-verify.stdout.log']),
+    tarball_sha256:'b'.repeat(64),tarball_integrity:'sha512-test',tarball_shasum:'c'.repeat(40)};
+  await writeFile(path.join(evidence,'closure.json'),JSON.stringify(closure));
+  return {base,root,evidence,closure,manifest};
+}
+
+test('R193 publication refuses absent external exact-byte closure',async()=>{
+  const f=await fixture();try{
+    await assert.rejects(assertR193NpmPublishReady(release,{root:f.root}),/PUBLISH_BLOCKED R193.*closure root absent/);
+  }finally{await rm(f.base,{recursive:true,force:true});}
+});
+
+test('R193 publication binds final manifest, protected gates, catalogs, and exact tarball',async()=>{
+  const f=await fixture();try{
+    const result=await assertR193NpmPublishReady(release,{root:f.root,closureRoot:f.evidence});
+    assert.equal(result.status,'R193_RELEASE_READY_EVIDENCE_BOUND');
+    assert.equal(result.tests,2187);assert.equal(result.passes,2136);assert.equal(result.skips,51);
+    assert.equal(result.tarball_sha256,'b'.repeat(64));
+  }finally{await rm(f.base,{recursive:true,force:true});}
+});
+
+test('R193 publication rejects final manifest drift and tampered gate evidence',async()=>{
+  const f=await fixture();try{
+    await writeFile(path.join(f.root,'MANIFEST.SHA256'),'changed');
+    await assert.rejects(assertR193NpmPublishReady(release,{root:f.root,closureRoot:f.evidence}),/PUBLISH_BLOCKED R193.*manifest drift/);
+    await writeFile(path.join(f.root,'MANIFEST.SHA256'),f.manifest);
+    await writeFile(path.join(f.evidence,'windows-full.stdout.log'),'tampered');
+    await assert.rejects(assertR193NpmPublishReady(release,{root:f.root,closureRoot:f.evidence}),/PUBLISH_BLOCKED R193.*evidence digest differs/);
+  }finally{await rm(f.base,{recursive:true,force:true});}
+});
+
+test('R193 publisher refuses a repacked artifact that differs from closure bytes',()=>{
+  assert.throws(()=>assertR193PackedIdentity({tarball_sha256:'a'.repeat(64),tarball_integrity:'sha512-expected',tarball_shasum:'b'.repeat(40),
+    observedSha256:'c'.repeat(64),observedIntegrity:'sha512-other',observedShasum:'d'.repeat(40)}),/PUBLISH_BLOCKED R193.*repacked tarball/);
+});
+
+test('canonical npm release entrypoint enforces current R195 closure before registry or pack work',async()=>{
+  const root=fileURLToPath(new URL('..',import.meta.url));
+  const env={...process.env};delete env.DEADBYTE_R193_CLOSURE_ROOT;
+  const result=spawnSync(process.execPath,[path.join(root,'scripts','npm-release-r48.mjs'),'--publish-only'],{cwd:root,env,encoding:'utf8',windowsHide:true});
+  assert.notEqual(result.status,0);
+  assert.match(`${result.stdout}\n${result.stderr}`,/PUBLISH_BLOCKED R206.*closure root absent/);
+  assert.doesNotMatch(`${result.stdout}\n${result.stderr}`,/npm publish|Packing artifact/);
+});

package/test/r193-uac-r70-bridge.test.mjs

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createPublicKey,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 {signR193R70ApprovalFromOwnerReview} from '../src/r193-uac-r70-bridge.mjs';
+
+const h=c=>c.repeat(64);
+async function fixture(){
+ const projectRoot=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r193-owner-'));
+ const now=new Date('2026-10-29T12: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'});
+ return {...expected,request,now,projectRoot,privateKeyDer,pair};
+}
+const cleanup=async x=>rm(x.projectRoot,{recursive:true,force:true});
+const sign=x=>signR193R70ApprovalFromOwnerReview({request:x.request,expected:x,
+  privateKeyDer:x.privateKeyDer,now:new Date(x.now.getTime()+1000)});
+
+test('R193 exact reviewed UAC request yields valid R70 signature without issuing a grant',async()=>{
+ const f=await fixture();
+ try{
+  const result=sign(f);
+  assert.equal(result.status,'PROTECTED_SIGNATURE_FORMAT_ONLY');
+  assert.equal(result.authority_granted,false);
+  assert.equal(result.owner_approved,false);
+  assert.equal(result.approval.subject.expires_at_utc,f.request.subject.expires_at_utc);
+  assert.equal(result.approval.subject.reviewed_artifact_sha256,f.releaseManifestSha256);
+  assert.equal(result.approval.subject.project_root,f.projectRoot);
+  const publicKey=createPublicKey({key:result.owner_public_key_spki_der,format:'der',type:'spki'});
+  const verified=await verifyProjectOwnerApproval({
+   approval:result.approval,ownerPublicKey:publicKey,
+   expected:{rootId:'core',projectRoot:f.projectRoot,
+    codingPolicySha256:f.codingPolicySha256,
+    autonomousPolicySha256:f.autonomousPolicySha256,
+    reviewedArtifactSha256:f.releaseManifestSha256},
+   now:new Date(f.now.getTime()+1000)
+  });
+  assert.equal(verified.approved,true);
+  assert.equal(verified.subject_sha256,result.approval.subject_sha256);
+ }finally{await cleanup(f);}
+});
+
+test('R193 signer refuses drift in machine epoch, release, policy, root and expiry',async()=>{
+ const f=await fixture();
+ try{
+  for(const patch of [
+   {machineEpoch:h('0')},{releaseManifestSha256:h('9')},
+   {codingPolicySha256:h('8')},{autonomousPolicySha256:h('7')},
+   {projectRoot:path.join(f.projectRoot,'nested')},
+  ])assert.throws(()=>signR193R70ApprovalFromOwnerReview({
+   request:f.request,expected:{...f,...patch},
+   privateKeyDer:f.privateKeyDer,now:f.now
+  }),/R188/);
+  assert.throws(()=>signR193R70ApprovalFromOwnerReview({
+   request:f.request,expected:f,privateKeyDer:f.privateKeyDer,
+   now:new Date(f.now.getTime()+120000)
+  }),/expired/i);
+ }finally{await cleanup(f);}
+});
+
+test('R193 signer refuses bad signing material and changed reviewed request',async()=>{
+ const f=await fixture();
+ try{
+  assert.throws(()=>signR193R70ApprovalFromOwnerReview({request:f.request,expected:f,privateKeyDer:Buffer.alloc(32),now:f.now}),
+   /R193.*key/);
+  assert.throws(()=>signR193R70ApprovalFromOwnerReview({
+   request:{...f.request,review_phrase:'APPROVE-BADBADBADBAD'},expected:f,privateKeyDer:f.privateKeyDer,now:f.now
+  }),/R188/);
+  const a=sign(f);
+  const wrong=generateKeyPairSync('ed25519').publicKey;
+  await assert.rejects(verifyProjectOwnerApproval({
+   approval:a.approval,ownerPublicKey:wrong,
+   expected:{rootId:'core',projectRoot:f.projectRoot,codingPolicySha256:f.codingPolicySha256,
+    autonomousPolicySha256:f.autonomousPolicySha256,reviewedArtifactSha256:f.releaseManifestSha256},
+   now:f.now
+  }),/identity mismatch/);
+ }finally{await cleanup(f);}
+});

package/test/r193-windows-gate.test.mjs

@@ -0,0 +1,30 @@
+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('R206 Windows gate is the canonical exact-identity prepublication gate',async()=>{
+ const [pkg,gate]=await Promise.all([
+  readFile(path.join(root,'package.json'),'utf8').then(JSON.parse),
+  readFile(path.join(root,'scripts','gate-windows-r206.ps1'),'utf8')
+ ]);
+ assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r206.ps1 -Stage all');
+ assert.match(gate,/0\.15\.75/);
+ assert.match(gate,/R206/);
+ assert.match(gate,/v0\.15\.74-e84bf4eed16e9443/);
+ assert.match(gate,/e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47/);
+ assert.match(gate,/598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7/);
+ assert.match(gate,/test\/r193-release-identity\.test\.mjs/);
+ assert.match(gate,/test\/r193-release-readiness\.test\.mjs/);
+ assert.match(gate,/test\/r193-owner-uac-broker\.test\.mjs/);
+ assert.match(gate,/test\/r70-owner-approval\.test\.mjs/);
+ assert.match(gate,/test\/r89-privileged-install-boundary\.test\.mjs/);
+ assert.match(gate,/DEADBYTE_TEST_CROSS_VOLUME_ROOT/);
+ assert.match(gate,/DEADBYTE_STATE_ROOT/);
+ assert.match(gate,/scripts\/release-manifest\.mjs','verify/);
+ assert.doesNotMatch(gate,/arm(process|coding|autonomous|desktop|host)/i);
+ assert.doesNotMatch(gate,/deploy|activate|npm publish/i);
+});

package/test/r194-npm-auth-recovery.test.mjs

@@ -0,0 +1,77 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,readFile,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {reconcileNpmPublication} from '../scripts/npm-publication-r65.mjs';
+import {classifyNpmPublishFailure} from '../scripts/npm-interactive-r194.mjs';
+
+const bytes=Buffer.from('r194 immutable npm artifact');
+const version='0.15.74';
+const manifestSha256='d'.repeat(64);
+const sha=name=>createHash(name).update(bytes).digest(name==='sha512'?'base64':'hex');
+const published={version,dist:{integrity:`sha512-${sha('sha512')}`,shasum:sha('sha1'),tarball:`https://registry.npmjs.org/deadbyte-mcp/-/deadbyte-mcp-${version}.tgz`}};
+
+async function fixture(run){
+ const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r194-auth-'));
+ try{return await run(path.join(root,'publication'));}finally{await rm(root,{recursive:true,force:true});}
+}
+
+function options(recordPath,overrides={}){
+ return {recordPath,version,manifestSha256,localBytes:bytes,timeoutMs:0,pollMs:1,
+  publish:async()=>{},lookup:async()=>null,tags:async()=>({latest:version}),fetchTarball:async()=>bytes,sleep:async()=>{},...overrides};
+}
+
+test('R194 classifies npm permission responses as authentication rejection without hiding transport ambiguity',()=>{
+ assert.equal(classifyNpmPublishFailure({exitCode:1,output:'npm error code E401\nnpm error 401 Unauthorized'}),'EAUTH');
+ assert.equal(classifyNpmPublishFailure({exitCode:1,output:'npm error 404 Not Found - PUT https://registry.npmjs.org/deadbyte-mcp - Not found\nThe requested resource could not be found or you do not have permission to access it.'}),'EAUTH');
+ assert.equal(classifyNpmPublishFailure({exitCode:1,output:'npm error code ECONNRESET\nnetwork socket disconnected'}),'OUTCOME_UNKNOWN');
+});
+
+test('R194 retries one definitively auth-rejected publication only after exact owner authentication',()=>fixture(async recordPath=>{
+ let publishes=0,authenticated=false,visible=false;
+ const base=options(recordPath,{
+  publish:async()=>{publishes++;if(!authenticated)throw Object.assign(new Error('permission rejected'),{code:'EAUTH'});visible=true;},
+  lookup:async()=>visible?published:null,
+  authorizeAuthRetry:async subject=>authenticated&&subject.version===version&&subject.tarball_sha256===sha('sha256')
+ });
+ assert.equal((await reconcileNpmPublication(base)).state,'AUTH_REQUIRED');
+ assert.equal((await reconcileNpmPublication(base)).state,'AUTH_REQUIRED');
+ assert.equal(publishes,1);
+ authenticated=true;
+ assert.equal((await reconcileNpmPublication(base)).state,'REGISTRY_IDENTITY_VERIFIED');
+ assert.equal(publishes,2);
+ const fs=await import('node:fs/promises');
+ const events=await Promise.all((await fs.readdir(recordPath)).filter(n=>n.startsWith('event-')).map(n=>fs.readFile(path.join(recordPath,n),'utf8').then(JSON.parse)));
+ assert.equal(events.filter(e=>e.state==='AUTH_RETRY_STARTED').length,1);
+ assert.equal(events.filter(e=>e.state==='SUBMISSION_ACCEPTED').length,1);
+ assert.match(await readFile(path.join(recordPath,'auth-retry-claim.json'),'utf8'),/0\.15\.74/);
+}));
+
+test('R194 never retries an ambiguous publication even after authentication becomes available',()=>fixture(async recordPath=>{
+ let publishes=0;
+ const base=options(recordPath,{publish:async()=>{publishes++;throw Object.assign(new Error('connection lost'),{code:'ECONNRESET'});},authorizeAuthRetry:async()=>true});
+ assert.equal((await reconcileNpmPublication(base)).state,'OUTCOME_UNKNOWN');
+ assert.equal((await reconcileNpmPublication(base)).state,'OUTCOME_UNKNOWN');
+ assert.equal(publishes,1);
+}));
+
+test('R194 auth retry is bounded to one dispatch even when authentication is rejected again',()=>fixture(async recordPath=>{
+ let publishes=0,allow=false;
+ const base=options(recordPath,{publish:async()=>{publishes++;throw Object.assign(new Error('authentication required'),{code:'EAUTH'});},authorizeAuthRetry:async()=>allow});
+ assert.equal((await reconcileNpmPublication(base)).state,'AUTH_REQUIRED');
+ allow=true;
+ assert.equal((await reconcileNpmPublication(base)).state,'AUTH_REQUIRED');
+ assert.equal((await reconcileNpmPublication(base)).state,'AUTH_REQUIRED');
+ assert.equal(publishes,2);
+}));
+
+test('R194 concurrent authenticated resumes dispatch exactly one auth retry',()=>fixture(async recordPath=>{
+ let publishes=0,first=true,visible=false;
+ const base=options(recordPath,{publish:async()=>{publishes++;if(first){first=false;throw Object.assign(new Error('authentication required'),{code:'EAUTH'});}await new Promise(r=>setTimeout(r,10));visible=true;},lookup:async()=>visible?published:null,authorizeAuthRetry:async()=>true,timeoutMs:100,pollMs:1});
+ assert.equal((await reconcileNpmPublication(base)).state,'AUTH_REQUIRED');
+ const results=await Promise.all([reconcileNpmPublication(base),reconcileNpmPublication(base)]);
+ assert.equal(publishes,2);
+ assert.ok(results.some(r=>r.state==='REGISTRY_IDENTITY_VERIFIED'));
+}));

package/test/r194-npm-preauth.test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,readFile,rm,stat} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {reconcileNpmPublication} from '../scripts/npm-publication-r65.mjs';
+
+const buffer=Buffer.from('r194 no dispatch before owner npm authentication');
+const version='0.15.74',manifestSha256='f'.repeat(64);
+const hash=(alg,fmt='hex')=>createHash(alg).update(buffer).digest(fmt);
+const published={version,dist:{integrity:'sha512-'+hash('sha512','base64'),shasum:hash('sha1'),
+ tarball:'https://registry.npmjs.org/deadbyte-mcp/-/deadbyte-mcp-'+version+'.tgz'}};
+const fixture=async fn=>{const tmp=await mkdtemp(path.join(os.tmpdir(),'r194-preauth-'));
+ try{return await fn(path.join(tmp,'publication'));}finally{await rm(tmp,{recursive:true,force:true});}};
+const opts=(recordPath,over={})=>({recordPath,version,manifestSha256,localBytes:buffer,
+ timeoutMs:0,pollMs:1,sleep:async()=>{},publish:async()=>{throw Error('UNAUTHORIZED_DISPATCH');},
+ lookup:async()=>null,tags:async()=>({latest:version}),fetchTarball:async()=>buffer,...over});
+
+test('R194 refuses initial publish without authenticated owner and creates no immutable claim',()=>fixture(async record=>{
+ let publishes=0;
+ const base=opts(record,{authorizePublish:async()=>false,publish:async()=>{publishes++;}});
+ assert.equal((await reconcileNpmPublication(base)).state,'AUTH_REQUIRED');
+ assert.equal(publishes,0);
+ await assert.rejects(stat(path.join(record,'claim.json')),{code:'ENOENT'});
+}));
+
+test('R194 authenticated initial publish uses one exact claim and verifies registry bytes',()=>fixture(async record=>{
+ let publishes=0,seen=false;
+ const base=opts(record,{authorizePublish:async subject=>{
+   assert.equal(subject.version,version);
+   assert.equal(subject.tarball_sha256,hash('sha256'));
+   assert.equal(subject.manifest_sha256,manifestSha256);
+   return true;
+ },publish:async()=>{publishes++;seen=true;},lookup:async()=>seen?published:null});
+ assert.equal((await reconcileNpmPublication(base)).state,'REGISTRY_IDENTITY_VERIFIED');
+ assert.equal((await reconcileNpmPublication(base)).state,'REGISTRY_IDENTITY_VERIFIED');
+ assert.equal(publishes,1);
+ assert.equal(JSON.parse(await readFile(path.join(record,'claim.json'),'utf8')).tarball_sha256,hash('sha256'));
+}));
+
+test('R194 owner-auth callback exception fails closed before immutable claim',()=>fixture(async record=>{
+ let publishes=0;
+ const result=await reconcileNpmPublication(opts(record,{authorizePublish:async()=>{throw Error('npm E401');},publish:async()=>{publishes++;}}));
+ assert.equal(result.state,'AUTH_REQUIRED');
+ assert.equal(publishes,0);
+ await assert.rejects(stat(path.join(record,'claim.json')),{code:'ENOENT'});
+}));
+
+test('R194 never replays claim with unknown original submission even after fresh authentication',()=>fixture(async record=>{
+ let publishes=0;
+ const base=opts(record,{publish:async()=>{publishes++;throw Object.assign(new Error('socket lost'),{code:'ECONNRESET'});}});
+ assert.equal((await reconcileNpmPublication(base)).state,'OUTCOME_UNKNOWN');
+ assert.equal((await reconcileNpmPublication({...base,authorizeAuthRetry:async()=>true})).state,'OUTCOME_UNKNOWN');
+ assert.equal(publishes,1);
+ await assert.rejects(stat(path.join(record,'auth-retry-claim.json')),{code:'ENOENT'});
+}));