deadbyte-mcp 0.15.72 → 0.15.74

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 R193 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 R194.*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('R194 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-r194.ps1'),'utf8')
+ ]);
+ assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r194.ps1 -Stage all');
+ assert.match(gate,/0\.15\.74/);
+ assert.match(gate,/R194/);
+ assert.match(gate,/v0\.15\.72-0a5d9436e06e2d9e/);
+ assert.match(gate,/0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90/);
+ assert.match(gate,/aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0/);
+ 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'});
+}));

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

@@ -0,0 +1,43 @@
+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 n=>JSON.parse(await readFile(path.join(root,n),'utf8'));
+test('R194 exact release version and predecessor bind active R192 but frozen local R193 source',async()=>{
+ const [pkg,bridge,release,provenance,matrix,sbom,lock,ver]=await Promise.all([
+ json('package.json'),json('bridge/package.json'),json('RELEASE.json'),json('PROVENANCE.json'),
+ json('TEST-MATRIX.json'),json('SBOM.cdx.json'),json('docs/R184-package-lock.json'),
+ readFile(path.join(root,'src','version.mjs'),'utf8')]);
+ for(const v of [pkg.version,bridge.version,release.version,provenance.version,matrix.version,
+ sbom.metadata.component.version,lock.version,lock.packages[''].version])assert.equal(v,'0.15.74');
+ assert.match(ver,/DEADBYTE_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,'v0.15.72-0a5d9436e06e2d9e');
+ assert.equal(release.runtime_predecessor.release_id,release.parent.release_id);
+ assert.equal(release.source_predecessor.version,'0.15.73');
+ assert.equal(release.source_predecessor.train,'R193');
+ assert.equal(release.source_predecessor.release_status,'FROZEN_R193_RELEASE_READY_NOT_PUBLISHED');
+ 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.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+ assert.equal(release.r194.scope,'NPM_AUTH_RECOVERY_AND_OWNER_AUTHORIZATION');
+ assert.equal(release.r194.npm_publish,'NOT_RUN');
+ assert.equal(release.r194.production_activation,'NOT_RUN');
+});
+test('R194 canonical publisher binds R194 readiness before registry/pack effects',async()=>{
+ const [entry,readiness]=await Promise.all([
+ readFile(path.join(root,'scripts/npm-release-r48.mjs'),'utf8'),
+ readFile(path.join(root,'scripts/npm-release-readiness-r194.mjs'),'utf8')]);
+ assert.match(entry,/assertR194NpmPublishReady/);
+ assert.match(entry,/if\(r194Readiness\)assertR194PackedIdentity/);
+ assert.match(entry,/authorizePublish:ownerAuth,authorizeAuthRetry:ownerAuth/);
+ assert.match(entry,/version==='0\.15\.74'/);
+ assert.match(entry,/if \(!publishOnly\)/);
+ assert.match(readiness,/PUBLISH_BLOCKED R194/);
+ assert.match(readiness,/DEADBYTE_R194_CLOSURE_ROOT/);
+ assert.match(readiness,/production_activation/);
+});

