deadbyte-mcp 0.15.65 → 0.15.67

package/scripts/gate-windows-r168.ps1

@@ -0,0 +1,75 @@
+#requires -Version 5.1
+[CmdletBinding()]
+param(
+    [ValidateSet('preflight','focused','full','manifest','doctor','all')][string]$Stage='preflight',
+    [string]$ExpectedDevelopmentRoot
+)
+Set-StrictMode -Version Latest
+$ErrorActionPreference='Stop'
+$repo=Split-Path -Parent $PSScriptRoot
+if([string]::IsNullOrWhiteSpace($ExpectedDevelopmentRoot)){$ExpectedDevelopmentRoot=$repo}
+$ExpectedDevelopmentRoot=[IO.Path]::GetFullPath($ExpectedDevelopmentRoot)
+$state=Join-Path $env:USERPROFILE '.deadbyte-mcp'
+$parentId='v0.15.61-055d1ff0aa99e60b'
+$parentSha='055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf'
+$parentGen='f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4'
+$sourceManifest='3316654646cc870584a7c969c2032af6c795229ff8c65e5a8b794f97c2458c41'
+$nativeNode='C:\Program Files\nodejs\node.exe'
+$node=if(Test-Path -LiteralPath $nativeNode -PathType Leaf){$nativeNode}else{(Get-Command node -ErrorAction Stop).Source}
+function Sha([string]$file){
+    $sha=[Security.Cryptography.SHA256]::Create()
+    try{$stream=[IO.File]::OpenRead($file);try{return ([BitConverter]::ToString($sha.ComputeHash($stream))).Replace('-','').ToLowerInvariant()}finally{$stream.Dispose()}}finally{$sha.Dispose()}
+}
+function Run-Node([string]$label,[string[]]$nodeArgs){
+    if($null -eq $nodeArgs -or $nodeArgs.Count -lt 1){throw "R168_${label}_NO_NODE_ARGUMENTS"}
+    Write-Output "R168_STAGE_START=$label"
+    Write-Output "R168_STAGE_ARGS=$($nodeArgs.Count)"
+    $global:LASTEXITCODE=0
+    & $node @nodeArgs
+    $exit=$global:LASTEXITCODE
+    if($exit -ne 0){throw "R168_${label}_FAILED exit=$exit"}
+    Write-Output "R168_STAGE_PASS=$label"
+}
+Push-Location $repo
+$previousExpectedDevelopmentRoot=$env:DEADBYTE_EXPECTED_DEVELOPMENT_ROOT
+try{
+    $env:DEADBYTE_EXPECTED_DEVELOPMENT_ROOT=$ExpectedDevelopmentRoot
+    $pkg=Get-Content -LiteralPath 'package.json' -Raw | ConvertFrom-Json
+    $release=Get-Content -LiteralPath 'RELEASE.json' -Raw | ConvertFrom-Json
+    if($pkg.version -ne '0.15.66' -or $release.version -ne '0.15.66' -or $release.train -ne 'R168'){throw 'R168_CANDIDATE_VERSION_DRIFT'}
+    if($release.source_predecessor.version -ne '0.15.65' -or $release.source_predecessor.train -ne 'R167' -or $release.r168.source_predecessor_manifest_sha256 -ne $sourceManifest){throw 'R168_SOURCE_PREDECESSOR_IDENTITY_DRIFT'}
+    if($release.runtime_predecessor.release_id -ne $parentId -or $release.runtime_predecessor.manifest_sha256 -ne $parentSha -or $release.runtime_predecessor.generation_manifest_sha256 -ne $parentGen){throw 'R168_RUNTIME_PREDECESSOR_IDENTITY_DRIFT'}
+    $active=Get-Content -LiteralPath (Join-Path $state 'active-release.json') -Raw | ConvertFrom-Json
+    if($active.version -ne '0.15.61' -or $active.release_id -ne $parentId -or $active.manifest_sha256 -ne $parentSha -or $active.generation_manifest_sha256 -ne $parentGen){throw 'R168_ACTIVE_RUNTIME_DRIFT'}
+    if((Sha (Join-Path $active.release_root 'MANIFEST.SHA256')) -ne $parentSha){throw 'R168_ACTIVE_MANIFEST_MISMATCH'}
+    Write-Output 'R168_PREDECESSOR_PREFLIGHT=PASS'
+    if($Stage -eq 'preflight'){return}
+    if($Stage -in @('focused','all')){
+        Run-Node -label 'focused' -nodeArgs @('--test','--test-reporter=tap','--test-concurrency=1','test/r167-activation-path.test.mjs','test/r168-release-contract.test.mjs','test/r168-remote-one-shot-coherence.test.mjs','test/r160-release-contract.test.mjs','test/r158-epoch-bootstrap.test.mjs','test/r65-activation-orchestration.test.mjs','test/r89-privileged-install-boundary.test.mjs','test/r119-recovery-crash-after-commit.test.mjs','test/r59-tool-surface-compat.test.mjs')
+        if($Stage -eq 'focused'){return}
+    }
+    if($Stage -in @('full','all')){
+        $previousCrossVolume=$env:DEADBYTE_TEST_CROSS_VOLUME_ROOT
+        $tempDrive=[IO.Path]::GetPathRoot([IO.Path]::GetFullPath($env:TEMP))
+        $scratchDrive=if($tempDrive -ieq 'D:\'){'C:\'}else{'D:\'}
+        if(-not (Test-Path -LiteralPath $scratchDrive -PathType Container)){throw 'R168_CROSS_VOLUME_DRIVE_UNAVAILABLE'}
+        $crossVolume=Join-Path $scratchDrive 'DEADBYTE-R168-CrossVolume'
+        try{
+            [IO.Directory]::CreateDirectory($crossVolume)|Out-Null
+            $env:DEADBYTE_TEST_CROSS_VOLUME_ROOT=$crossVolume
+            Run-Node -label 'full' -nodeArgs @('--test','--test-reporter=tap','--test-concurrency=4','test/*.test.mjs')
+        }finally{$env:DEADBYTE_TEST_CROSS_VOLUME_ROOT=$previousCrossVolume}
+        if($Stage -eq 'full'){return}
+    }
+    if($Stage -in @('manifest','all')){
+        Run-Node -label 'manifest' -nodeArgs @('scripts/release-manifest.mjs','verify')
+        if($Stage -eq 'manifest'){return}
+    }
+    if($Stage -in @('doctor','all')){
+        $previous=$env:DEADBYTE_STATE_ROOT
+        $isolated=Join-Path $env:TEMP ('deadbyte-r168-doctor-'+[guid]::NewGuid().ToString('N'))
+        try{[IO.Directory]::CreateDirectory($isolated)|Out-Null;$env:DEADBYTE_STATE_ROOT=$isolated;Run-Node -label 'isolated_doctor' -nodeArgs @('src/deadbyte-cli.mjs','doctor')}
+        finally{$env:DEADBYTE_STATE_ROOT=$previous;Remove-Item -LiteralPath $isolated -Recurse -Force -ErrorAction SilentlyContinue}
+    }
+    Write-Output 'R168_WINDOWS_CANDIDATE_GATE=PASS_PREPUBLICATION'
+}finally{$env:DEADBYTE_EXPECTED_DEVELOPMENT_ROOT=$previousExpectedDevelopmentRoot;Pop-Location}

package/scripts/npm-release-r48.mjs

@@ -11,6 +11,8 @@ 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';
@@ -116,6 +118,11 @@ async function main() {
     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) {
@@ -145,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);
@@ -157,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;
@@ -242,6 +258,10 @@ async function main() {
       ...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-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/scripts/r172-protected-preflight.mjs

@@ -0,0 +1,42 @@
+// R172 privileged preflight; read-only. Never invokes native CAS or changes grants.
+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.67',expectedTrain='R172';
+const mandatory=['scripts/r172-protected-preflight.mjs','src/activation-continuity-abort-r172.mjs',
+  'src/activation-lock-r65.mjs','src/activation-preflight-r65.mjs',
+  'src/activation-reconciliation-journal-r168.mjs','src/activation-reconciliation-terminal-r168.mjs',
+  'src/activation-reconciliation-fence-r168.mjs','src/activation-reconciliation-audit-r168.mjs'];
+function denied(reason){throw new Error('R172_'+reason);}
+function actualProtectedRoot(){
+  const trusted='C:\\Program Files',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 pkg=JSON.parse(await readFile(path.join(verifiedRoot,'package.json'),'utf8'));
+  const release=JSON.parse(await readFile(path.join(verifiedRoot,'RELEASE.json'),'utf8'));
+  if(pkg.name!=='deadbyte-mcp'||pkg.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('SOURCE_NOT_IN_MANIFEST');
+  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')];
+  await inspectTrustedInstallation(important);
+  const hash=createHash('sha256').update(manifest).digest('hex');
+  process.stdout.write(JSON.stringify({status:'R172_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('R172_PROTECTED_PREFLIGHT=BLOCKED '+String(error?.message??error)+'\n');process.exitCode=1;}

package/src/activation-continuity-abort-r172.mjs

@@ -0,0 +1,108 @@
+import {createHash} from 'node:crypto';
+import {lstat, readFile, readdir} from 'node:fs/promises';
+import path from 'node:path';
+import {createAuthorityEpochStore} from './authority-continuity-r65.mjs';
+
+const PLANES = Object.freeze(['process', 'coding', 'autonomous', 'desktop', 'host']);
+const GRANT_FIELD = Object.freeze({
+  process: 'grant_file', coding: 'lease_file', autonomous: 'lease_file',
+  desktop: 'grant_file', host: 'arm_file'
+});
+const HEX64 = /^[0-9a-f]{64}$/u;
+const CONTINUITY = /^r65-[0-9a-f]{32}$/u;
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+
+function parse(bytes, label) {
+  let text = bytes.toString('utf8');
+  if (text.charCodeAt(0) === 0xfeff) text = text.slice(1);
+  try { return JSON.parse(text); }
+  catch { throw new Error(`R172 ${label} JSON invalid`); }
+}
+
+function inside(root, target) {
+  const relative = path.relative(path.resolve(root), path.resolve(target));
+  return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+
+async function optionalBytes(file) {
+  try { return await readFile(file); }
+  catch (error) { if (error?.code === 'ENOENT') return null; throw error; }
+}
+
+export async function verifyR172PredispatchContinuityAbort({outcome, lock, stateRoot} = {}) {
+  if (!outcome || !lock || typeof stateRoot !== 'string' || !path.isAbsolute(stateRoot)) return false;
+  if (outcome.schema !== 'deadbyte.r65-activation-outcome.v1' ||
+      outcome.claim_operation_id !== lock.operation_id ||
+      outcome.preflight_subject_sha256 !== lock.subject_sha256 ||
+      outcome.outcome?.state !== 'ACTIVATION_OUTCOME_UNKNOWN' ||
+      outcome.outcome?.preflight !== 'AUTHORITY_UNVERIFIED' ||
+      outcome.update_id !== null || outcome.state_path !== null ||
+      !CONTINUITY.test(String(outcome.continuity_update_id ?? '')) ||
+      !HEX64.test(String(outcome.candidate_manifest_sha256 ?? '')) ||
+      typeof outcome.candidate_version !== 'string' || typeof outcome.predecessor_release_id !== 'string') return false;
+
+  const created = Date.parse(lock.created_at_utc), observed = Date.parse(outcome.observed_at_utc);
+  if (!Number.isFinite(created) || !Number.isFinite(observed) || observed < created || observed - created > 120_000) return false;
+  const state = path.resolve(stateRoot), pointerBytes = await readFile(path.join(state, 'active-release.json'));
+  const pointer = parse(pointerBytes, 'active pointer');
+  if (pointer.release_id !== outcome.predecessor_release_id ||
+      !HEX64.test(String(pointer.manifest_sha256 ?? '')) ||
+      !HEX64.test(String(pointer.generation_manifest_sha256 ?? ''))) return false;
+  const generation = path.resolve(String(pointer.generation_root ?? ''));
+  if (!inside(path.join(state, 'generations'), generation)) return false;
+
+  const updates = path.join(state, 'evidence', 'updates');
+  const candidatePrefix = `r27-${outcome.candidate_manifest_sha256.slice(0, 16)}-`;
+  const updateEntries = await readdir(updates, {withFileTypes: true});
+  if (updateEntries.some(entry => entry.name.startsWith(candidatePrefix))) return false;
+
+  const runtime = path.join(state, 'runtime');
+  const store = createAuthorityEpochStore({runtimeDir: runtime});
+  const revoked = new Map();
+  for (const plane of PLANES) {
+    const audit = await store.auditHistory({plane});
+    if (!['PASS', 'EMPTY'].includes(audit.status)) return false;
+    const eventsDir = path.join(runtime, 'authority-epochs', plane, 'events');
+    let entries;
+    try { entries = await readdir(eventsDir, {withFileTypes: true}); }
+    catch (error) { if (error?.code === 'ENOENT' && audit.status === 'EMPTY') entries = []; else throw error; }
+    if (entries.length !== audit.verified_events || entries.length > 10_000) return false;
+    for (const entry of entries) {
+      if (!entry.isFile() || entry.isSymbolicLink()) return false;
+      const match = /^(\d{16})-([0-9a-f]{64})\.json$/u.exec(entry.name);
+      if (!match) return false;
+      const bytes = await readFile(path.join(eventsDir, entry.name));
+      if (sha(bytes) !== match[2]) return false;
+      const event = parse(bytes, `${plane} epoch event`);
+      if (event.update_id !== outcome.continuity_update_id) continue;
+      const when = Date.parse(event.recorded_at_utc);
+      if (event.plane !== plane || event.action !== 'transaction_revoke' ||
+          !Number.isFinite(when) || when < created || when > observed || revoked.has(plane)) return false;
+      revoked.set(plane, event);
+    }
+  }
+  if (revoked.size < 1) return false;
+
+  for (const [plane, event] of revoked) {
+    const policyFile = path.join(generation, `${plane}-policy.json`);
+    const policyBytes = await readFile(policyFile), policy = parse(policyBytes, `${plane} policy`);
+    const grantFile = path.resolve(String(policy?.[GRANT_FIELD[plane]] ?? ''));
+    if (!inside(runtime, grantFile)) return false;
+    const planeStore = createAuthorityEpochStore({runtimeDir: runtime, policyBytes});
+    const head = await planeStore.readHead({plane});
+    if (!head || head.seq <= event.seq || head.previous_event_sha256 === null) return false;
+    if (head.action === 'user_revoke') {
+      if (await optionalBytes(grantFile) !== null) return false;
+      continue;
+    }
+    if (!['grant', 'transaction_restore'].includes(head.action)) return false;
+    const grantBytes = await optionalBytes(grantFile);
+    if (!grantBytes) return false;
+    const grant = parse(grantBytes, `${plane} grant`);
+    const verified = await planeStore.verifyGrant({
+      plane, grantBytes, grantInstanceNonce: grant.instance_nonce, policyBytes
+    });
+    if (verified.trusted !== true || verified.event_sha256 !== head.event_sha256) return false;
+  }
+  return true;
+}

package/src/activation-lock-r65.mjs

@@ -2,6 +2,7 @@ import {createPublicKey,randomBytes} from 'node:crypto';
 import {mkdir,open,readFile,readdir,unlink} from 'node:fs/promises';
 import path from 'node:path';
 import {verifySlotUpdateEnvelope} from './runtime-update.mjs';
+import {verifyR172PredispatchContinuityAbort} from './activation-continuity-abort-r172.mjs';
 
 const HEX64=/^[0-9a-f]{64}$/;
 const OP=/^[0-9a-f]{32}$/;
@@ -130,8 +131,11 @@ async function findTerminalOutcome(updatesDir,lock,stateRoot){
     catch{continue;}
     if(value?.claim_operation_id!==lock.operation_id)continue;
     if(value?.preflight_subject_sha256!==lock.subject_sha256){foreign=true;continue;}
+    let continuityAbort=false;
+    try{continuityAbort=await verifyR172PredispatchContinuityAbort({outcome:value,lock,stateRoot});}
+    catch{continuityAbort=false;}
     if(isSafePreMutationReject(value,lock)||await isSafeTerminalActivation(value,lock,stateRoot)||
-       await isSafeSignedPreconditionReject(value,lock,stateRoot))matched=true;
+       await isSafeSignedPreconditionReject(value,lock,stateRoot)||continuityAbort)matched=true;
     else unknown=true;
   }
   return {matched,foreign,unknown};