deadbyte-mcp 0.15.65 → 0.15.67

package/src/activation-reconciliation-receipt-store-r168.mjs

@@ -0,0 +1,42 @@
+// R168 exclusive storage for *authorization-only* receipts.
+// Does not sign an owner approval, terminalize claims or invoke native deletion.
+import {createHash} from 'node:crypto';
+import {lstat,open,readFile,realpath} from 'node:fs/promises';
+import path from 'node:path';
+import {verifyR168SignedAuthorization} from './activation-reconciliation-consent-r168.mjs';
+
+const SHA=/^[a-f0-9]{64}$/;
+const digest=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+export async function persistR168OneUseAuthorization({
+  evidenceDir,subject,approval,receipt,ownerPublicKey,machinePublicKey,now
+}={}){
+  verifyR168SignedAuthorization({subject,approval,receipt,ownerPublicKey,machinePublicKey,now});
+  if(typeof evidenceDir!=='string'||!path.isAbsolute(evidenceDir))
+    throw new Error('R168 receipt evidence directory must be absolute');
+  const dir=path.resolve(evidenceDir);
+  const stats=await lstat(dir);
+  if(!stats.isDirectory()||stats.isSymbolicLink()||path.resolve(await realpath(dir))!==dir)
+    throw new Error('R168 receipt directory not a real bounded directory');
+  const nonce=approval.body.nonce;
+  if(!SHA.test(String(nonce)))throw new Error('R168 receipt one-use nonce invalid');
+  const file=path.join(dir,'r168-reconciliation-authorization-'+nonce+'.json');
+  const data=Buffer.from(JSON.stringify({
+    schema:'deadbyte.r168-reconciliation-authorization-record.v1',
+    status:'PREPARED_ONLY',
+    owner_approval:approval,
+    receipt
+  })+'\n','utf8');
+  if(data.length>32768)throw new Error('R168 authorization receipt oversized');
+  let handle;
+  try{handle=await open(file,'wx',0o600);}
+  catch(error){if(error?.code==='EEXIST')throw new Error('R168 one-use receipt already exists; no-clobber');throw error;}
+  try{
+    await handle.writeFile(data);
+    await handle.sync();
+  }finally{await handle.close();}
+  const observed=await readFile(file);
+  if(!observed.equals(data))throw new Error('R168 one-use authorization receipt changed during verification');
+  return Object.freeze({path:file,sha256:digest(data),bytes:data.length,
+    terminalization_committed:false,activation_authorized:false});
+}

package/src/activation-reconciliation-terminal-r168.mjs