package/test/r194-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 {assertR194NpmPublishReady,assertR194PackedIdentity} from '../scripts/npm-release-readiness-r194.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.74',train:'R194',parent,
+  r194:{scope:'NPM_AUTH_RECOVERY_AND_OWNER_AUTHORIZATION',public_tool_delta:0,authority_scope_delta:0}
+};
+
+async function fixture(){
+  const base=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r194-readiness-'));
+  const root=path.join(base,'development','candidate');
+  const evidence=path.join(base,'testing','r194-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.74',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\nR194_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\nR194_STAGE_PASS=full\n',
+    'npm-verify.stdout.log':'Artifact isolation gate PASS\nVERIFIED_TARBALL {"filename":"deadbyte-mcp-0.15.74.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.r194-release-closure.v1',status:'RELEASE_READY',version:'0.15.74',train:'R194',
+    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('R194 publication refuses absent external exact-byte closure',async()=>{
+  const f=await fixture();try{
+    await assert.rejects(assertR194NpmPublishReady(release,{root:f.root}),/PUBLISH_BLOCKED R194.*closure root absent/);
+  }finally{await rm(f.base,{recursive:true,force:true});}
+});
+
+test('R194 publication binds final manifest, protected gates, catalogs, and exact tarball',async()=>{
+  const f=await fixture();try{
+    const result=await assertR194NpmPublishReady(release,{root:f.root,closureRoot:f.evidence});
+    assert.equal(result.status,'R194_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('R194 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(assertR194NpmPublishReady(release,{root:f.root,closureRoot:f.evidence}),/PUBLISH_BLOCKED R194.*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(assertR194NpmPublishReady(release,{root:f.root,closureRoot:f.evidence}),/PUBLISH_BLOCKED R194.*evidence digest differs/);
+  }finally{await rm(f.base,{recursive:true,force:true});}
+});
+
+test('R194 publisher refuses a repacked artifact that differs from closure bytes',()=>{
+  assert.throws(()=>assertR194PackedIdentity({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 R194.*repacked tarball/);
+});
+
+test('canonical npm release entrypoint enforces R194 closure before registry or pack work',async()=>{
+  const root=fileURLToPath(new URL('..',import.meta.url));
+  const env={...process.env};delete env.DEADBYTE_R194_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 R194.*closure root absent/);
+  assert.doesNotMatch(`${result.stdout}\n${result.stderr}`,/npm publish|Packing artifact/);
+});

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

@@ -0,0 +1,21 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const root=fileURLToPath(new URL('..',import.meta.url));
+test('R194 prepublication Windows gate keeps parent pinned and current R194 identity',async()=>{
+ const [pkg,gate]=await Promise.all([
+  readFile(path.join(root,'package.json'),'utf8').then(JSON.parse),
+  readFile(path.join(root,'scripts/gate-windows-r194.ps1'),'utf8')]);
+ assert.equal(pkg.scripts['gate:windows'],
+ 'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r194.ps1 -Stage all');
+ assert.match(gate,/0\.15\.74/);assert.match(gate,/R194/);
+ assert.match(gate,/v0\.15\.72-0a5d9436e06e2d9e/);
+ assert.match(gate,/aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0/);
+ assert.match(gate,/test\/r194-release-identity\.test\.mjs/);
+ assert.match(gate,/test\/r194-npm-auth-recovery\.test\.mjs/);
+ assert.match(gate,/test\/r193-owner-uac-broker\.test\.mjs/);
+ assert.doesNotMatch(gate,/arm(process|coding|autonomous|desktop|host)/i);
+ assert.doesNotMatch(gate,/deploy|activate|npm publish/i);
+});

package/test/r59-tool-surface-compat.test.mjs

@@ -83,7 +83,7 @@ test('R72 compact baseline permits only R64 read offset and authorized coding-on
   assert.deepEqual(diff.added,[]);
   assert.deepEqual(diff.removed,[]);
   const packageVersion=JSON.parse(await readFile(path.join(repoRoot,'package.json'),'utf8')).version;
-  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54','0.15.55','0.15.56','0.15.57','0.15.58','0.15.59','0.15.60','0.15.61','0.15.62','0.15.63','0.15.64','0.15.65','0.15.66','0.15.67','0.15.68','0.15.69','0.15.70','0.15.71','0.15.72'].includes(packageVersion)){
+  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47','0.15.48','0.15.49','0.15.50','0.15.51','0.15.52','0.15.53','0.15.54','0.15.55','0.15.56','0.15.57','0.15.58','0.15.59','0.15.60','0.15.61','0.15.62','0.15.63','0.15.64','0.15.65','0.15.66','0.15.67','0.15.68','0.15.69','0.15.70','0.15.71','0.15.72','0.15.73','0.15.74'].includes(packageVersion)){
     assert.deepEqual([...diff.schema_changed].sort(),['machine_fs','native_diff_preview']);
     assert.equal(diff.unchanged.length,41);
     const prior=baseline.tools.find(tool=>tool.name==='machine_fs');