deadbyte-mcp 0.15.62 → 0.15.64

package/scripts/gate-windows-r166.ps1

@@ -0,0 +1,57 @@
+#requires -Version 5.1
+[CmdletBinding()]
+param([ValidateSet('preflight','focused','full','manifest','doctor','all')][string]$Stage='preflight')
+Set-StrictMode -Version Latest
+$ErrorActionPreference='Stop'
+$repo=Split-Path -Parent $PSScriptRoot
+$state=Join-Path $env:USERPROFILE '.deadbyte-mcp'
+$parentId='v0.15.61-055d1ff0aa99e60b'
+$parentSha='055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf'
+$parentGen='f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4'
+$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 "R166_${label}_NO_NODE_ARGUMENTS"}
+    Write-Output "R166_STAGE_START=$label"
+    Write-Output "R166_STAGE_ARGS=$($nodeArgs.Count)"
+    $global:LASTEXITCODE=0
+    & $node @nodeArgs
+    $exit=$global:LASTEXITCODE
+    if($exit -ne 0){throw "R166_${label}_FAILED exit=$exit"}
+    Write-Output "R166_STAGE_PASS=$label"
+}
+Push-Location $repo
+try{
+    $pkg=Get-Content -LiteralPath 'package.json' -Raw | ConvertFrom-Json
+    $release=Get-Content -LiteralPath 'RELEASE.json' -Raw | ConvertFrom-Json
+    if($pkg.version -ne '0.15.64' -or $release.version -ne '0.15.64' -or $release.train -ne 'R166'){throw 'R166_CANDIDATE_VERSION_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 'R166_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 'R166_ACTIVE_RUNTIME_DRIFT'}
+    if((Sha (Join-Path $active.release_root 'MANIFEST.SHA256')) -ne $parentSha){throw 'R166_ACTIVE_MANIFEST_MISMATCH'}
+    Write-Output 'R166_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/r89-privileged-install-boundary.test.mjs','test/r92-acl-ace-applicability.test.mjs','test/r153-clean-activation-recovery.test.mjs','test/r155-commander-live-log.test.mjs','test/r155-default-live-log.test.mjs','test/r156-supervisor-pacing.test.mjs','test/r157-supervisor-singleflight.test.mjs','test/r158-epoch-bootstrap.test.mjs','test/r159-legacy-marker-evidence.test.mjs','test/r160-marker-proof.test.mjs','test/r160-package-decision-manifest.test.mjs','test/r160-stable-launcher.test.mjs','test/r160-release-contract.test.mjs','test/r59-tool-surface-compat.test.mjs')
+        if($Stage -eq 'focused'){return}
+    }
+    if($Stage -in @('full','all')){
+        Run-Node -label 'full' -nodeArgs @('--test','--test-reporter=tap','--test-concurrency=4','test/*.test.mjs')
+        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-r160-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 'R166_WINDOWS_CANDIDATE_GATE=PASS_PREPUBLICATION'
+}finally{Pop-Location}

package/scripts/npm-release-r48.mjs

@@ -8,6 +8,8 @@ import {assertR71NpmPublishReady} from './npm-release-readiness-r71.mjs';
 import {assertR72NpmPublishReady} from './npm-release-readiness-r72.mjs';
 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 { existsSync } from 'node:fs';
 import { resolveStateRoot } from '../src/state-root.mjs';
 import path from 'node:path';
@@ -100,6 +102,14 @@ async function main() {
     if (!publishOnly) throw new Error('PUBLISH_BLOCKED R163 0.15.62 requires --publish-only; production activation is a separate authority boundary');
     await assertR163NpmPublishReady(release,{root});
   }
