deadbyte-mcp 0.15.64 → 0.15.66

package/scripts/npm-release-r48.mjs

@@ -10,6 +10,9 @@ import {assertR74NpmPublishReady} from './npm-release-readiness-r74.mjs';
 import {assertR163NpmPublishReady} from './npm-release-readiness-r163.mjs';
 import {assertR165NpmPublishReady} from './npm-release-readiness-r165.mjs';
 import {assertR166NpmPublishReady} from './npm-release-readiness-r166.mjs';
+import {assertR167NpmPublishReady,assertR167PackedIdentity} from './npm-release-readiness-r167.mjs';
+import {assertR168NpmPublishReady,assertR168PackedIdentity} from './npm-release-readiness-r168.mjs';
+import {resumePackRecord} from '../src/npm-publication-resume-r168.mjs';
 import { existsSync } from 'node:fs';
 import { resolveStateRoot } from '../src/state-root.mjs';
 import path from 'node:path';
@@ -110,6 +113,16 @@ async function main() {
     if (!publishOnly) throw new Error('PUBLISH_BLOCKED R166 requires --publish-only; activation is separate');
     await assertR166NpmPublishReady(release,{root});
   }
+  let r167Readiness=null;
+  if (!isVerifyOnly && version==='0.15.65') {
+    if (!publishOnly) throw new Error('PUBLISH_BLOCKED R167 requires --publish-only; activation is separate');
+    r167Readiness=await assertR167NpmPublishReady(release,{root});
+  }
+  let r168Readiness=null;
+  if (!isVerifyOnly && version==='0.15.66') {
+    if (!publishOnly) throw new Error('PUBLISH_BLOCKED R168 requires --publish-only; activation is separate');
+    r168Readiness=await assertR168NpmPublishReady(release,{root});
+  }
   if (release.parent?.release_id !== provenance.parent_release_id ||
       release.parent?.manifest_sha256 !== provenance.parent_manifest_sha256 ||
       release.parent?.generation_manifest_sha256 !== provenance.parent_generation_manifest_sha256) {
@@ -139,8 +152,14 @@ async function main() {
   if(resuming&&!existsSync(preservedTarball))throw new Error('immutable npm publication claim exists but exact local tarball is missing; manual artifact reconciliation required');
   if(!resuming&&preservedTarball&&existsSync(preservedTarball))throw new Error('unclaimed preserved npm tarball exists; inspect artifact evidence before another pack');
   if(!resuming)await assertVacantPackDestination({root,filename:`deadbyte-mcp-${version}.tgz`});
+  const resumeClaim=resuming?JSON.parse(await readFile(path.join(publicationDir,'claim.json'),'utf8')):null;
+  const preservedRecord=resuming?resumePackRecord({
+    filename:path.basename(preservedTarball),localBytes:await readFile(preservedTarball),
+    claim:resumeClaim,version,
+    manifestSha256:createHash('sha256').update(await readFile(path.join(root,'MANIFEST.SHA256'))).digest('hex')
+  }):null;
   const packed=resuming?null:parseJson(runNpm(['pack', '--json'], { timeout: 180000 }));
-  const packRecord=resuming?{filename:path.basename(preservedTarball)}:(Array.isArray(packed) ? packed[0] : packed?.[pkg.name]);
+  const packRecord=resuming?preservedRecord:(Array.isArray(packed) ? packed[0] : packed?.[pkg.name]);
   const filename = packRecord?.filename;
   if (!filename) throw new Error('npm pack did not return a tarball filename');
   const tarball = resuming?preservedTarball:path.join(root, filename);
@@ -151,8 +170,11 @@ async function main() {
   try {
     console.log('[4/7] Verifying packed artifact file surface against MANIFEST.SHA256 and packaging contract...');
     const manifestText = await readFile(path.join(root, 'MANIFEST.SHA256'), 'utf8');
-    const claimData = resuming ? JSON.parse(await readFile(path.join(publicationDir, 'claim.json'), 'utf8')) : null;
-    const manifestSha256 = resuming ? claimData.manifest_sha256 : createHash('sha256').update(manifestText).digest('hex');
+    const claimData = resumeClaim;
+    const currentManifestSha256 = createHash('sha256').update(manifestText).digest('hex');
+    if(resuming&&claimData.manifest_sha256!==currentManifestSha256)
+      throw new Error('immutable npm resume claim manifest changed during artifact verification');
+    const manifestSha256 = resuming ? claimData.manifest_sha256 : currentManifestSha256;
     const manifestEntries = new Set();
     for (const line of manifestText.split(/\r?\n/)) {
       if (!line) continue;
@@ -232,6 +254,14 @@ async function main() {
     const localBytes = await readFile(publishTarball);
     const localIntegrity=`sha512-${createHash('sha512').update(localBytes).digest('base64')}`;
     if(packRecord.integrity&&packRecord.integrity!==localIntegrity)throw new Error('npm packed artifact integrity changed before publication');
+    if(r167Readiness)assertR167PackedIdentity({
+      ...r167Readiness,observedSha256:createHash('sha256').update(localBytes).digest('hex'),
+      observedIntegrity:localIntegrity,observedShasum:packRecord.shasum
+    });
+    if(r168Readiness)assertR168PackedIdentity({
+      ...r168Readiness,observedSha256:createHash('sha256').update(localBytes).digest('hex'),
+      observedIntegrity:localIntegrity,observedShasum:packRecord.shasum
+    });
 
     console.log('[6/7] Publishing artifact to npm registry...');
     publishAttempted = true;

package/scripts/npm-release-readiness-r167.mjs

@@ -0,0 +1,70 @@
+import {createHash} from 'node:crypto';
+import {lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const hex=value=>typeof value==='string'&&/^[0-9a-f]{64}$/.test(value);
+const required=(value,message)=>{if(!value)throw new Error(`PUBLISH_BLOCKED R167 ${message}`);};
+
+async function checkedFile(file,expected,{maxBytes=32*1024*1024}={}){
+  required(hex(expected),'evidence digest missing');
+  const info=await lstat(file);
+  required(info.isFile()&&!info.isSymbolicLink()&&info.size>0&&info.size<maxBytes,'evidence file invalid');
+  const bytes=await readFile(file);
+  required(sha256(bytes)===expected,'evidence digest differs');
+  return bytes;
+}
+
+export function assertR167PackedIdentity({
+  tarball_sha256,tarball_integrity,tarball_shasum,
+  observedSha256,observedIntegrity,observedShasum
+}={}){
+  required(hex(tarball_sha256)&&typeof tarball_integrity==='string'&&tarball_integrity.startsWith('sha512-')&&
+    typeof tarball_shasum==='string'&&/^[0-9a-f]{40}$/.test(tarball_shasum),'verified tarball identity invalid');
+  required(observedSha256===tarball_sha256&&observedIntegrity===tarball_integrity&&observedShasum===tarball_shasum,
+    'repacked tarball differs from verified closure bytes');
+  return true;
+}
+
+export async function assertR167NpmPublishReady(release,{root}={}){
+  required(release?.version==='0.15.65'&&release?.train==='R167'&&
+    release?.r167?.scope==='TRUSTED_EPOCH_ACTIVATION_ENTRYPOINT_AND_EXPLICIT_ROOT_FORWARDING',
+    'candidate metadata invalid');
+  required(release?.parent?.release_id==='v0.15.61-055d1ff0aa99e60b'&&
+    release?.source_predecessor?.version==='0.15.64'&&release?.source_predecessor?.train==='R166',
+    'lineage mismatch');
+  const evidence=process.env.DEADBYTE_R167_CLOSURE_ROOT;
+  required(root&&path.isAbsolute(root)&&evidence&&path.isAbsolute(evidence),'closure root absent');
+  const allowed=path.resolve(root,'..','..','testing','r167-final-gate-final');
+  required(path.resolve(evidence).toLowerCase()===allowed.toLowerCase(),'closure root not in scoped testing folder');
+  const closure=JSON.parse(await readFile(path.join(evidence,'closure.json'),'utf8'));
+  required(closure?.schema==='deadbyte.r167-release-closure.v1'&&closure.status==='PASS'&&closure.version==='0.15.65',
+    'closure status mismatch');
+  required(closure.production_release_id===release.parent.release_id&&hex(closure.manifest_sha256),'predecessor or manifest invalid');
+  required(closure.manifest_sha256===sha256(await readFile(path.join(root,'MANIFEST.SHA256'))),'final manifest drift');
+
+  const receiptBytes=await checkedFile(path.join(evidence,'protected-install-receipt.json'),closure.protected_receipt_sha256);
+  const receipt=JSON.parse(receiptBytes.toString('utf8'));
+  required(receipt?.status==='PASS'&&receipt.package_version==='0.15.65'&&
+    receipt.source_manifest_sha256===closure.manifest_sha256&&receipt.protected_manifest_sha256===closure.manifest_sha256,
+    'protected exact-byte receipt mismatch');
+
+  const focused=(await checkedFile(path.join(evidence,'windows-focused.stdout.log'),closure.focused_stdout_sha256)).toString('utf8');
+  const full=(await checkedFile(path.join(evidence,'windows-full.stdout.log'),closure.full_stdout_sha256)).toString('utf8');
+  const verify=(await checkedFile(path.join(evidence,'npm-verify.stdout.log'),closure.verify_stdout_sha256)).toString('utf8');
+  required(focused.includes('R167_STAGE_PASS=focused')&&focused.includes('# fail 0'),'focused protected gate incomplete');
+  required(full.includes('R167_STAGE_PASS=full')&&full.includes('# fail 0'),'full protected gate incomplete');
+  const summaries=[...full.matchAll(/^# tests (\d+)\s*\r?\n# suites (\d+)\s*\r?\n# pass (\d+)\s*\r?\n# fail (\d+)\s*\r?\n# cancelled (\d+)\s*\r?\n# skipped (\d+)/gm)];
+  required(summaries.length>0,'full TAP summary absent');
+  const final=summaries.at(-1),tests=Number(final[1]),passes=Number(final[3]),fails=Number(final[4]),skips=Number(final[6]);
+  required(tests>=1971&&passes>=1921&&fails===0&&skips<=50&&passes+skips===tests,'full regression count mismatch');
+  required(verify.includes('VERIFY-ONLY PIPELINE PASS')&&verify.includes('Artifact isolation gate PASS')&&verify.includes('VERIFIED_TARBALL '),
+    'npm exact-artifact verification incomplete');
+  const line=verify.split(/\r?\n/).find(value=>value.startsWith('VERIFIED_TARBALL '));
+  let artifact;try{artifact=JSON.parse(line.slice('VERIFIED_TARBALL '.length));}catch{required(false,'tarball evidence malformed');}
+  required(artifact.filename==='deadbyte-mcp-0.15.65.tgz'&&artifact.sha256===closure.tarball_sha256&&
+    artifact.integrity===closure.tarball_integrity&&artifact.shasum===closure.tarball_shasum&&artifact.bytes>0,
+    'tarball identity mismatch');
+  return Object.freeze({status:'R167_RELEASE_READY_EVIDENCE_BOUND',manifest_sha256:closure.manifest_sha256,
+    tarball_sha256:artifact.sha256,tarball_integrity:artifact.integrity,tarball_shasum:artifact.shasum,tests,passes,skips});
+}

package/scripts/npm-release-readiness-r168.mjs

@@ -0,0 +1,70 @@
+import {createHash} from 'node:crypto';
+import {lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const hex=value=>typeof value==='string'&&/^[0-9a-f]{64}$/.test(value);
+const required=(value,message)=>{if(!value)throw new Error(`PUBLISH_BLOCKED R168 ${message}`);};
+
+async function checkedFile(file,expected,{maxBytes=32*1024*1024}={}){
+  required(hex(expected),'evidence digest missing');
+  const info=await lstat(file);
+  required(info.isFile()&&!info.isSymbolicLink()&&info.size>0&&info.size<maxBytes,'evidence file invalid');
+  const bytes=await readFile(file);
+  required(sha256(bytes)===expected,'evidence digest differs');
+  return bytes;
+}
+
+export function assertR168PackedIdentity({
+  tarball_sha256,tarball_integrity,tarball_shasum,
+  observedSha256,observedIntegrity,observedShasum
+}={}){
+  required(hex(tarball_sha256)&&typeof tarball_integrity==='string'&&tarball_integrity.startsWith('sha512-')&&
+    typeof tarball_shasum==='string'&&/^[0-9a-f]{40}$/.test(tarball_shasum),'verified tarball identity invalid');
+  required(observedSha256===tarball_sha256&&observedIntegrity===tarball_integrity&&observedShasum===tarball_shasum,
+    'repacked tarball differs from verified closure bytes');
+  return true;
+}
+
+export async function assertR168NpmPublishReady(release,{root}={}){
+  required(release?.version==='0.15.66'&&release?.train==='R168'&&
+    release?.r168?.scope==='REMOTE_VERSION_SKEW_FAIL_CLOSED_AND_READONLY_RECONCILIATION',
+    'candidate metadata invalid');
+  required(release?.parent?.release_id==='v0.15.61-055d1ff0aa99e60b'&&
+    release?.source_predecessor?.version==='0.15.65'&&release?.source_predecessor?.train==='R167',
+    'lineage mismatch');
+  const evidence=process.env.DEADBYTE_R168_CLOSURE_ROOT;
+  required(root&&path.isAbsolute(root)&&evidence&&path.isAbsolute(evidence),'closure root absent');
+  const allowed=path.resolve(root,'..','..','testing','r168-final-gate-fix1');
+  required(path.resolve(evidence).toLowerCase()===allowed.toLowerCase(),'closure root not in scoped testing folder');
+  const closure=JSON.parse(await readFile(path.join(evidence,'closure.json'),'utf8'));
+  required(closure?.schema==='deadbyte.r168-release-closure.v1'&&closure.status==='PASS'&&closure.version==='0.15.66',
+    'closure status mismatch');
+  required(closure.production_release_id===release.parent.release_id&&hex(closure.manifest_sha256),'predecessor or manifest invalid');
+  required(closure.manifest_sha256===sha256(await readFile(path.join(root,'MANIFEST.SHA256'))),'final manifest drift');
+
+  const receiptBytes=await checkedFile(path.join(evidence,'protected-install-receipt.json'),closure.protected_receipt_sha256);
+  const receipt=JSON.parse(receiptBytes.toString('utf8'));
+  required(receipt?.status==='PASS'&&receipt.package_version==='0.15.66'&&
+    receipt.source_manifest_sha256===closure.manifest_sha256&&receipt.protected_manifest_sha256===closure.manifest_sha256,
+    'protected exact-byte receipt mismatch');
+
+  const focused=(await checkedFile(path.join(evidence,'windows-focused.stdout.log'),closure.focused_stdout_sha256)).toString('utf8');
+  const full=(await checkedFile(path.join(evidence,'windows-full.stdout.log'),closure.full_stdout_sha256)).toString('utf8');
+  const verify=(await checkedFile(path.join(evidence,'npm-verify.stdout.log'),closure.verify_stdout_sha256)).toString('utf8');
+  required(focused.includes('R168_STAGE_PASS=focused')&&focused.includes('# fail 0'),'focused protected gate incomplete');
+  required(full.includes('R168_STAGE_PASS=full')&&full.includes('# fail 0'),'full protected gate incomplete');
+  const summaries=[...full.matchAll(/^# tests (\d+)\s*\r?\n# suites (\d+)\s*\r?\n# pass (\d+)\s*\r?\n# fail (\d+)\s*\r?\n# cancelled (\d+)\s*\r?\n# skipped (\d+)/gm)];
+  required(summaries.length>0,'full TAP summary absent');
+  const final=summaries.at(-1),tests=Number(final[1]),passes=Number(final[3]),fails=Number(final[4]),skips=Number(final[6]);
+  required(tests>=1975&&passes>=1925&&fails===0&&skips<=65&&passes+skips===tests,'full regression count mismatch');
+  required(verify.includes('VERIFY-ONLY PIPELINE PASS')&&verify.includes('Artifact isolation gate PASS')&&verify.includes('VERIFIED_TARBALL '),
+    'npm exact-artifact verification incomplete');
+  const line=verify.split(/\r?\n/).find(value=>value.startsWith('VERIFIED_TARBALL '));
+  let artifact;try{artifact=JSON.parse(line.slice('VERIFIED_TARBALL '.length));}catch{required(false,'tarball evidence malformed');}
+  required(artifact.filename==='deadbyte-mcp-0.15.66.tgz'&&artifact.sha256===closure.tarball_sha256&&
+    artifact.integrity===closure.tarball_integrity&&artifact.shasum===closure.tarball_shasum&&artifact.bytes>0,
+    'tarball identity mismatch');
+  return Object.freeze({status:'R168_RELEASE_READY_EVIDENCE_BOUND',manifest_sha256:closure.manifest_sha256,
+    tarball_sha256:artifact.sha256,tarball_integrity:artifact.integrity,tarball_shasum:artifact.shasum,tests,passes,skips});
+}

package/scripts/r168-audit-readonly.mjs

@@ -0,0 +1,32 @@
+// Standalone R168 *read-only* diagnostic. Never signs/releases activation locks.
+import os from 'node:os';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import {inspectR168UnknownWithoutMutation} from '../src/activation-reconciliation-audit-r168.mjs';
+
+const auditModule=new URL('../src/activation-reconciliation-audit-r168.mjs',import.meta.url);
+const expectedModuleHash='467268f6f195e9359b819e35c8b418c81e1cb40c9ba04b990fd2656e354c65a5';
+const state=path.join(os.homedir(),'.deadbyte-mcp');
+try{
+  const actualModuleHash=createHash('sha256').update(await readFile(auditModule)).digest('hex');
+  if(actualModuleHash!==expectedModuleHash)throw new Error('R168 audit module source hash changed');
+  const result=await inspectR168UnknownWithoutMutation({
+    stateRoot:state,
+    expectedOperationId:'c84d7ffa4eee80a2f467acda3ddd9332',
+    expectedSubjectSha256:'fba80e0128da9657dcbfcaa27d3a4dc8d9d8939146e81a097293fa5fcb6ae8fc',
+    expectedOutcomeFilename:'r65-activation-outcome-1792993876612-cc7c498632c7757d.json',
+    expectedContinuityId:'r65-ef42bc84451ce024c4dee736d4047b36',
+    expectedPredecessorReleaseId:'v0.15.61-055d1ff0aa99e60b',
+    expectedPredecessorManifestSha256:'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf',
+    expectedPredecessorGenerationSha256:'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4',
+    expectedCandidateManifestSha256:'ad3c091fbbe2bac6d234548724008b67305fd483ad6542f92d5aeb1aa84f5849'
+  });
+  console.log(JSON.stringify(result,null,2));
+  console.log('R168_NO_MUTATION_DIAGNOSTIC=OBSERVED_NOT_SIGNED');
+  console.log('R168_ACTIVATION_CLAIM=UNCHANGED');
+  console.log('R168_PRODUCTION_ACTIVATION=NOT_RUN');
+}catch(error){
+  console.error('R168_READONLY_AUDIT=BLOCKED '+String(error?.message??error));
+  process.exitCode=1;
+}

package/scripts/r168-npm-registry-readonly.mjs

@@ -0,0 +1,19 @@
+// R168 read-only exact registry preflight. No npm publish here.
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+const cli=path.join(path.dirname(process.execPath),'node_modules','npm','bin','npm-cli.js');
+const calls=[
+  ['view','deadbyte-mcp@0.15.66','version','--json'],
+  ['view','deadbyte-mcp','dist-tags.latest','--json'],
+  ['whoami']
+];
+for(const args of calls){
+ const r=spawnSync(process.execPath,[cli,...args],{
+  shell:false,windowsHide:true,encoding:'utf8',timeout:60000,maxBuffer:1024*1024
+ });
+ console.log(JSON.stringify({args:args.slice(0,3),exit:r.status,
+  stdout:String(r.stdout??'').trim().slice(0,250),
+  stderr:String(r.stderr??'').trim().slice(0,250)}));
+ if(r.error)throw r.error;
+ if(r.status!==0&&args[0]!=='view')process.exitCode=1;
+}

package/scripts/r168-protected-preflight.mjs

@@ -0,0 +1,65 @@
+// R168 privileged preflight; read-only. Never invokes native CAS or changes grants.
+// This code must be part of a signed manifest in a protected Program Files install.
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+import {inspectTrustedInstallation,privilegedEpochInstallFiles} from '../src/privileged-install-trust-r89.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const version='0.15.66';
+const expectedTrain='R168';
+const mandatory=['scripts/r168-protected-preflight.mjs',
+  'src/activation-reconciliation-journal-r168.mjs',
+  'src/activation-reconciliation-consent-r168.mjs',
+  'src/activation-reconciliation-terminal-r168.mjs',
+  'src/activation-reconciliation-fence-r168.mjs',
+  'src/activation-reconciliation-audit-r168.mjs',
+  'src/activation-reconciliation-receipt-store-r168.mjs'];
+function denied(reason){throw new Error('R168_'+reason);}
+function actualProtectedRoot(){
+  const trusted='C:\\Program Files';
+  const rel=path.win32.relative(trusted,root);
+  if(!rel||rel==='..'||rel.startsWith('..'+path.win32.sep)||path.win32.isAbsolute(rel))
+    denied('ROOT_UNPROTECTED');
+  return root;
+}
+async function main(){
+  if(process.platform!=='win32'||process.arch!=='x64')
+    denied('WINDOWS_X64_REQUIRED');
+  if(process.argv.length!==2)denied('UNKNOWN_OPTION');
+  const verifiedRoot=actualProtectedRoot();
+  const packageInfo=JSON.parse(await readFile(path.join(verifiedRoot,'package.json'),'utf8'));
+  const release=JSON.parse(await readFile(path.join(verifiedRoot,'RELEASE.json'),'utf8'));
+  if(packageInfo.name!=='deadbyte-mcp'||packageInfo.version!==version||
+     release.name!=='deadbyte-mcp'||release.version!==version||release.train!==expectedTrain)
+    denied('VERSION_DRIFT');
+  const manifest=await readFile(path.join(verifiedRoot,'MANIFEST.SHA256'));
+  const entries=parseManifest(manifest.toString('utf8'));
+  for(const name of mandatory){
+    if(!entries.has(name))denied('R168_SOURCE_NOT_IN_MANIFEST');
+  }
+  // The installed package is checked against its complete manifest, not a
+  // handpicked critical-file subset or a writable development source root.
+  await verifyManifestTreeExact(verifiedRoot,entries,{allowedExtraPaths:['.npmignore','package-lock.json']});
+  const important=[
+    ...privilegedEpochInstallFiles(verifiedRoot,process.execPath),
+    ...mandatory.map(rel=>path.win32.join(verifiedRoot,...rel.split('/'))),
+    path.win32.join(verifiedRoot,'MANIFEST.SHA256'),
+    path.win32.join(verifiedRoot,'RELEASE.json'),
+    path.win32.join(verifiedRoot,'package.json')
+  ];
+  // OS ACL trust is checked *after* content verification, under the protected
+  // root. No user-controlled environment may override this inventory.
+  await inspectTrustedInstallation(important);
+  const hash=createHash('sha256').update(manifest).digest('hex');
+  process.stdout.write(JSON.stringify({status:'R168_PROTECTED_PREFLIGHT_READONLY_PASS',
+    version,train:expectedTrain,manifest_sha256:hash,files:entries.size,
+    terminalization_authorized:false,activation_authorized:false})+'\n');
+}
+try{await main();}
+catch(error){
+  process.stderr.write('R168_PROTECTED_PREFLIGHT=BLOCKED '+String(error?.message??error)+'\n');
+  process.exitCode=1;
+}

package/scripts/r168-release-scan.mjs

@@ -0,0 +1,28 @@
+// R168 bounded read-only scan of current version-bound source.
+import {readdir,readFile,lstat} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+const root=fileURLToPath(new URL('..',import.meta.url));
+let count=0, results=[];
+const scopes=['test','src','scripts','controller','bridge'];
+for(const scope of scopes){
+ const visit=async(dir,depth)=>{
+  if(depth>14)throw Error('scan depth exceeded');
+  const entries=await readdir(dir,{withFileTypes:true});
+  if(entries.length>3000)throw Error('inventory exceeds budget');
+  for(const e of entries){
+   if(e.isSymbolicLink())throw Error('symlink in bounded scan');
+   const file=path.join(dir,e.name),rel=path.relative(root,file).replaceAll('\\','/');
+   if(e.isDirectory()) {if(!['node_modules','.git','tmp'].includes(e.name))await visit(file,depth+1);continue}
+   if(!e.isFile()||!/(\.mjs|\.ps1|\.json)$/.test(e.name))continue;
+   const stats=await lstat(file);if(stats.size>300000)continue;
+   const text=await readFile(file,'utf8');
+   const lines=text.split(/\r?\n/);
+   const matches=lines.map((s,j)=>({line:j+1,s})).filter(q=>/0\.15\.65|R167.*version|R167_CANDIDATE_VERSION_DRIFT|r167:0\.15\.65|R167_STAGE_PASS=/.test(q.s));
+   if(matches.length)results.push({file:rel,lines:matches.slice(0,7)});
+   count++;
+  }
+ };
+ await visit(path.join(root,scope),0);
+}
+console.log(JSON.stringify({scannedFiles:count,matchedFiles:results.length,results},null,2));

package/scripts/r168-source-full-test-runner.mjs

@@ -0,0 +1,46 @@
+// R168 Windows unprotected SOURCE gate. No publication, activation or claims.
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import {closeSync,fsyncSync,openSync} from 'node:fs';
+import {mkdir,readFile,writeFile} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const outDir=path.resolve(root,'..','..','testing','r168-source-full-20261026-fix1');
+const manifestBytes=await readFile(path.join(root,'MANIFEST.SHA256'));
+const manifestHash=createHash('sha256').update(manifestBytes).digest('hex');
+const fileCount=manifestBytes.toString('utf8').trimEnd().split(/\r?\n/).length;
+const digest=b=>createHash('sha256').update(b).digest('hex');
+const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+if(process.platform!=='win32'||release.version!=='0.15.66'||release.train!=='R168')
+ throw new Error('R168 Windows source release identity mismatch');
+const manifestCheck=spawnSync(process.execPath,[path.join(root,'scripts','release-manifest.mjs'),'verify'],{cwd:root,shell:false,windowsHide:true,encoding:'utf8',timeout:180000});
+if(manifestCheck.status!==0)throw new Error('R168 manifest verify failed '+String(manifestCheck.stderr??manifestCheck.stdout).slice(0,1200));
+await mkdir(outDir,{recursive:true});
+const stdoutPath=path.join(outDir,'windows-full.stdout.log');
+const stderrPath=path.join(outDir,'windows-full.stderr.log');
+let o=null,e=null;
+try{
+ o=openSync(stdoutPath,'wx');e=openSync(stderrPath,'wx');
+ const cross=path.join(root,'..','..','testing','r168-crossvolume-scratch');
+ await mkdir(cross,{recursive:true});
+ const result=spawnSync(process.execPath,
+  ['--test','--test-reporter=tap','--test-concurrency=4','test/*.test.mjs'],{
+   cwd:root,shell:false,windowsHide:true,stdio:['ignore',o,e],
+   timeout:480000,env:{...process.env,DEADBYTE_TEST_CROSS_VOLUME_ROOT:cross}
+  });
+ fsyncSync(o);fsyncSync(e);
+ closeSync(o);closeSync(e);o=e=null;
+ const full=await readFile(stdoutPath,'utf8');
+ const match=[...full.matchAll(/^# tests (\d+)\s*\r?\n# suites (\d+)\s*\r?\n# pass (\d+)\s*\r?\n# fail (\d+)\s*\r?\n# cancelled (\d+)\s*\r?\n# skipped (\d+)/gm)].at(-1);
+ const summary={status:result.status===0?'SOURCE_FULL_PASS':'SOURCE_FULL_FAIL',
+  exit_code:result.status,terminated_signal:result.signal??null,
+  files_checked:fileCount,manifest_sha256:manifestHash,
+  tests:match?Number(match[1]):null,passes:match?Number(match[3]):null,
+  failures:match?Number(match[4]):null,skipped:match?Number(match[6]):null,
+  stdout_sha256:digest(await readFile(stdoutPath)),stderr_sha256:digest(await readFile(stderrPath))};
+ console.log(JSON.stringify(summary,null,2));
+ if(result.error)throw result.error;
+ if(result.status!==0)process.exitCode=1;
+}catch(error){if(o!==null)closeSync(o);if(e!==null)closeSync(e);throw error;}

package/scripts/r168-subject-readonly.mjs

@@ -0,0 +1,49 @@
+// R168 read-only subject preparation. No signing keys or activation mutation.
+import {readFile} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import {readPinnedEpochLockSnapshot} from '../src/foreground-marker-cas-win32.mjs';
+import {inspectR168UnknownWithoutMutation} from '../src/activation-reconciliation-audit-r168.mjs';
+import {createR168ReconciliationSubject,makeR168ConsentChallenge} from '../src/activation-reconciliation-consent-r168.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const sourceExpected={
+ 'activation-reconciliation-audit-r168.mjs':'467268f6f195e9359b819e35c8b418c81e1cb40c9ba04b990fd2656e354c65a5',
+ 'activation-reconciliation-consent-r168.mjs':'a82b05e1c521cc77f3398985d6faa1beb0fe8f65595f50bed474227550d462c5'
+};
+const stateRoot=path.join(os.homedir(),'.deadbyte-mcp');
+const lockPath=path.join(stateRoot,'evidence','updates','r65-activation.lock');
+try {
+  if(process.platform!=='win32')throw new Error('Windows-only R168 subject');
+  for(const [name,expected] of Object.entries(sourceExpected)){
+    const bytes=await readFile(new URL('../src/'+name,import.meta.url));
+    if(sha(bytes)!==expected)throw new Error('R168 source identity changed: '+name);
+  }
+  const pinnedBefore=readPinnedEpochLockSnapshot(lockPath);
+  if(!pinnedBefore)throw new Error('old claim missing');
+  const observation=await inspectR168UnknownWithoutMutation({
+    stateRoot,
+    expectedOperationId:'c84d7ffa4eee80a2f467acda3ddd9332',
+    expectedSubjectSha256:'fba80e0128da9657dcbfcaa27d3a4dc8d9d8939146e81a097293fa5fcb6ae8fc',
+    expectedOutcomeFilename:'r65-activation-outcome-1792993876612-cc7c498632c7757d.json',
+    expectedContinuityId:'r65-ef42bc84451ce024c4dee736d4047b36',
+    expectedPredecessorReleaseId:'v0.15.61-055d1ff0aa99e60b',
+    expectedPredecessorManifestSha256:'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf',
+    expectedPredecessorGenerationSha256:'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4',
+    expectedCandidateManifestSha256:'ad3c091fbbe2bac6d234548724008b67305fd483ad6542f92d5aeb1aa84f5849'
+  });
+  const pinnedAfter=readPinnedEpochLockSnapshot(lockPath);
+  if(!pinnedAfter||pinnedAfter.sha256!==pinnedBefore.sha256||pinnedAfter.fileId!==pinnedBefore.fileId)
+    throw new Error('R168 lock changed during subject derivation');
+  const subject=createR168ReconciliationSubject({observation,claimSnapshot:pinnedBefore,stateRoot});
+  console.log(JSON.stringify({status:'R168_SUBJECT_READY_READONLY',claim_operation_id:subject.claim_operation_id,
+    observation_sha256:observation.observation_sha256,subject_sha256:subject.subject_sha256,
+    native_claim_sha256:pinnedBefore.sha256,native_claim_file_id:pinnedBefore.fileId,
+    verified_signed_events:observation.signed_event_count,
+    approval_challenge:makeR168ConsentChallenge(subject),
+    owner_signature:'NOT_PRESENT',terminalization_committed:false,activation_authorized:false},null,2));
+}catch(error){
+  console.error('R168_SUBJECT_READONLY_BLOCKED '+String(error?.message??error));
+  process.exitCode=1;
+}

package/src/activation-path-r167.mjs

@@ -0,0 +1,55 @@
+import path from 'node:path';
+
+function canonicalWindowsRoot(value,label){
+  if(typeof value!=='string'||value.length===0)throw new Error(`${label} requires a path`);
+  if(value.includes('\0')||value.startsWith('\\\\')||value.startsWith('\\\\?\\')||value.includes('/'))
+    throw new Error(`${label} must be a canonical local Windows path`);
+  if(!/^[A-Za-z]:\\/.test(value)||!path.win32.isAbsolute(value))
+    throw new Error(`${label} must be an absolute local Windows path`);
+  const normalized=path.win32.normalize(value);
+  if(normalized!==value||/(?:^|\\)\.\.?($|\\)/.test(value))
+    throw new Error(`${label} must be canonical`);
+  return value;
+}
+
+const samePath=(left,right)=>path.win32.normalize(left).toLowerCase()===path.win32.normalize(right).toLowerCase();
+
+export function parseActivationPathFlags(argv){
+  if(!Array.isArray(argv))throw new TypeError('deploy argv must be an array');
+  let authorityEpochRoot=null,developmentRoot=null;
+  const remainingArgs=[];
+  for(let index=0;index<argv.length;index++){
+    const arg=argv[index];
+    if(arg!=='--authority-epoch-root'&&arg!=='--development-root'){
+      remainingArgs.push(arg);continue;
+    }
+    const value=argv[++index];
+    if(arg==='--authority-epoch-root'){
+      if(authorityEpochRoot!==null)throw new Error('duplicate --authority-epoch-root');
+      authorityEpochRoot=canonicalWindowsRoot(value,'--authority-epoch-root');
+    }else{
+      if(developmentRoot!==null)throw new Error('duplicate --development-root');
+      developmentRoot=canonicalWindowsRoot(value,'--development-root');
+    }
+  }
+  return Object.freeze({authorityEpochRoot,developmentRoot,remainingArgs:Object.freeze(remainingArgs)});
+}
+
+export function assertTrustedActivationEntrypoint({continuity,packageRoot,authorityEpochRoot,developmentRoot,trusted}){
+  if(continuity!=='EPOCH_NATIVE')return Object.freeze({authorityEpochRoot,developmentRoot});
+  const epoch=canonicalWindowsRoot(authorityEpochRoot,'--authority-epoch-root');
+  const development=canonicalWindowsRoot(developmentRoot,'--development-root');
+  const activeRoot=canonicalWindowsRoot(packageRoot,'deploy package root');
+  if(!samePath(activeRoot,epoch))throw new Error('EPOCH_NATIVE activation requires the protected entrypoint package root');
+  if(trusted!==true)throw new Error('EPOCH_NATIVE activation package root is not ACL-trusted');
+  return Object.freeze({authorityEpochRoot:epoch,developmentRoot:development});
+}
+
+export function appendActivationPathArgs(args,{stageRoot,authorityEpochRoot,developmentRoot}){
+  if(!Array.isArray(args))throw new TypeError('updater args must be an array');
+  const stage=canonicalWindowsRoot(stageRoot,'stage root');
+  const epoch=canonicalWindowsRoot(authorityEpochRoot,'--authority-epoch-root');
+  const development=canonicalWindowsRoot(developmentRoot,'--development-root');
+  if(!samePath(stage,epoch))throw new Error('updater stage must equal the protected authority epoch root');
+  return [...args,'--stage',stage,'--development-root',development,'--authority-epoch-root',epoch];
+}