deadbyte-mcp 0.15.64 → 0.15.66

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/deadbyte-cli.mjs

@@ -19,6 +19,7 @@ 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 { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
 import {foregroundIdentityMatches,queryForegroundIdentity,validForegroundIdentity,proveRestrictedPidReuse} from './foreground-process-identity.mjs';
@@ -787,6 +788,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 +957,15 @@ 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==='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,36 @@
+// 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 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);
+  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.64';
+export const DEADBYTE_VERSION = '0.15.66';
 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/process-policy-refresh.test.mjs

@@ -65,14 +65,17 @@ async function fixture() {
   };
 }
 
-test('R33 candidate process policy self-binds to the current repository root', async () => {
+test('R167 process policy binds coherently to the explicit development root', async () => {
   const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const expectedRoot = path.resolve(process.env.DEADBYTE_EXPECTED_DEVELOPMENT_ROOT || repoRoot);
   const policyPath = path.join(repoRoot, 'controller', 'deadbyte-process-policy.json');
   const policy = JSON.parse(await readFile(policyPath, 'utf8'));
-  assert.equal(policy.grant_file, path.join(repoRoot, 'controller', 'runtime', 'process-grant.json'));
-  assert.equal(policy.state_dir, path.join(repoRoot, 'controller', 'runtime', 'process-state'));
-  assert.equal(policy.native_host.path, path.join(repoRoot, 'bin', 'deadbyte-process-host.exe'));
-  assert.equal(policy.roots.core.path, repoRoot);
+  assert.equal(path.resolve(policy.roots.core.path), expectedRoot);
+  assert.notEqual(expectedRoot, path.parse(expectedRoot).root, 'development root must not be a broad filesystem root');
+  assert.equal(policy.grant_file, path.join(expectedRoot, 'controller', 'runtime', 'process-grant.json'));
+  assert.equal(policy.state_dir, path.join(expectedRoot, 'controller', 'runtime', 'process-state'));
+  assert.equal(policy.native_host.path, path.join(expectedRoot, 'bin', 'deadbyte-process-host.exe'));
+  assert.equal(policy.native_host.sha256, sha256(await readFile(policy.native_host.path)));
   assert.ok(policy.profiles.ping_hold);
   assert.ok(policy.profiles.powershell);
   assert.ok(policy.profiles.powershell_repl);

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('R130 security patch has a new immutable package identity and truthful source predecessor',async()=>{
+test('current successor retains the R130 security baseline with truthful R168 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.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(actual,'0.15.66');
+  assert.equal(release.train,'R168');
+  assert.equal(matrix.train,'R168');
+  assert.equal(release.source_predecessor.version,'0.15.65');
+  assert.equal(release.source_predecessor.train,'R167');
+  assert.match(release.source_predecessor.source_path,/0\.15\.65-r167-activation-path/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,22 +8,22 @@ 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('R166 package identity preserves R132 evidence and published source predecessor',async()=>{
+test('R168 package identity preserves R132 evidence and published R167 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,'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.train,'R168');
+  assert.equal(matrix.train,'R168');
+  assert.equal(release.source_predecessor.version,'0.15.65');
+  assert.equal(release.source_predecessor.train,'R167');
+  assert.match(release.source_predecessor.source_path,/0\.15\.65-r167-activation-path/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(release.source_predecessor.tarball_sha256,'fc3ae5b1505e316bc9dfedf8d063cb00641754c8f5f1306a31f8cc4bb84c9484');
   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);

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

@@ -22,11 +22,11 @@ const historical=()=>{
       runtime_predecessor:runtime,parent:{...runtime}}};
 };
 const copy=()=>historical();
-test('R153 historical verifier refuses current R160 package identity',async()=>{
+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.64');
+ assert.equal(state.pkg.version,'0.15.66');
  assert.throws(()=>verifyR153Lineage(state),/package version/);
  await assert.rejects(verifyR153IdentityTree(root),/package version/);
 });

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

@@ -3,25 +3,17 @@ import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
-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 identity separates source and live runtime predecessors',async()=>{
-  const [pkg,lock,bridge,release,provenance,matrix,bom]=await Promise.all([
-    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.64');
-  assert.equal(release.train,'R166');
-  assert.equal(matrix.train,'R166');
+test('R160 historical contract remains distinct from the current package identity',async()=>{
+  const [release,provenance]=await Promise.all([read('RELEASE.json'),read('PROVENANCE.json')]);
   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,'R165');
-  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.63-r165-remote-recovery/i);
+  assert.equal(release.r160.source_predecessor_train,'R159');
+  assert.equal(release.r160.runtime_predecessor_version,'0.15.61');
   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.64';
+const version='0.15.66';
 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('R166 isolated immutable slot activates, rolls back, and restores 0.15.64 without authority or production mutation',async()=>{
+test('R168 isolated immutable slot activates, rolls back, and restores 0.15.66 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.64');
+  assert.equal(JSON.parse(await readFile(path.join(envRoot,'package.json'),'utf8')).version,'0.15.66');
   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('R165 executable CLI passes completed R159 history, reaches 0.15.61 -> 0.15.64 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\.66/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-activation-path.test.mjs

@@ -0,0 +1,124 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,readdir,rm,writeFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {
+  parseActivationPathFlags,
+  assertTrustedActivationEntrypoint,
+  appendActivationPathArgs
+} from '../src/activation-path-r167.mjs';
+
+const protectedRoot='C:\\Program Files\\DEADBYTE-R167';
+const developmentRoot='D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.65-r167-activation-path';
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const H=value=>createHash('sha256').update(value).digest('hex');
+
+test('R167 parses one exact protected epoch root and one separate development root',()=>{
+  const parsed=parseActivationPathFlags([
+    '--preflight','--authority-epoch-root',protectedRoot,'--development-root',developmentRoot
+  ]);
+  assert.equal(parsed.authorityEpochRoot,protectedRoot);
+  assert.equal(parsed.developmentRoot,developmentRoot);
+  assert.deepEqual(parsed.remainingArgs,['--preflight']);
+});
+
+test('R167 rejects missing duplicate relative UNC drive-relative and noncanonical roots',()=>{
+  const invalid=[
+    ['--authority-epoch-root'],
+    ['--development-root'],
+    ['--authority-epoch-root','relative'],
+    ['--authority-epoch-root','\\\\server\\share'],
+    ['--authority-epoch-root','C:relative'],
+    ['--authority-epoch-root','C:\\Program Files\\..\\Writable'],
+    ['--authority-epoch-root',protectedRoot,'--authority-epoch-root',protectedRoot],
+    ['--development-root',developmentRoot,'--development-root',developmentRoot]
+  ];
+  for(const argv of invalid)assert.throws(()=>parseActivationPathFlags(argv));
+});
+
+test('R167 EPOCH_NATIVE activation requires the executing package root to be the trusted protected root',()=>{
+  assert.throws(()=>assertTrustedActivationEntrypoint({
+    continuity:'EPOCH_NATIVE',packageRoot:developmentRoot,
+    authorityEpochRoot:protectedRoot,developmentRoot,trusted:true
+  }),/protected entrypoint/i);
+  assert.throws(()=>assertTrustedActivationEntrypoint({
+    continuity:'EPOCH_NATIVE',packageRoot:protectedRoot,
+    authorityEpochRoot:protectedRoot,developmentRoot,trusted:false
+  }),/ACL-trusted/i);
+  assert.deepEqual(assertTrustedActivationEntrypoint({
+    continuity:'EPOCH_NATIVE',packageRoot:protectedRoot,
+    authorityEpochRoot:protectedRoot,developmentRoot,trusted:true
+  }),{authorityEpochRoot:protectedRoot,developmentRoot});
+});
+
+test('R167 forwards exact protected stage epoch and development roots to updater without fallback',()=>{
+  const args=appendActivationPathArgs(['--expected-version','0.15.65'],{
+    stageRoot:protectedRoot,authorityEpochRoot:protectedRoot,developmentRoot
+  });
+  assert.deepEqual(args,[
+    '--expected-version','0.15.65','--stage',protectedRoot,
+    '--development-root',developmentRoot,'--authority-epoch-root',protectedRoot
+  ]);
+  assert.throws(()=>appendActivationPathArgs([],{
+    stageRoot:developmentRoot,authorityEpochRoot:protectedRoot,developmentRoot
+  }),/stage.*protected/i);
+});
+
+test('R167 writable EPOCH_NATIVE entrypoint rejects before creating an activation claim',
+  {skip:process.platform!=='win32'},async()=>{
+  const isolated=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r167-preclaim-'));
+  try{
+    const state=path.join(isolated,'state'),runtime=path.join(state,'runtime'),bin=path.join(state,'bin');
+    const generation=path.join(state,'generations','fixture'),policies=path.join(state,'policies');
+    await Promise.all([mkdir(runtime,{recursive:true}),mkdir(bin,{recursive:true}),mkdir(generation,{recursive:true}),mkdir(policies,{recursive:true})]);
+    const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+    const fields={process:'grant_file',coding:'lease_file',autonomous:'lease_file',desktop:'grant_file',host:'arm_file'};
+    const policyPaths={},config=[];
+    const configFields={process:'ProcessPolicyFile',coding:'CodingPolicyFile',autonomous:'AutonomousPolicyFile',desktop:'DesktopPolicyFile',host:'HostPolicyFile'};
+    for(const [plane,field] of Object.entries(fields)){
+      const grant=path.join(runtime,`${plane}-grant.json`),policy=path.join(policies,`${plane}.json`);
+      const body={schema:plane==='host'?'deadbyte.host-policy.v2':`deadbyte.${plane}-policy.v1`,enabled:true,[field]:grant};
+      await writeFile(policy,JSON.stringify(body));
+      policyPaths[plane]=policy;
+      config.push(`${configFields[plane]} = '${policy.replaceAll("'","''")}'`);
+      if(plane==='coding')await writeFile(grant,JSON.stringify({schema:'fixture',nonce:H('coding-grant')}));
+    }
+    const pointer={schema:'deadbyte.active-release.v1',...release.parent,
+      release_root:path.join(state,'releases',release.parent.release_id),generation_root:generation,
+      launcher_sha256:H('launcher'),config_path:path.join(generation,'controller-config.psd1')};
+    await writeFile(pointer.config_path,`@{ ${config.join('; ')} }\n`);
+    const pointerBytes=Buffer.from(JSON.stringify(pointer));
+    await writeFile(path.join(state,'active-release.json'),pointerBytes);
+    const disarmed=plane=>({configured:true,armed:false,reason:plane==='autonomous'?'coding-disarmed':'disarmed'});
+    const observation={schema:'deadbyte.controller-observation.v1',state:'ONLINE',local_ready:true,
+      bridge:{alive:true,reason:'verified',pid:101},core:{alive:true,reason:'verified',pid:102},
+      cloud:{alive:true,reason:'verified',pid:103},supervisor:{running:true},
+      authority:{process:disarmed('process'),coding:{configured:true,armed:true,reason:'standing-grant',epoch_seq:7,epoch_sha256:H('coding-epoch')},
+        autonomous:disarmed('autonomous'),desktop:disarmed('desktop'),host:disarmed('host')}};
+    const observationPath=path.join(state,'observation.json');
+    await writeFile(observationPath,JSON.stringify(observation));
+    await writeFile(path.join(bin,'DEADBYTE-MCP.ps1'),`param([string]$Command,[switch]$Json)\nif($Command -ne 'status' -or -not $Json){throw 'mutation attempted'}\nGet-Content -Raw -LiteralPath '${observationPath.replaceAll("'","''")}'\n`);
+    const before=H(pointerBytes);
+    const preflightRun=spawnSync(process.execPath,[path.join(root,'scripts','deploy-r48.mjs'),'--preflight',
+      '--authority-epoch-root',protectedRoot,'--development-root',developmentRoot],{
+      env:{...process.env,DEADBYTE_STATE_ROOT:state},cwd:root,encoding:'utf8',timeout:30000,windowsHide:true});
+    assert.equal(preflightRun.status,0,preflightRun.stderr);
+    const preflight=JSON.parse(preflightRun.stdout.trim());
+    assert.equal(preflight.authority_continuity,'EPOCH_NATIVE');
+    assert.equal(preflight.activation_entrypoint_state,'REJECTED');
+    assert.equal(preflight.protected_activation_entrypoint,false);
+    assert.match(preflight.activation_entrypoint_reason,/protected|trusted|UNTRUSTED_WRITE_ACE/i);
+    const run=spawnSync(process.execPath,[path.join(root,'scripts','deploy-r48.mjs'),
+      '--authority-epoch-root',protectedRoot,'--development-root',developmentRoot],{
+      env:{...process.env,DEADBYTE_STATE_ROOT:state},cwd:root,encoding:'utf8',timeout:30000,windowsHide:true});
+    assert.notEqual(run.status,0,run.stdout);
+    assert.match(run.stderr,/trusted|protected|UNTRUSTED_WRITE_ACE/i);
+    assert.equal(H(await readFile(path.join(state,'active-release.json'))),before);
+    const updates=path.join(state,'evidence','updates');
+    await assert.rejects(readdir(updates),error=>error?.code==='ENOENT');
+  }finally{await rm(isolated,{recursive:true,force:true});}
+});