+  if (!isVerifyOnly && version==='0.15.63') {
+    if (!publishOnly) throw new Error('PUBLISH_BLOCKED R165 0.15.63 requires --publish-only; production activation is a separate authority boundary');
+    await assertR165NpmPublishReady(release,{root});
+  }
+  if (!isVerifyOnly && version==='0.15.64') {
+    if (!publishOnly) throw new Error('PUBLISH_BLOCKED R166 requires --publish-only; activation is separate');
+    await assertR166NpmPublishReady(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) {

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

@@ -0,0 +1,68 @@
+/** R165 0.15.63 publication fence. No evidence generation or authority mutation. */
+import {createHash} from 'node:crypto';
+import {readFile,lstat} from 'node:fs/promises';
+import path from 'node:path';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const parent='v0.15.61-055d1ff0aa99e60b';
+const parentManifest='055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf';
+const parentGen='f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4';
+const reject=(m)=>{throw new Error('PUBLISH_BLOCKED R165 '+m);};
+const hex=x=>typeof x==='string'&&/^[0-9a-f]{64}$/.test(x);
+const readJson=async f=>JSON.parse(await readFile(f,'utf8'));
+async function checkedEvidenceFile(file,digest,{allowEmpty=false}={}){
+  if(!hex(digest))reject('missing exact evidence digest');
+  const info=await lstat(file).catch(()=>reject('evidence file missing '+file));
+  if(!info.isFile()||info.isSymbolicLink()||(!allowEmpty&&info.size<1)||info.size>16*1024*1024)reject('invalid evidence file');
+  const bytes=await readFile(file);
+  if(sha(bytes)!==digest)reject('evidence SHA-256 mismatch '+file);
+  return bytes;
+}
+function boundedEvidence(root,relative){
+  if(typeof relative!=='string'||!relative||relative.includes('\\'))reject('invalid evidence relative path');
+  const p=path.resolve(root,relative),r=path.relative(root,p);
+  if(!r||r.startsWith('..')||path.isAbsolute(r))reject('evidence path escape');
+  return p;
+}
+export async function assertR165NpmPublishReady(release,{root,evidenceRoot=process.env.DEADBYTE_R165_CLOSURE_ROOT}={}){
+  if(release?.name!=='deadbyte-mcp'||release?.version!=='0.15.63'||release?.train!=='R165'||release?.r165?.publication_mode!=='PUBLISH_ONLY')reject('release metadata not R165-closed');
+  if(release?.parent?.release_id!==parent||release?.parent?.manifest_sha256!==parentManifest||release?.parent?.generation_manifest_sha256!==parentGen||release?.runtime_predecessor?.release_id!==parent)reject('active predecessor lineage mismatch');
+  if(!root||!path.isAbsolute(root))reject('candidate root missing');
+  if(!evidenceRoot||!path.isAbsolute(evidenceRoot))reject('closure evidence path missing');
+  const testRoot=path.resolve(root,'..','..','testing','r165-release-closure');
+  const evidence=path.resolve(evidenceRoot);
+  const relative=path.relative(testRoot,evidence);
+  if(!relative||relative.startsWith('..')||path.isAbsolute(relative))reject('evidence outside bounded R165 testing root');
+  for(const p of [testRoot,evidence]){const st=await lstat(p).catch(()=>reject('evidence directory absent'));if(!st.isDirectory()||st.isSymbolicLink())reject('evidence directory is reparse/symlink');}
+  const closurePath=path.join(evidence,'closure.json');
+  const closureInfo=await lstat(closurePath).catch(()=>reject('closure missing'));
+  if(!closureInfo.isFile()||closureInfo.isSymbolicLink()||closureInfo.size<1||closureInfo.size>1024*1024)reject('closure file not regular/bounded');
+  const closure=await readJson(closurePath).catch(()=>reject('closure missing/invalid'));
+  if(closure?.schema!=='deadbyte.r165-release-closure.v1'||closure?.version!=='0.15.63'||closure?.status!=='PASS'||closure?.production_release_id!==parent)reject('closure subject/status mismatch');
+  const manifestSha=sha(await readFile(path.join(root,'MANIFEST.SHA256')));
+  if(closure.source_manifest_sha256!==manifestSha)reject('final manifest differs from closure');
+  const files=closure?.files;
+  if(!files||!['protected_receipt','protected_stdout','protected_stderr','verify_receipt','verify_stdout','verify_stderr'].every(k=>files[k]&&typeof files[k].path==='string'&&hex(files[k].sha256)))reject('required receipts missing');
+  const data={};
+  for(const [key,info] of Object.entries(files)) data[key]=await checkedEvidenceFile(boundedEvidence(testRoot,info.path),info.sha256,{allowEmpty:key.endsWith('_stderr')});
+  let protectedReceipt,verifyReceipt;
+  try{protectedReceipt=JSON.parse(data.protected_receipt);verifyReceipt=JSON.parse(data.verify_receipt);}
+  catch{reject('gate receipts invalid JSON');}
+  if(protectedReceipt?.schema!=='deadbyte.r165-protected-windows-gate.v1'||protectedReceipt?.stage!=='full'||protectedReceipt?.exit_code!==0||protectedReceipt?.source_manifest_sha256!==manifestSha||protectedReceipt?.active_release_id!==parent)reject('protected gate missing or unbound');
+  if(protectedReceipt.stdout_sha256!==sha(data.protected_stdout)||protectedReceipt.stderr_sha256!==sha(data.protected_stderr))reject('protected log mismatch');
+  const stdout=data.protected_stdout.toString('utf8');
+  const counts=Object.fromEntries(['tests','pass','fail','skipped'].map(k=>[k,Number(new RegExp('^# '+k+' (\\d+)\\s*$','m').exec(stdout)?.[1]??NaN)]));
+  if(counts.tests<1955||counts.pass<1906||counts.fail!==0||counts.skipped!==49||counts.pass+counts.skipped!==counts.tests||/^not ok\s+\d+/m.test(stdout))reject('full regression totals mismatch');
+  if(!/^ok\s+\d+\s+-\s+R165 isolated immutable slot activates, rolls back, and restores 0\.15\.63/m.test(stdout))reject('R165 live rollback proof missing');
+  if(!/^ok\s+\d+\s+-\s+R165 executable CLI passes completed R159 history/m.test(stdout))reject('R165 executable startup proof missing');
+  const skips=stdout.split(/\r?\n/).filter(x=>/^ok\s+\d+\s+-.*# SKIP/.test(x));
+  if(skips.length!==49||skips.some(x=>!/historical|R35 external semantic backend|POSIX|R100 POSIX/i.test(x)))reject('unexpected unclassified skipped test');
+  if(verifyReceipt?.schema!=='deadbyte.r165-release-verify.v1'||verifyReceipt?.status!=='PASS'||verifyReceipt?.version!=='0.15.63'||verifyReceipt?.source_manifest_sha256!==manifestSha||verifyReceipt?.production_release_id!==parent||verifyReceipt?.exit_code!==0)reject('verify-only receipt subject/status mismatch');
+  if(verifyReceipt.stdout_sha256!==sha(data.verify_stdout)||verifyReceipt.stderr_sha256!==sha(data.verify_stderr))reject('verify-only transcript hash mismatch');
+  const vout=data.verify_stdout.toString('utf8');
+  if(!vout.includes('VERIFY-ONLY PIPELINE PASS')||!vout.includes('Artifact isolation gate PASS')||!vout.includes('VERIFIED_TARBALL '))reject('npm verify-only output missing');
+  const tarLine=vout.split(/\r?\n/).find(x=>x.startsWith('VERIFIED_TARBALL '));
+  try{const p=JSON.parse(tarLine.slice('VERIFIED_TARBALL '.length));if(p.filename!=='deadbyte-mcp-0.15.63.tgz'||!hex(p.sha256)||p.bytes<1)reject('npm tarball identity invalid');}
+  catch{reject('npm tarball evidence invalid');}
+  return Object.freeze({status:'R165_RELEASE_READY_EVIDENCE_BOUND',version:'0.15.63',manifest_sha256:manifestSha,checks:6});
+}

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

@@ -0,0 +1,37 @@
+import {readFile,lstat} from 'node:fs/promises';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const required=(v,m)=>{if(!v)throw new Error('PUBLISH_BLOCKED R166 '+m)};
+const hex=s=>typeof s==='string'&&/^[a-f0-9]{64}$/.test(s);
+async function checkedFile(f,expected){
+  required(hex(expected),'missing log hash');
+  const s=await lstat(f);
+  required(s.isFile()&&!s.isSymbolicLink()&&s.size>0&&s.size<32*1024*1024,'invalid log');
+  const b=await readFile(f);required(sha(b)===expected,'log digest differs');return b.toString('utf8');
+}
+export async function assertR166NpmPublishReady(release,{root}={}){
+  required(release?.version==='0.15.64'&&release?.train==='R166'&&release?.r166?.scope==='WINDOWS_GATE_AND_SIGNED_PRECONDITION_RECOVERY_HOTFIX','candidate metadata invalid');
+  required(release?.parent?.release_id==='v0.15.61-055d1ff0aa99e60b'&&release?.source_predecessor?.version==='0.15.63','lineage mismatch');
+  const evidence=process.env.DEADBYTE_R166_CLOSURE_ROOT;
+  required(root&&path.isAbsolute(root)&&evidence&&path.isAbsolute(evidence),'closure root absent');
+  const allowed=path.resolve(root,'..','..','testing','r166-final-gate');
+  required(path.resolve(evidence).toLowerCase()===allowed.toLowerCase(),'closure root not in scoped testing folder');
+  const data=JSON.parse(await readFile(path.join(evidence,'closure.json'),'utf8'));
+  required(data?.schema==='deadbyte.r166-release-closure.v1'&&data.status==='PASS'&&data.version==='0.15.64','closure status mismatch');
+  required(data?.production_release_id===release.parent.release_id&&hex(data.manifest_sha256),'predecessor or manifest invalid');
+  required(data.manifest_sha256===sha(await readFile(path.join(root,'MANIFEST.SHA256'))),'final manifest drift');
+  const gate=await checkedFile(path.join(evidence,'windows-gate.protected.stdout.log'),data.gate_stdout_sha256);
+  const verify=await checkedFile(path.join(evidence,'npm-verify.stdout.log'),data.verify_stdout_sha256);
+  required(gate.includes('R166_WINDOWS_CANDIDATE_GATE=PASS_PREPUBLICATION')&&gate.includes('MANIFEST_VERIFY_OK')&&gate.includes('R166_STAGE_PASS=full'),'Windows full gate transcript incomplete');
+  const matches=[...gate.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(matches.length>0,'full TAP summary absent');
+  const full=matches.at(-1);
+  const tests=Number(full[1]),passes=Number(full[3]),fails=Number(full[4]),skips=Number(full[6]);
+  required(tests>=1960&&passes>=1908&&fails===0&&skips<=55&&passes+skips===tests,'full regression count mismatch');
+  required(verify.includes('VERIFY-ONLY PIPELINE PASS')&&verify.includes('Artifact isolation gate PASS')&&verify.includes('VERIFIED_TARBALL '),'exact npm tarball gate missing');
+  const tar=verify.split(/\r?\n/).find(x=>x.startsWith('VERIFIED_TARBALL '));
+  let identity;try{identity=JSON.parse(tar.slice('VERIFIED_TARBALL '.length));}catch{required(false,'tarball evidence malformed');}
+  required(identity.filename==='deadbyte-mcp-0.15.64.tgz'&&hex(identity.sha256)&&identity.bytes>0,'tarball subject invalid');
+  return Object.freeze({status:'R166_RELEASE_READY_EVIDENCE_BOUND',manifest_sha256:data.manifest_sha256,tests,passes,skips});
+}

package/src/activation-lock-r65.mjs

@@ -114,7 +114,7 @@ async function isSafeSignedPreconditionReject(outcome,lock,stateRoot){
      body.result!=='PRECONDITION_REJECTED'||body.phase!=='initial'||
      body.attempted_pointer!==null||body.rollback?.attempted!==false||
      !Array.isArray(body.rollback?.errors)||body.rollback.errors.length!==0||
-     !/^host command 'powershell_script' executable pin drift detected;/.test(String(body.error?.message??''))||
+     !(/^(?:host command 'powershell_script' executable pin drift detected;|windows release gate package script invalid$)/.test(String(body.error?.message??'')))||
      !Number.isFinite(failedTime)||failedTime<lockTime||failedTime>observedTime||
      !samePointerIdentity(body.prior_pointer,current))return false;
   return true;

package/src/deadbyte-cli.mjs

@@ -547,13 +547,33 @@ async function recoverRemoteSession(ctx,{displayMode='unicode'}={}){
     const historyAllowed=activePointer?.version===DEADBYTE_VERSION&&
       activePointer?.manifest_sha256===currentManifestSha256&&
       activePointer?.release_id===('v'+DEADBYTE_VERSION+'-'+currentManifestSha256.slice(0,16));
+    // R164: a different CLI version is not sufficient reason to replay a
+    // completed receipt. Only a verified ONLINE active predecessor may ignore
+    // completed history; pending, locator conflicts, and tampering still fail.
+    let onlinePredecessorReady=false;
+    if(!historyAllowed&&activePointer){
+      try{
+        const runtime=observedAuthority(ctx);
+        if(runtime.state==='ONLINE'){
+          assertRuntimeReadyObservation(runtime,{coreRoot:activePointer.release_root});
+          onlinePredecessorReady=true;
+        }
+      }catch{onlinePredecessorReady=false;}
+    }
     const selected=await selectLegacyMarkerEvidence({evidenceDir,activePointer,
-      allowCompletedHistory:historyAllowed});
+      allowCompletedHistory:historyAllowed||onlinePredecessorReady});
     if(selected.kind==='none')return null;
     if(selected.kind==='completed_history_ambiguous'){
-      if(!historyAllowed)throw new Error('R159 completed history cannot be reused across a release change');
-      // Nothing is pending: do not select an arbitrary completed receipt.
-      // A future upgrade still requires its own exact signed migration proof.
+      if(!historyAllowed){
+        if(!onlinePredecessorReady)throw new Error('R164 completed history requires a verified ONLINE predecessor');
+        const readback=await readActiveRuntimeBinding(ctx.root);
+        for(const key of ['release_id','version','manifest_sha256','generation_manifest_sha256'])
+          if(readback?.[key]!==activePointer?.[key])
+            throw new Error('R164 predecessor changed during completed-history classification');
+        assertRuntimeReadyObservation(observedAuthority(ctx),{coreRoot:readback.release_root});
+      }
+      // Every completed receipt was validated by R159 and no pending intent
+      // exists. Do not adopt any receipt as an upgrade/migration authority.
       return null;
     }
     if(selected.kind==='located'){

package/src/release-generation.mjs

@@ -87,7 +87,7 @@ async function currentWindowsGateScript(rootPath){
   try{ pkg=JSON.parse(await readFile(packagePath,'utf8')); }
   catch{ throw new Error('windows release gate package.json malformed'); }
   const command=String(pkg?.scripts?.['gate:windows']??'').trim();
-  const match=/^powershell(?:\.exe)?\s+-NoProfile\s+-ExecutionPolicy\s+Bypass\s+-File\s+(scripts\/[A-Za-z0-9._\/-]+\.ps1)$/i.exec(command);
+  const match=/^powershell(?:\.exe)?\s+-NoProfile\s+-ExecutionPolicy\s+Bypass\s+-File\s+(scripts\/[A-Za-z0-9._\/-]+\.ps1)(?:\s+-Stage\s+all)?$/i.exec(command);
   if(!match) throw new Error('windows release gate package script invalid');
   return safeRel(match[1]);
 }

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.62';
+export const DEADBYTE_VERSION = '0.15.64';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/r130-release-security-contract.test.mjs

@@ -13,13 +13,13 @@ test('R130 security patch has a new immutable package identity and truthful sour
     read('SBOM.cdx.json'),read('package-lock.json'),read('TEST-MATRIX.json')]);
   assert.equal(pkg.name,'deadbyte-mcp');
   for(const actual of [pkg.version,release.version,provenance.version,matrix.version,bom.metadata.component.version,lock.version,lock.packages[''].version,DEADBYTE_VERSION])
-    assert.equal(actual,'0.15.62');
-  assert.equal(release.train,'R160');
-  assert.equal(matrix.train,'R160');
-  assert.equal(release.source_predecessor.version,'0.15.61');
-  assert.equal(release.source_predecessor.train,'R159');
-  assert.match(release.source_predecessor.source_path,/r159-marker-reconcile/i);
-  assert.equal(release.source_predecessor.manifest_status,'STALE_REJECTED');
+    assert.equal(actual,'0.15.64');
+  assert.equal(release.train,'R166');
+  assert.equal(matrix.train,'R166');
+  assert.equal(release.source_predecessor.version,'0.15.63');
+  assert.equal(release.source_predecessor.train,'R165');
+  assert.match(release.source_predecessor.source_path,/0\.15\.63-r165-remote-recovery/i);
+  assert.equal(release.source_predecessor.manifest_status,'VERIFIED_FINAL_BYTES');
   assert.equal(release.runtime_predecessor.version,'0.15.61');
   assert.equal(provenance.r160.source_predecessor_manifest_status,'STALE_REJECTED');
   assert.equal(pkg.dependencies['@modelcontextprotocol/client'],'2.3.1');

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

@@ -8,19 +8,23 @@ import {DEADBYTE_VERSION} from '../src/version.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 
-test('R160 package identities retain R132 historic evidence and separate the development predecessor',async()=>{
+test('R166 package identity preserves R132 evidence and published source predecessor',async()=>{
   const [pkg,lock,release,prov,bom,matrix]=await Promise.all([
     read('package.json'),read('package-lock.json'),read('RELEASE.json'),
     read('PROVENANCE.json'),read('SBOM.cdx.json'),read('TEST-MATRIX.json')]);
   for(const value of [pkg.version,lock.version,lock.packages[''].version,release.version,prov.version,bom.metadata.component.version,matrix.version,DEADBYTE_VERSION]){
     assert.equal(value,pkg.version);
   }
-  assert.equal(release.train,'R160');
-  assert.equal(matrix.train,'R160');
-  assert.equal(release.source_predecessor.version,'0.15.61');
-  assert.equal(release.source_predecessor.train,'R159');
-  assert.match(release.source_predecessor.source_path,/r159-marker-reconcile/i);
+  assert.equal(release.train,'R166');
+  assert.equal(matrix.train,'R166');
+  assert.equal(release.source_predecessor.version,'0.15.63');
+  assert.equal(release.source_predecessor.train,'R165');
+  assert.match(release.source_predecessor.source_path,/0\.15\.63-r165-remote-recovery/i);
   assert.equal(prov.r160.source_predecessor_manifest_status,'STALE_REJECTED');
+  assert.equal(release.r165.published_source_manifest_sha256,'4adf7d94682fbb71c4a91eb3147ecc48076bbc5d79cb67fcb875cde6a1bb4805');
+  assert.equal(release.r165.published_source_tarball_sha256,'812e97609b7c51353ed25f2202129737e43bb4fbe0778c3adec43ec065352641');
+  assert.equal(release.source_predecessor.tarball_sha256,'3bcd89c00fca98428aab6791b545bcfd0c62323349ee9de819aae4041d170406');
+  assert.equal(prov.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
   assert.equal(release.runtime_predecessor.version,'0.15.61');
   assert.equal(prov.runtime_predecessor.release_id,release.runtime_predecessor.release_id);
   assert.equal(prov.runtime_predecessor.manifest_sha256,release.runtime_predecessor.manifest_sha256);

package/test/r153-prepublish-identity.test.mjs

@@ -26,7 +26,7 @@ test('R153 historical verifier refuses current R160 package identity',async()=>{
  const state={pkg:JSON.parse(await readFile(path.join(root,'package.json'),'utf8')),
   release:JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8')),
   bridge:JSON.parse(await readFile(path.join(root,'bridge/package.json'),'utf8'))};
- assert.equal(state.pkg.version,'0.15.62');
+ assert.equal(state.pkg.version,'0.15.64');
  assert.throws(()=>verifyR153Lineage(state),/package version/);
  await assert.rejects(verifyR153IdentityTree(root),/package version/);
 });

package/test/r159-legacy-marker-evidence.test.mjs

@@ -72,7 +72,10 @@ test('R159 two unlocated completed current receipts remain ambiguous',async t=>{
 });
 test('R159 remote foreground code routes historical locators through subject selection',async()=>{
  const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
- assert.match(cli,/selectLegacyMarkerEvidence\(\{evidenceDir,activePointer,\s*allowCompletedHistory:historyAllowed\}\)/);
+ assert.match(cli,/selectLegacyMarkerEvidence\(\{evidenceDir,activePointer,\s*allowCompletedHistory:historyAllowed\|\|onlinePredecessorReady\}\)/);
+ assert.match(cli,/assertRuntimeReadyObservation\(runtime,\{coreRoot:activePointer\.release_root\}\)/);
+ assert.match(cli,/R164 predecessor changed during completed-history classification/);
+ assert.match(cli,/assertRuntimeReadyObservation\(observedAuthority\(ctx\),\{coreRoot:readback\.release_root\}\)/);
  assert.match(cli,/R159 active release changed during marker recovery/);
  assert.match(cli,/marker-'\+reconciled\.marker_sha256\+'\.locator\.json'/);
  assert.doesNotMatch(cli,/publishExclusiveJson\(locatorPath,locator\)/);

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

@@ -13,15 +13,15 @@ test('R160 package identity separates source and live runtime predecessors',asyn
     read('package.json'),read('package-lock.json'),read('bridge/package.json'),read('RELEASE.json'),
     read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
   for(const version of [pkg.version,lock.version,lock.packages[''].version,bridge.version,release.version,
-    provenance.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION]) assert.equal(version,'0.15.62');
-  assert.equal(release.train,'R160');
-  assert.equal(matrix.train,'R160');
+    provenance.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION]) assert.equal(version,'0.15.64');
+  assert.equal(release.train,'R166');
+  assert.equal(matrix.train,'R166');
   assert.equal(release.runtime_predecessor.version,'0.15.61');
   assert.equal(release.runtime_predecessor.release_id,'v0.15.61-055d1ff0aa99e60b');
   assert.equal(release.runtime_predecessor.manifest_sha256,'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf');
   assert.equal(release.runtime_predecessor.generation_manifest_sha256,'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4');
-  assert.equal(release.source_predecessor.train,'R159');
-  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.62-r159-marker-reconcile/i);
+  assert.equal(release.source_predecessor.train,'R165');
+  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.63-r165-remote-recovery/i);
   assert.equal(release.r160.public_tool_delta,0);
   assert.equal(release.r160.authority_scope_delta,0);
   assert.equal(release.r160.production_activation,'NOT_RUN');

package/test/r163-isolated-slot-rollback-restore.test.mjs

@@ -8,7 +8,7 @@ import {fileURLToPath} from 'node:url';
 import {atomicWriteActivePointer,materializeReleaseSlot,parseActivePointer,parseManifest,renderStableLauncherPs1,verifyManifestTreeExact} from '../src/release-slot.mjs';
 
 const candidate=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const version='0.15.62';
+const version='0.15.64';
 const parent=path.join(os.homedir(),'.deadbyte-mcp','releases','v0.15.61-055d1ff0aa99e60b');
 const parentDigest='055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf';
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
@@ -21,7 +21,7 @@ async function generation(state,label){
   await writeFile(path.join(root,'GENERATION.SHA256'),manifest,{flag:'wx'});
   return {root,manifest_sha256:sha(manifest),config_path:path.join(root,'controller-config.psd1')};
 }
-test('R163 isolated immutable slot activates, rolls back, and restores 0.15.62 without authority or production mutation',async()=>{
+test('R166 isolated immutable slot activates, rolls back, and restores 0.15.64 without authority or production mutation',async()=>{
   const stateBase=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r163-isolated-'));
   const state=path.join(stateBase,'state');
   try{
@@ -33,8 +33,8 @@ test('R163 isolated immutable slot activates, rolls back, and restores 0.15.62 w
     const nextDigest=sha(nextManifest);
     const parentSlot=await materializeReleaseSlot({source:parent,stateRoot:state,version:'0.15.61',manifestSha256:parentDigest});
     const nextSlot=await materializeReleaseSlot({source:candidate,stateRoot:state,version,manifestSha256:nextDigest});
-    const pGen=await generation(state,'r163-parent');
-    const nGen=await generation(state,'r163-next');
+    const pGen=await generation(state,'r165-parent');
+    const nGen=await generation(state,'r165-next');
     const launcherSha=sha(Buffer.from(renderStableLauncherPs1(),'utf8'));
     const pointerPath=path.join(state,'active-release.json');
     const ptr=(slot,ver,g)=>({schema:'deadbyte.active-release.v1',release_id:slot.release_id,version:ver,

package/test/r164-remote-history-skew.test.mjs

@@ -0,0 +1,13 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+test('R164 current ONLINE predecessor permits completed-history classification, not receipt adoption',async()=>{
+ const cli=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
+ assert.match(cli,/assertRuntimeReadyObservation\(runtime,\{coreRoot:activePointer\.release_root\}\)/);
+ assert.match(cli,/allowCompletedHistory:historyAllowed\|\|onlinePredecessorReady/);
+ assert.match(cli,/R164 predecessor changed during completed-history classification/);
+ assert.match(cli,/assertRuntimeReadyObservation\(observedAuthority\(ctx\),\{coreRoot:readback\.release_root\}\)/);
+ assert.match(cli,/if\(!onlinePredecessorReady\)throw new Error/);
+ assert.match(cli,/do not adopt any receipt as an upgrade\/migration authority/i);
+});

package/test/r165-live-cli-skew.test.mjs

@@ -0,0 +1,90 @@
+// Executable foreground CLI proof. All runtime state is created under a fresh OS temp dir.
+// The fake controller intentionally rejects disarmhost, BEFORE any production deployment.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,writeFile,readdir,rm} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import os from 'node:os';
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const envRoot=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const expectedManifest=null;
+const predecessor={version:'0.15.61',release_id:'v0.15.61-055d1ff0aa99e60b',manifest_sha256:'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf',generation_manifest_sha256:'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4'};
+const gate=process.platform==='win32'?test:test.skip;
+const hashMarker=c=>c.repeat(64);
+async function fixture(t,kind){
+  assert.equal(typeof envRoot,'string'); assert.ok(path.isAbsolute(envRoot));
+  assert.match(sha(await readFile(path.join(envRoot,'MANIFEST.SHA256'))),/^[0-9a-f]{64}$/);
+  assert.equal(JSON.parse(await readFile(path.join(envRoot,'package.json'),'utf8')).version,'0.15.64');
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r164-skew-e2e-'));
+  t.after(async()=>{await rm(dir,{recursive:true,force:true,maxRetries:10,retryDelay:150});});
+  const state=path.join(dir,'state'),bin=path.join(state,'bin');
+  const legacy=path.join(state,'evidence','legacy-migration');
+  const trace=path.join(dir,'controller.trace');
+  const releaseRoot=path.join(state,'releases','predecessor');
+  const generationRoot=path.join(state,'generations','predecessor');
+  await mkdir(bin,{recursive:true});await mkdir(legacy,{recursive:true});
+  const pointer={schema:'deadbyte.active-release.v1',...predecessor,release_root:releaseRoot,generation_root:generationRoot,launcher_sha256:hashMarker('9'),config_path:path.join(generationRoot,'controller-config.psd1')};
+  await writeFile(path.join(state,'active-release.json'),JSON.stringify(pointer)+'\n','utf8');
+  // The true CLI calls this local PowerShell stub; a hard stop precedes deploy.
+  const ps=`param([string]$Command,[switch]$Json)\n$ErrorActionPreference='Stop'\n[IO.File]::AppendAllText($env:DEADBYTE_SKEW_E2E_TRACE,($Command+[Environment]::NewLine),[Text.Encoding]::UTF8)\nif($Command -eq 'status' -and $Json){\n $auth=@{};foreach($id in @('process','coding','autonomous','desktop','host')){$auth[$id]=@{configured=$true;armed=$false;reason='disarmed'}}\n @{schema='deadbyte.controller-observation.v1';state=$env:DEADBYTE_SKEW_E2E_RUNTIME_STATE;local_ready=$true;core_root=$env:DEADBYTE_SKEW_E2E_CORE_ROOT;bridge=@{alive=$true;reason='verified'};core=@{alive=$true;reason='verified'};cloud=@{alive=$true;reason='verified'};supervisor=@{running=$true};authority=$auth}|ConvertTo-Json -Depth 6 -Compress;exit 0\n}\nif($Command -eq 'disarmhost'){[Console]::Error.WriteLine('R164_INTENTIONAL_PREDEPLOY_STOP');exit 93}\nWrite-Error ('R164_UNEXPECTED_CONTROLLER_OPERATION '+$Command);exit 99\n`;
+  await writeFile(path.join(bin,'DEADBYTE-MCP.ps1'),ps,'utf8');
+  const currentIds=['a','b'];
+  for(const id of currentIds){
+    const marker=hashMarker(id),intent={schema:'deadbyte.r153-marker-reconciliation-intent.v1',state:'RECONCILIATION_CLAIMED',marker_sha256:marker,predecessor,subject_sha256:hashMarker('7')};
+    const intentBytes=Buffer.from(JSON.stringify(intent)+'\n');
+    const terminal={schema:'deadbyte.r153-marker-reconciliation.v1',state:'MARKER_RECONCILED',marker_sha256:marker,predecessor,intent_sha256:sha(intentBytes),subject_sha256:hashMarker('8')};
+    await writeFile(path.join(legacy,`marker-${marker}.intent.json`),intentBytes,{flag:'wx'});
+    await writeFile(path.join(legacy,`marker-${marker}.terminal.json`),JSON.stringify(terminal)+'\n',{flag:'wx'});
+  }
+  if(kind==='pending'){
+    const marker=hashMarker('c'),intent={schema:'deadbyte.r153-marker-reconciliation-intent.v1',state:'RECONCILIATION_CLAIMED',marker_sha256:marker,predecessor,subject_sha256:hashMarker('7')};
+    await writeFile(path.join(legacy,`marker-${marker}.intent.json`),JSON.stringify(intent)+'\n',{flag:'wx'});
+  }
+  if(kind==='tampered'){
+    const p=path.join(legacy,`marker-${hashMarker('b')}.terminal.json`);
+    const terminal=JSON.parse(await readFile(p,'utf8'));
+    terminal.intent_sha256=hashMarker('0');
+    await writeFile(p,JSON.stringify(terminal)+'\n');
+  }
+  const before=await Promise.all((await readdir(legacy)).sort().map(async name=>[name,sha(await readFile(path.join(legacy,name)))]));
+  const env={...process.env,DEADBYTE_STATE_ROOT:state,DEADBYTE_SKEW_E2E_TRACE:trace,DEADBYTE_SKEW_E2E_CORE_ROOT:releaseRoot,DEADBYTE_SKEW_E2E_RUNTIME_STATE:kind==='offline'?'OFFLINE':'ONLINE'};
+  return {dir,state,legacy,trace,env,before};
+}
+async function run(fx){
+ const cli=path.join(envRoot,'src','deadbyte-cli.mjs');
+ const result=spawnSync(process.execPath,[cli,'remote'],{env:fx.env,cwd:fx.dir,windowsHide:true,shell:false,encoding:'utf8',timeout:45000,maxBuffer:2*1024*1024});
+ if(result.error)throw result.error;
+ assert.equal(result.status,1,'expected hard stop BEFORE deploy');
+ const after=await Promise.all((await readdir(fx.legacy)).sort().map(async name=>[name,sha(await readFile(path.join(fx.legacy,name)))]));
+ assert.deepEqual(after,fx.before,'reconciliation evidence mutated');
+ await assert.rejects(readFile(path.join(fx.state,'runtime','remote-session.json')),{code:'ENOENT'});
+ let trace='';try{trace=await readFile(fx.trace,'utf8');}catch(e){if(e.code!=='ENOENT')throw e;}
+ assert.doesNotMatch(trace,/\b(?:start|restart|armprocess|armcoding|armautonomous|deploy)\b/i,'unexpected runtime operation');
+ return {output:(result.stderr||'')+'\n'+(result.stdout||''),trace};
+}
+gate('R165 executable CLI passes completed R159 history, reaches 0.15.61 -> 0.15.64 synchronization safely',async t=>{
+ const fx=await fixture(t,'completed');
+ const r=await run(fx);
+ assert.match(r.output,/runtime coherence 'disarmhost' failed exit=93/i,r.output);
+ assert.doesNotMatch(r.output,/R159 ambiguous multiple completed/i);
+ assert.match(r.trace,/disarmhost/);
+ assert.doesNotMatch(r.trace,/disarmdesktop/);
+});
+gate('R165 executable CLI rejects pending current reconciliation before upgrade',async t=>{
+ const fx=await fixture(t,'pending'),r=await run(fx);
+ assert.match(r.output,/pending marker reconciliation requires an offline runtime/i,r.output);
+ assert.doesNotMatch(r.trace,/disarmhost/);
+});
+gate('R165 executable CLI rejects tampered terminal before upgrade',async t=>{
+ const fx=await fixture(t,'tampered'),r=await run(fx);
+ assert.match(r.output,/terminal intent\/subject mismatch|terminal.*mismatch/i,r.output);
+ assert.doesNotMatch(r.trace,/disarmhost/);
+});
+gate('R165 executable CLI keeps ambiguous history fail-closed when predecessor is not ONLINE',async t=>{
+ const fx=await fixture(t,'offline'),r=await run(fx);
+ assert.match(r.output,/R159 ambiguous multiple completed reconciliation receipts/i,r.output);
+ assert.doesNotMatch(r.trace,/disarmhost/);
+});

package/test/r165-publish-fence.test.mjs

@@ -0,0 +1,13 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {assertR165NpmPublishReady} from '../scripts/npm-release-readiness-r165.mjs';
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const release={name:'deadbyte-mcp',version:'0.15.63',train:'R165',r165:{publication_mode:'PUBLISH_ONLY'},parent:{release_id:'v0.15.61-055d1ff0aa99e60b',manifest_sha256:'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf',generation_manifest_sha256:'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4'},runtime_predecessor:{release_id:'v0.15.61-055d1ff0aa99e60b'}};
+test('R165 publish gate fails closed with missing evidence',async()=>{
+ await assert.rejects(()=>assertR165NpmPublishReady(release,{root,evidenceRoot:null}),/PUBLISH_BLOCKED R165/);
+});
+test('R165 publish gate rejects changed parent identity before evidence read',async()=>{
+ await assert.rejects(()=>assertR165NpmPublishReady({...release,parent:{...release.parent,release_id:'v0.15.60-wrong'}},{root}),/predecessor lineage mismatch/);
+});

package/test/r166-hotfix-contract.test.mjs

@@ -0,0 +1,27 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+const release = await readFile(new URL('../src/release-generation.mjs',import.meta.url),'utf8');
+const gate = await readFile(new URL('../scripts/gate-windows-r166.ps1',import.meta.url),'utf8');
+const pkg = JSON.parse(await readFile(new URL('../package.json',import.meta.url),'utf8'));
+const lock = await readFile(new URL('../src/activation-lock-r65.mjs',import.meta.url),'utf8');
+test('exact Windows gate grammar supports only optional Stage all',()=>{
+  const line = release.split('\n').find(x=>x.includes('const match=/^powershell'));
+  assert.ok(line);
+  const regexSource=line.slice(line.indexOf('const match=')+12,line.lastIndexOf('.exec(command)'));
+  const regex=Function(`return ${regexSource}`)();
+  assert.ok(regex.test(pkg.scripts['gate:windows']));
+  assert.equal(regex.test(pkg.scripts['gate:windows']+'; echo injected'),false);
+  assert.equal(regex.test(pkg.scripts['gate:windows'].replace('all','focused')),false);
+});
+test('corrected gate matches candidate identity',()=>{
+  assert.match(gate,/R166_CANDIDATE_VERSION_DRIFT/);
+  assert.match(gate,/\$pkg.version -ne '0.15.64'/);
+  assert.match(gate,/\$release.train -ne 'R166'/);
+});
+test('recovery is restricted to exact recognized signed preconditions',()=>{
+  assert.match(lock,/windows release gate package script invalid\$/);
+  assert.match(lock,/verifySlotUpdateEnvelope\(signed,publicKey\)/);
+  assert.match(lock,/body.phase!=='initial'/);
+  assert.match(lock,/body.attempted_pointer!==null/);
+});

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

@@ -0,0 +1,10 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import {assertR166NpmPublishReady} from '../scripts/npm-release-readiness-r166.mjs';
+test('R166 publication refuses absent external closure',async()=>{
+  const release=JSON.parse(await readFile(new URL('../RELEASE.json',import.meta.url)));
+  const old=process.env.DEADBYTE_R166_CLOSURE_ROOT;
+  try{delete process.env.DEADBYTE_R166_CLOSURE_ROOT;await assert.rejects(assertR166NpmPublishReady(release,{root:new URL('..',import.meta.url).pathname}),/PUBLISH_BLOCKED R166/);}
+  finally{if(old===undefined)delete process.env.DEADBYTE_R166_CLOSURE_ROOT;else process.env.DEADBYTE_R166_CLOSURE_ROOT=old;}
+});

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'].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'].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');