@@ -0,0 +1,111 @@
+// R168 cryptographic terminal-result contract. Pure: no CAS, filesystem,
+// owner-key discovery or authority mutation occurs here. A protected caller
+// must obtain every 'after' field from native handle-bound observations under
+// its five-plane epoch fence before invoking this contract.
+import {createHash,createPublicKey,sign,verify} from 'node:crypto';
+import {canonicalJson} from './canonical-json.mjs';
+import {verifyR168SignedAuthorization} from './activation-reconciliation-consent-r168.mjs';
+
+const DOMAIN='DEADBYTE-R168-TERMINAL-RESULT-V1';
+const SHA=/^[0-9a-f]{64}$/;
+const PLANES=['process','coding','autonomous','desktop','host'];
+const hash=body=>createHash('sha256').update(Buffer.from(canonicalJson(body),'utf8')).digest('hex');
+const message=body=>Buffer.concat([Buffer.from(DOMAIN+'\0','utf8'),
+  Buffer.from(canonicalJson(body),'utf8')]);
+function requireR168(ok,reason){if(!ok)throw new Error('R168 terminal '+reason);}
+
+function verifiedAfter(subject,after){
+  requireR168(after&&typeof after==='object'&&!Array.isArray(after)&&
+    Object.keys(after).length===8&&
+    ['native_cas_result','claim_absent','pointer_sha256','old_outcome_sha256',
+      'coding_policy_sha256','coding_grant_sha256','coding_epoch_sha256','epoch_history']
+      .every(k=>Object.hasOwn(after,k)),'post-CAS evidence field shape invalid');
+  requireR168(after.native_cas_result==='REMOVED'&&after.claim_absent===true,
+    'claim native CAS removal and absence not verified');
+  requireR168(after.pointer_sha256===subject.predecessor_pointer_sha256,
+    'predecessor pointer changed');
+  requireR168(after.old_outcome_sha256===subject.old_outcome_sha256,
+    'old outcome evidence changed');
+  requireR168(after.coding_policy_sha256===subject.coding_policy_sha256&&
+    after.coding_grant_sha256===subject.coding_grant_sha256&&
+    after.coding_epoch_sha256===subject.coding_epoch_sha256,
+    'Coding grant/epoch changed after CAS');
+  requireR168(after.epoch_history&&typeof after.epoch_history==='object'&&
+    Object.keys(after.epoch_history).length===PLANES.length&&
+    canonicalJson(after.epoch_history)===canonicalJson(subject.epoch_history),
+    'signed five-plane epoch history changed after CAS');
+}
+
+function expectedBody({subject,prepared,after,now}){
+  verifiedAfter(subject,after);
+  requireR168(SHA.test(String(prepared?.receipt_sha256)), 'prepared receipt digest invalid');
+  return Object.freeze({
+    schema:'deadbyte.r168-terminal-result.v1',
+    action:'terminalize_unknown_without_replay',
+    subject_sha256:subject.subject_sha256,
+    prepared_receipt_sha256:prepared.receipt_sha256,
+    claim_file_sha256:subject.claim_file_sha256,claim_file_id:subject.claim_file_id,
+    old_outcome_sha256:after.old_outcome_sha256,
+    predecessor_pointer_sha256:after.pointer_sha256,
+    coding_policy_sha256:after.coding_policy_sha256,
+    coding_grant_sha256:after.coding_grant_sha256,
+    coding_epoch_sha256:after.coding_epoch_sha256,
+    epoch_history:structuredClone(after.epoch_history),
+    native_cas_result:'REMOVED',claim_absent:true,
+    observed_at_utc:now,
+    terminalization_committed:true,activation_authorized:false
+  });
+}
+
+export function createR168TerminalResult({
+  subject,approval,prepared,ownerPublicKey,machinePrivateKey,after,now
+}={}){
+  requireR168(machinePrivateKey?.asymmetricKeyType==='ed25519'&&machinePrivateKey?.type==='private',
+    'trusted machine signing key invalid');
+  const machinePublicKey=createPublicKey(machinePrivateKey);
+  verifyR168SignedAuthorization({subject,approval,receipt:prepared,
+    ownerPublicKey,machinePublicKey,now});
+  const body=expectedBody({subject,prepared,after,now});
+  const signature=sign(null,message(body),machinePrivateKey);
+  const unsigned={body,body_sha256:hash(body),
+    attestation:{algorithm:'ed25519',domain:DOMAIN,signature_base64:signature.toString('base64')}};
+  return Object.freeze({...unsigned,receipt_sha256:hash(unsigned)});
+}
+
+export function verifyR168TerminalResult({
+  subject,approval,prepared,terminal,ownerPublicKey,machinePublicKey,after,now
+}={}){
+  // Archived evidence remains verifiable after one-time approval expiry, but
+  // only if the signed preparation AND terminal observation occurred inside
+  // that original approval interval. Never interpret replay as live consent.
+  verifyR168SignedAuthorization({subject,approval,receipt:prepared,
+    ownerPublicKey,machinePublicKey,now:prepared?.body?.created_at_utc});
+  const terminalTime=terminal?.body?.observed_at_utc;
+  const observed=Date.parse(terminalTime),preparedAt=Date.parse(prepared?.body?.created_at_utc);
+  const expires=Date.parse(approval?.body?.expires_at_utc);
+  const checkTime=Date.parse(now??new Date().toISOString());
+  requireR168(typeof terminalTime==='string'&&
+    terminalTime.length===24&&terminalTime.endsWith('Z')&&
+    Number.isFinite(observed)&&new Date(observed).toISOString()===terminalTime&&
+    Number.isFinite(checkTime)&&observed>=preparedAt&&observed<expires&&observed<=checkTime,
+    'terminal observation time outside approved window or in the future');
+  const expected=expectedBody({subject,prepared,after,now:terminalTime});
+  requireR168(terminal?.body&&canonicalJson(terminal.body)===canonicalJson(expected),
+    'terminal result body differs from verified post-CAS evidence');
+  requireR168(terminal.body_sha256===hash(terminal.body),
+    'terminal result body digest invalid');
+  const {receipt_sha256,...unsigned}=terminal;
+  requireR168(receipt_sha256===hash(unsigned),'terminal result receipt digest mismatch');
+  requireR168(terminal.attestation?.algorithm==='ed25519'&&terminal.attestation?.domain===DOMAIN,
+    'terminal result attestation identity invalid');
+  const encoded=terminal.attestation.signature_base64;
+  const signature=Buffer.from(String(encoded??''),'base64');
+  requireR168(signature.length===64&&signature.toString('base64')===encoded,
+    'terminal result signature encoding invalid');
+  const key=machinePublicKey?.type==='public'&&machinePublicKey?.asymmetricKeyType==='ed25519'?
+    machinePublicKey:createPublicKey(machinePublicKey);
+  requireR168(key.asymmetricKeyType==='ed25519'&&
+    verify(null,message(terminal.body),key,signature),
+    'terminal result machine signature invalid');
+  return true;
+}

package/src/active-controller-delegation-r169.mjs

@@ -0,0 +1,57 @@
+// R169 pre-dispatch identity fence. Only routes an explicit user-issued
+// authority command to the already installed controller, never upgrades or
+// fabricates an authority grant.
+import {createHash} from 'node:crypto';
+import {lstat,readFile,realpath} from 'node:fs/promises';
+import path from 'node:path';
+
+const SHA=/^[0-9a-f]{64}$/;
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+function deny(condition,reason){if(!condition)throw new Error('R169 installed controller '+reason);}
+const canonical=pathName=>path.win32.normalize(path.win32.resolve(pathName)).toLowerCase();
+function descendant(parent,child){
+  const r=path.win32.relative(parent,child);
+  return r!==''&&r!=='..'&&!r.startsWith('..'+path.win32.sep)&&!path.win32.isAbsolute(r);
+}
+async function fileBytes(file){
+  const before=await lstat(file);
+  deny(before.isFile()&&!before.isSymbolicLink()&&before.size>0&&before.size<=8*1024*1024,
+    'file not regular or bounded');
+  deny(canonical(await realpath(file))===canonical(file),'file reparse not allowed');
+  const bytes=await readFile(file);
+  deny(bytes.length===before.size,'file length changed');
+  return bytes;
+}
+export async function assertR169PinnedActiveDelegation({stateRoot,launcherPath,active}={}){
+  deny(process.platform==='win32','Windows only');
+  deny(typeof stateRoot==='string'&&path.win32.isAbsolute(stateRoot),'state root invalid');
+  deny(active&&typeof active==='object'&&
+    SHA.test(String(active.manifest_sha256))&&
+    SHA.test(String(active.generation_manifest_sha256))&&
+    SHA.test(String(active.launcher_sha256))&&
+    typeof active.release_id==='string'&&
+    typeof active.release_root==='string'&&
+    typeof active.generation_root==='string'&&
+    typeof active.config_path==='string','active release binding incomplete');
+  const root=path.win32.resolve(stateRoot);
+  const expectedLauncher=path.win32.join(root,'bin','DEADBYTE-MCP.ps1');
+  deny(canonical(launcherPath)===canonical(expectedLauncher),'launcher path not active stable launcher');
+  deny(descendant(path.win32.join(root,'releases'),active.release_root)&&
+    descendant(path.win32.join(root,'generations'),active.generation_root),
+    'release/generation escapes state root');
+  deny(canonical(active.config_path)===canonical(path.win32.join(active.generation_root,'controller-config.psd1')),
+    'generation controller config not bound');
+  const launcher=await fileBytes(launcherPath);
+  deny(hash(launcher)===active.launcher_sha256,'launcher digest mismatch');
+  const releaseManifest=await fileBytes(path.win32.join(active.release_root,'MANIFEST.SHA256'));
+  deny(hash(releaseManifest)===active.manifest_sha256,'release manifest digest mismatch');
+  const generationManifest=await fileBytes(path.win32.join(active.generation_root,'GENERATION.SHA256'));
+  deny(hash(generationManifest)===active.generation_manifest_sha256,
+    'generation manifest digest mismatch');
+  // Installed PowerShell launcher enforces its own identity/generation/
+  // controller provenance again before invoking the actual controller.
+  return Object.freeze({release_id:active.release_id,version:active.version,
+    launcher_sha256:active.launcher_sha256,manifest_sha256:active.manifest_sha256,
+    generation_manifest_sha256:active.generation_manifest_sha256,
+    activation_attempted:false});
+}

package/src/deadbyte-cli.mjs

@@ -19,6 +19,8 @@ import { printDoctor } from './doctor-r45.mjs';
 import { classifyRemoteAuditOutcome, createLiveTimelineFilter, createLiveTimelineTracker, createLiveTimelineWriter, defaultForegroundTimelineOptions, formatRemoteLogResetNotice, formatCompactAuditEvent, formatRemoteLifecycle, formatRemoteToolCall, formatRuntimeDiagnosticLine, selectLiveLogNames } from './remote-live-log.mjs';
 import { prepareRemoteConsole, remoteDisplayText } from './remote-console.mjs';
 import { ensureRuntimeCoherence } from './runtime-coherence.mjs';
+import {selectR168OneShotRemotePath} from './remote-one-shot-coherence-r168.mjs';
+import {assertR169PinnedActiveDelegation} from './active-controller-delegation-r169.mjs';
 import { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
 import {foregroundIdentityMatches,queryForegroundIdentity,validForegroundIdentity,proveRestrictedPidReuse} from './foreground-process-identity.mjs';
@@ -787,6 +789,16 @@ async function runRemoteSession({resumeCursor=null,verbose=false,trace=false,fil
   const display=prepareRemoteConsole();
   const displayMode=display.mode;
   const ctx=await remoteContext();
+  // Never attempt automatic activation or cleanup from an npm-cache build on
+  // an EPOCH_NATIVE production runtime. This guard precedes session recovery,
+  // marker claims, revocations and any controller startup.
+  const active=await readActiveRuntimeBinding(ctx.root);
+  if(active){
+    const decision=selectR168OneShotRemotePath({command:'start',active,cliVersion:DEADBYTE_VERSION});
+    if(decision.mode==='blocked_version_skew') throw new Error(decision.message);
+  }
+  // First installation without an active pointer retains the existing
+  // unbound bootstrap path. A bound older release must never auto-upgrade.
   if(displayMode==='ascii') writeRemote(process.stdout,`[DISPLAY] ASCII fallback: ${display.reason}\n`,displayMode);
   if(resumeCursor!==null) await replayRemoteResults(ctx.root,resumeCursor,{displayMode});
   const startupLock=await acquireForegroundSessionLock({root:ctx.root,powershell:ctx.powershell});
@@ -946,6 +958,32 @@ async function runRemote(args){
   if(positional.length>1) throw new Error('remote accepts one controller command');
   const command=positional[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);
   const ctx=await remoteContext();
+  const active=await readActiveRuntimeBinding(ctx.root);
+  const decision=selectR168OneShotRemotePath({command,active,cliVersion:DEADBYTE_VERSION});
+  if(decision.mode==='blocked_version_skew') throw new Error(decision.message);
+  if(decision.mode==='delegate_active'){
+    // R169 explicitly delegates ONLY plane arm/disarm verbs to the installed
+    // controller. The launcher verifies its own identity and policy; this path
+    // never launches deploy-r48.mjs or attempts runtime coherence activation.
+    await assertR169PinnedActiveDelegation({stateRoot:ctx.root,launcherPath:ctx.launcher,active});
+    const unchanged=await readActiveRuntimeBinding(ctx.root);
+    if(unchanged?.release_id!==active.release_id||
+       unchanged?.generation_manifest_sha256!==active.generation_manifest_sha256)
+      throw new Error('R169 active runtime changed before delegated command; no dispatch');
+    const result=invokeController(ctx,command,{allowFailure:true,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+    const final=await readActiveRuntimeBinding(ctx.root);
+    if(final?.release_id!==active.release_id||
+       final?.generation_manifest_sha256!==active.generation_manifest_sha256)
+      throw new Error('R169 active runtime changed during delegated command; outcome unknown');
+    process.exitCode=result.status;
+    return;
+  }
+  if(decision.mode==='observe_active'||decision.mode==='observe_unbound'){
+    if(decision.mode==='observe_active')await reportVersionCoherence(ctx.root,{displayMode:'ascii'});
+    const observed=invokeController(ctx,command,{allowFailure:true,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+    process.exitCode=observed.status;
+    return;
+  }
   await synchronizeOneShotRuntime(ctx,{displayMode:'ascii'});
   const result=invokeController(ctx,command,{allowFailure:true});
   process.exitCode=result.status;

package/src/npm-publication-resume-r168.mjs

@@ -0,0 +1,25 @@
+// R168: derive resume metadata only from a hash-pinned immutable npm artifact.
+import {createHash} from 'node:crypto';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const digest=(alg,bytes,encoding='hex')=>createHash(alg).update(bytes).digest(encoding);
+
+export function resumePackRecord({filename,localBytes,claim,version,manifestSha256}={}){
+  if(typeof version!=='string'||!/^\d+\.\d+\.\d+$/.test(version)||
+    filename!=='deadbyte-mcp-'+version+'.tgz')
+    throw new Error('npm resume version or filename invalid');
+  if(!Buffer.isBuffer(localBytes)||localBytes.length<1)
+    throw new Error('npm resume preserved tarball bytes unavailable');
+  if(!HEX64.test(String(manifestSha256))||
+    !claim||typeof claim!=='object'||Array.isArray(claim)||
+    claim.schema!=='deadbyte.npm-publication-claim.r65.v1'||claim.version!==version||
+    claim.manifest_sha256!==manifestSha256||
+    !HEX64.test(String(claim.tarball_sha256)))
+    throw new Error('npm resume immutable claim manifest or version mismatch');
+  const sha256=digest('sha256',localBytes);
+  if(sha256!==claim.tarball_sha256)
+    throw new Error('npm resume preserved tarball differs from immutable claim digest');
+  return Object.freeze({filename,sha256,
+    integrity:'sha512-'+digest('sha512',localBytes,'base64'),
+    shasum:digest('sha1',localBytes)});
+}

package/src/remote-one-shot-coherence-r168.mjs

@@ -0,0 +1,43 @@
+// R168 one-shot command dispatch. Pure policy. Does not spawn or modify state.
+import {compareRuntimeVersions} from './runtime-coherence.mjs';
+
+const COMMANDS=new Set([
+  'menu','start','resume','park','stop','restart','status','url','test','fulltest','toggle','clean','machinetest',
+  'armprocess','disarmprocess','processstatus','armhost','disarmhost','hoststatus','hosttest',
+  'armdesktop','disarmdesktop','desktopstatus',
+  'armcoding','disarmcoding','codingstatus','codingtest',
+  'armautonomous','disarmautonomous','autonomousstatus','autonomoustest'
+]);
+const OBSERVE=new Set(['status','processstatus','codingstatus','autonomousstatus','desktopstatus','hoststatus']);
+const DELEGATE=new Set(['armprocess','disarmprocess','armcoding','disarmcoding','armautonomous',
+  'disarmautonomous','armdesktop','disarmdesktop','armhost','disarmhost']);
+const safe=(mode,active,cli,message=null)=>Object.freeze({
+  mode,active_version:active,cli_version:cli,message,
+  may_activate:false,may_mutate_authority:false
+});
+
+export function selectR168OneShotRemotePath({command,active,cliVersion}={}){
+  if(typeof command!=='string'||!COMMANDS.has(command))
+    throw new Error('R168 unsupported remote controller command');
+  if(active===null||active===undefined){
+    if(OBSERVE.has(command))return safe('observe_unbound',null,cliVersion,
+      'R168 active runtime binding absent: read-only status only, never activate.');
+    throw new Error('R168 active runtime binding unavailable for authority mutation');
+  }
+  if(typeof active!=='object'||typeof active.version!=='string'||
+    !/^\d+\.\d+\.\d+$/.test(active.version))
+    throw new Error('R168 active runtime binding unavailable or invalid');
+  const relation=compareRuntimeVersions(cliVersion,active.version);
+  if(relation===0) return safe('verify_coherent',active.version,cliVersion);
+  const explanation=
+    'R168 version skew: installed runtime '+active.version+', npm CLI '+cliVersion+
+    '. Automatic activation from npm cache is forbidden. Existing runtime remains unchanged.';
+  if(OBSERVE.has(command))return safe('observe_active',active.version,cliVersion,explanation);
+  if(relation>0&&DELEGATE.has(command))return Object.freeze({
+    ...safe('delegate_active',active.version,cliVersion,
+      explanation+' Forwarding explicit plane authority request to installed active controller.'),
+    may_mutate_authority:true
+  });
+  return safe('blocked_version_skew',active.version,cliVersion,
+    explanation+' Run the corresponding command through the installed active-release launcher only if specifically authorized.');
+}

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.65';
+export const DEADBYTE_VERSION = '0.15.67';
 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

@@ -7,18 +7,18 @@ import {DEADBYTE_VERSION} from '../src/version.mjs';
 
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
-test('current successor retains the R130 security baseline with truthful R167 identity',async()=>{
+test('current successor retains the R130 security baseline with truthful R172 identity',async()=>{
   const [pkg,release,provenance,bom,lock,matrix]=await Promise.all([
     read('package.json'),read('RELEASE.json'),read('PROVENANCE.json'),
     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.65');
-  assert.equal(release.train,'R167');
-  assert.equal(matrix.train,'R167');
-  assert.equal(release.source_predecessor.version,'0.15.64');
-  assert.equal(release.source_predecessor.train,'R166');
-  assert.match(release.source_predecessor.source_path,/0\.15\.64-r166-final/i);
+    assert.equal(actual,'0.15.67');
+  assert.equal(release.train,'R172');
+  assert.equal(matrix.train,'R172');
+  assert.equal(release.source_predecessor.version,'0.15.66');
+  assert.equal(release.source_predecessor.train,'R168');
+  assert.match(release.source_predecessor.source_path,/0\.15\.66-r168-activation-reconcile/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');

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

@@ -8,23 +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('R167 package identity preserves R132 evidence and published R166 source predecessor',async()=>{
+test('R172 package identity preserves R132 evidence and published R168 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,'R167');
-  assert.equal(matrix.train,'R167');
-  assert.equal(release.source_predecessor.version,'0.15.64');
-  assert.equal(release.source_predecessor.train,'R166');
-  assert.match(release.source_predecessor.source_path,/0\.15\.64-r166-final/i);
+  assert.equal(release.train,'R172');
+  assert.equal(matrix.train,'R172');
+  assert.equal(release.source_predecessor.version,'0.15.66');
+  assert.equal(release.source_predecessor.train,'R168');
+  assert.match(release.source_predecessor.source_path,/0\.15\.66-r168-activation-reconcile/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,'3d22412c3cebabd66bfa92ca4dbaaf3ef49acba7f92436a16485d7e4cb18c653');
-  assert.equal(prov.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+  assert.equal(release.source_predecessor.tarball_sha256,'31b194a4fbff7dbdb9f4f275b4ea49c5115f7b0bb2241c0c72d72ef690311a5d');
+  assert.equal(release.r172.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 successor 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.65');
+ assert.equal(state.pkg.version,'0.15.67');
  assert.throws(()=>verifyR153Lineage(state),/package version/);
  await assert.rejects(verifyR153IdentityTree(root),/package version/);
 });

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.65';
+const version='0.15.67';
 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('R167 isolated immutable slot activates, rolls back, and restores 0.15.65 without authority or production mutation',async()=>{
+test('R172 isolated immutable slot activates, rolls back, and restores 0.15.67 without authority or production mutation',async()=>{
   const stateBase=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r163-isolated-'));
   const state=path.join(stateBase,'state');
   try{

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

@@ -17,7 +17,7 @@ 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.65');
+  assert.equal(JSON.parse(await readFile(path.join(envRoot,'package.json'),'utf8')).version,'0.15.67');
   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');
@@ -65,26 +65,26 @@ async function run(fx){
  assert.doesNotMatch(trace,/\b(?:start|restart|armprocess|armcoding|armautonomous|deploy)\b/i,'unexpected runtime operation');
  return {output:(result.stderr||'')+'\n'+(result.stdout||''),trace};
 }
-gate('R167 executable CLI passes completed R159 history, reaches 0.15.61 -> 0.15.65 synchronization safely',async t=>{
+gate('R168 executable CLI blocks npm-cache activation on version skew before touching R159 history',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.match(r.output,/R168 version skew.*0\.15\.61.*0\.15\.67/i,r.output);
  assert.doesNotMatch(r.output,/R159 ambiguous multiple completed/i);
- assert.match(r.trace,/disarmhost/);
+ assert.equal(r.trace,'');
  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.match(r.output,/R168 version skew/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.match(r.output,/R168 version skew/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.match(r.output,/R168 version skew/i,r.output);
  assert.doesNotMatch(r.trace,/disarmhost/);
 });

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

@@ -8,11 +8,11 @@ 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'));
 const readOptional=async rel=>{try{return await read(rel);}catch(error){if(error?.code==='ENOENT')return null;throw error;}};
-const VERSION='0.15.65';
+const VERSION='0.15.67';
 const R166_MANIFEST='ad3c091fbbe2bac6d234548724008b67305fd483ad6542f92d5aeb1aa84f5849';
 const R166_TARBALL='3d22412c3cebabd66bfa92ca4dbaaf3ef49acba7f92436a16485d7e4cb18c653';
 
-test('R167 package identity binds published R166 source separately from active R153 runtime',async()=>{
+test('R172 package identity binds published R168 source separately from active R153 runtime',async()=>{
   const [pkg,lock,bridge,release,provenance,matrix,bom]=await Promise.all([
     read('package.json'),readOptional('package-lock.json'),read('bridge/package.json'),read('RELEASE.json'),
     read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
@@ -20,20 +20,21 @@ test('R167 package identity binds published R166 source separately from active R
     provenance.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION];
   if(lock)versions.push(lock.version,lock.packages[''].version);
   for(const version of versions)assert.equal(version,VERSION);
-  assert.equal(release.train,'R167');
-  assert.equal(matrix.train,'R167');
-  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r167:0.15.65');
+  assert.equal(release.train,'R172');
+  assert.equal(matrix.train,'R172');
+  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r172:0.15.67');
   assert.deepEqual(release.runtime_predecessor,{
     version:'0.15.61',release_id:'v0.15.61-055d1ff0aa99e60b',
     manifest_sha256:'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf',
     generation_manifest_sha256:'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4'
   });
-  assert.equal(release.source_predecessor.version,'0.15.64');
-  assert.equal(release.source_predecessor.train,'R166');
-  assert.equal(release.source_predecessor.tarball_sha256,R166_TARBALL);
+  assert.equal(release.source_predecessor.version,'0.15.66');
+  assert.equal(release.source_predecessor.train,'R168');
+  assert.equal(release.source_predecessor.tarball_sha256,'31b194a4fbff7dbdb9f4f275b4ea49c5115f7b0bb2241c0c72d72ef690311a5d');
   assert.equal(release.r167.source_predecessor_manifest_sha256,R166_MANIFEST);
-  assert.equal(provenance.source_predecessor_manifest_file_sha256,R166_MANIFEST);
-  assert.equal(provenance.source_predecessor_tarball_sha256,R166_TARBALL);
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'962e227dace247d59aa860211388fbde461c5f9c8a7e8a878e34a14a27d355f8');
+  assert.equal(release.r172.source_predecessor_manifest_sha256,'962e227dace247d59aa860211388fbde461c5f9c8a7e8a878e34a14a27d355f8');
+  assert.equal(release.r172.source_predecessor_tarball_sha256,'31b194a4fbff7dbdb9f4f275b4ea49c5115f7b0bb2241c0c72d72ef690311a5d');
   assert.equal(release.r167.public_tool_delta,0);
   assert.equal(release.r167.authority_scope_delta,0);
   assert.equal(release.r167.production_activation,'NOT_RUN');

package/test/r168-combined-targeted-runner.mjs

@@ -0,0 +1,14 @@
+// R168 targeted test entrypoint. Does not invoke production authority.
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const dir=path.dirname(fileURLToPath(import.meta.url));
+const cases=['r168-five-plane-fence.test.mjs','r168-focused-suite.test.mjs','r168-crash-journal.test.mjs','r168-protected-entrypoint.test.mjs','r168-remote-one-shot-coherence.test.mjs'];
+const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...cases.map(x=>path.join(dir,x))],{
+  cwd:dir,encoding:'utf8',shell:false,windowsHide:true,timeout:120000,maxBuffer:3*1024*1024
+});
+if(result.stdout)process.stdout.write(result.stdout);
+if(result.stderr)process.stderr.write(result.stderr);
+if(result.error)throw result.error;
+process.exitCode=result.status??1;