deadbyte-mcp 0.15.66 → 0.15.68

package/node_modules/which/CHANGELOG.md

@@ -0,0 +1,166 @@
+# Changes
+
+
+## 2.0.2
+
+* Rename bin to `node-which`
+
+## 2.0.1
+
+* generate changelog and publish on version bump
+* enforce 100% test coverage
+* Promise interface
+
+## 2.0.0
+
+* Parallel tests, modern JavaScript, and drop support for node < 8
+
+## 1.3.1
+
+* update deps
+* update travis
+
+## v1.3.0
+
+* Add nothrow option to which.sync
+* update tap
+
+## v1.2.14
+
+* appveyor: drop node 5 and 0.x
+* travis-ci: add node 6, drop 0.x
+
+## v1.2.13
+
+* test: Pass missing option to pass on windows
+* update tap
+* update isexe to 2.0.0
+* neveragain.tech pledge request
+
+## v1.2.12
+
+* Removed unused require
+
+## v1.2.11
+
+* Prevent changelog script from being included in package
+
+## v1.2.10
+
+* Use env.PATH only, not env.Path
+
+## v1.2.9
+
+* fix for paths starting with ../
+* Remove unused `is-absolute` module
+
+## v1.2.8
+
+* bullet items in changelog that contain (but don't start with) #
+
+## v1.2.7
+
+* strip 'update changelog' changelog entries out of changelog
+
+## v1.2.6
+
+* make the changelog bulleted
+
+## v1.2.5
+
+* make a changelog, and keep it up to date
+* don't include tests in package
+* Properly handle relative-path executables
+* appveyor
+* Attach error code to Not Found error
+* Make tests pass on Windows
+
+## v1.2.4
+
+* Fix typo
+
+## v1.2.3
+
+* update isexe, fix regression in pathExt handling
+
+## v1.2.2
+
+* update deps, use isexe module, test windows
+
+## v1.2.1
+
+* Sometimes windows PATH entries are quoted
+* Fixed a bug in the check for group and user mode bits. This bug was introduced during refactoring for supporting strict mode.
+* doc cli
+
+## v1.2.0
+
+* Add support for opt.all and -as cli flags
+* test the bin
+* update travis
+* Allow checking for multiple programs in bin/which
+* tap 2
+
+## v1.1.2
+
+* travis
+* Refactored and fixed undefined error on Windows
+* Support strict mode
+
+## v1.1.1
+
+* test +g exes against secondary groups, if available
+* Use windows exe semantics on cygwin & msys
+* cwd should be first in path on win32, not last
+* Handle lower-case 'env.Path' on Windows
+* Update docs
+* use single-quotes
+
+## v1.1.0
+
+* Add tests, depend on is-absolute
+
+## v1.0.9
+
+* which.js: root is allowed to execute files owned by anyone
+
+## v1.0.8
+
+* don't use graceful-fs
+
+## v1.0.7
+
+* add license to package.json
+
+## v1.0.6
+
+* isc license
+
+## 1.0.5
+
+* Awful typo
+
+## 1.0.4
+
+* Test for path absoluteness properly
+* win: Allow '' as a pathext if cmd has a . in it
+
+## 1.0.3
+
+* Remove references to execPath
+* Make `which.sync()` work on Windows by honoring the PATHEXT variable.
+* Make `isExe()` always return true on Windows.
+* MIT
+
+## 1.0.2
+
+* Only files can be exes
+
+## 1.0.1
+
+* Respect the PATHEXT env for win32 support
+* should 0755 the bin
+* binary
+* guts
+* package
+* 1st

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.66",
+  "version": "0.15.68",
   "private": false,
   "type": "module",
   "description": "Authenticated MCP agentic runtime with signed skills, persistent model backends, identity-bound remote devices, durable job supervision, immutable release slots, and separately revocable machine authority.",
@@ -97,7 +97,9 @@
     "r167:focused:test": "node --test --test-concurrency=1 test/r167-activation-path.test.mjs test/r167-release-contract.test.mjs test/r167-release-readiness.test.mjs test/r160-release-contract.test.mjs test/r158-epoch-bootstrap.test.mjs test/r65-activation-orchestration.test.mjs",
     "gate:windows": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r168.ps1 -Stage all",
     "r168:focused:test": "node test/r168-combined-targeted-runner.mjs",
-    "r168:release:verify": "node scripts/npm-release-r48.mjs --verify-only"
+    "r168:release:verify": "node scripts/npm-release-r48.mjs --verify-only",
+    "r172:focused:test": "node --test --test-concurrency=1 test/r172-activation-recovery.test.mjs test/r172-release-contract.test.mjs test/r169-delegate-active.test.mjs test/r169-delegate-cli-integration.test.mjs test/r65-activation-lock-recovery.test.mjs test/r65-activation-orchestration.test.mjs",
+    "r173:focused:test": "node --test --test-concurrency=1 test/r75-authority-evidence.test.mjs test/r172-activation-recovery.test.mjs test/r173-release-contract.test.mjs test/r65-activation-preflight.test.mjs test/r65-activation-orchestration.test.mjs"
   },
   "bundleDependencies": [
     "@modelcontextprotocol/server",

package/scripts/r172-protected-preflight.mjs

@@ -0,0 +1,42 @@
+// R172 privileged preflight; read-only. Never invokes native CAS or changes grants.
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+import {inspectTrustedInstallation,privilegedEpochInstallFiles} from '../src/privileged-install-trust-r89.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const version='0.15.67',expectedTrain='R172';
+const mandatory=['scripts/r172-protected-preflight.mjs','src/activation-continuity-abort-r172.mjs',
+  'src/activation-lock-r65.mjs','src/activation-preflight-r65.mjs',
+  'src/activation-reconciliation-journal-r168.mjs','src/activation-reconciliation-terminal-r168.mjs',
+  'src/activation-reconciliation-fence-r168.mjs','src/activation-reconciliation-audit-r168.mjs'];
+function denied(reason){throw new Error('R172_'+reason);}
+function actualProtectedRoot(){
+  const trusted='C:\\Program Files',rel=path.win32.relative(trusted,root);
+  if(!rel||rel==='..'||rel.startsWith('..'+path.win32.sep)||path.win32.isAbsolute(rel))denied('ROOT_UNPROTECTED');
+  return root;
+}
+async function main(){
+  if(process.platform!=='win32'||process.arch!=='x64')denied('WINDOWS_X64_REQUIRED');
+  if(process.argv.length!==2)denied('UNKNOWN_OPTION');
+  const verifiedRoot=actualProtectedRoot();
+  const pkg=JSON.parse(await readFile(path.join(verifiedRoot,'package.json'),'utf8'));
+  const release=JSON.parse(await readFile(path.join(verifiedRoot,'RELEASE.json'),'utf8'));
+  if(pkg.name!=='deadbyte-mcp'||pkg.version!==version||release.name!=='deadbyte-mcp'||
+     release.version!==version||release.train!==expectedTrain)denied('VERSION_DRIFT');
+  const manifest=await readFile(path.join(verifiedRoot,'MANIFEST.SHA256'));
+  const entries=parseManifest(manifest.toString('utf8'));
+  for(const name of mandatory)if(!entries.has(name))denied('SOURCE_NOT_IN_MANIFEST');
+  await verifyManifestTreeExact(verifiedRoot,entries,{allowedExtraPaths:['.npmignore','package-lock.json']});
+  const important=[...privilegedEpochInstallFiles(verifiedRoot,process.execPath),
+    ...mandatory.map(rel=>path.win32.join(verifiedRoot,...rel.split('/'))),
+    path.win32.join(verifiedRoot,'MANIFEST.SHA256'),path.win32.join(verifiedRoot,'RELEASE.json'),
+    path.win32.join(verifiedRoot,'package.json')];
+  await inspectTrustedInstallation(important);
+  const hash=createHash('sha256').update(manifest).digest('hex');
+  process.stdout.write(JSON.stringify({status:'R172_PROTECTED_PREFLIGHT_READONLY_PASS',version,train:expectedTrain,
+    manifest_sha256:hash,files:entries.size,terminalization_authorized:false,activation_authorized:false})+'\n');
+}
+try{await main();}catch(error){process.stderr.write('R172_PROTECTED_PREFLIGHT=BLOCKED '+String(error?.message??error)+'\n');process.exitCode=1;}

package/scripts/r173-protected-preflight.mjs

@@ -0,0 +1,42 @@
+// R173 privileged preflight; read-only. Never invokes native CAS or changes grants.
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
+import {inspectTrustedInstallation,privilegedEpochInstallFiles} from '../src/privileged-install-trust-r89.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const version='0.15.68',expectedTrain='R173';
+const mandatory=['scripts/r173-protected-preflight.mjs','src/activation-continuity-abort-r172.mjs',
+  'src/activation-lock-r65.mjs','src/activation-preflight-r65.mjs',
+  'src/activation-reconciliation-journal-r168.mjs','src/activation-reconciliation-terminal-r168.mjs',
+  'src/activation-reconciliation-fence-r168.mjs','src/activation-reconciliation-audit-r168.mjs'];
+function denied(reason){throw new Error('R173_'+reason);}
+function actualProtectedRoot(){
+  const trusted='C:\\Program Files',rel=path.win32.relative(trusted,root);
+  if(!rel||rel==='..'||rel.startsWith('..'+path.win32.sep)||path.win32.isAbsolute(rel))denied('ROOT_UNPROTECTED');
+  return root;
+}
+async function main(){
+  if(process.platform!=='win32'||process.arch!=='x64')denied('WINDOWS_X64_REQUIRED');
+  if(process.argv.length!==2)denied('UNKNOWN_OPTION');
+  const verifiedRoot=actualProtectedRoot();
+  const pkg=JSON.parse(await readFile(path.join(verifiedRoot,'package.json'),'utf8'));
+  const release=JSON.parse(await readFile(path.join(verifiedRoot,'RELEASE.json'),'utf8'));
+  if(pkg.name!=='deadbyte-mcp'||pkg.version!==version||release.name!=='deadbyte-mcp'||
+     release.version!==version||release.train!==expectedTrain)denied('VERSION_DRIFT');
+  const manifest=await readFile(path.join(verifiedRoot,'MANIFEST.SHA256'));
+  const entries=parseManifest(manifest.toString('utf8'));
+  for(const name of mandatory)if(!entries.has(name))denied('SOURCE_NOT_IN_MANIFEST');
+  await verifyManifestTreeExact(verifiedRoot,entries,{allowedExtraPaths:['.npmignore','package-lock.json']});
+  const important=[...privilegedEpochInstallFiles(verifiedRoot,process.execPath),
+    ...mandatory.map(rel=>path.win32.join(verifiedRoot,...rel.split('/'))),
+    path.win32.join(verifiedRoot,'MANIFEST.SHA256'),path.win32.join(verifiedRoot,'RELEASE.json'),
+    path.win32.join(verifiedRoot,'package.json')];
+  await inspectTrustedInstallation(important);
+  const hash=createHash('sha256').update(manifest).digest('hex');
+  process.stdout.write(JSON.stringify({status:'R173_PROTECTED_PREFLIGHT_READONLY_PASS',version,train:expectedTrain,
+    manifest_sha256:hash,files:entries.size,terminalization_authorized:false,activation_authorized:false})+'\n');
+}
+try{await main();}catch(error){process.stderr.write('R173_PROTECTED_PREFLIGHT=BLOCKED '+String(error?.message??error)+'\n');process.exitCode=1;}

package/src/activation-authority-proof-r75.mjs

@@ -1,6 +1,7 @@
 import {createHash} from 'node:crypto';
 import {lstat,open,realpath} from 'node:fs/promises';
 import path from 'node:path';
+import {createAuthorityEpochStore} from './authority-continuity-r65.mjs';
 
 const FIELDS=Object.freeze({process:'grant_file',coding:'lease_file',autonomous:'lease_file',desktop:'grant_file',host:'arm_file'});
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
@@ -22,7 +23,9 @@ async function readRegularPinned(file,label){
   }finally{await handle.close();}
 }
 
-export async function observeAuthorityEvidence({stateRoot,policyPaths,policySha256,authority}){
+export async function observeAuthorityEvidence({stateRoot,policyPaths,policySha256,authority,
+  epochStoreFactory=createAuthorityEpochStore}){
+  if(typeof epochStoreFactory!=='function')throw new Error('authority epoch store factory invalid');
   const runtimeRoot=await realpath(path.join(stateRoot,'runtime'));
   const result={};
   for(const [plane,field] of Object.entries(FIELDS)){
@@ -49,11 +52,31 @@ export async function observeAuthorityEvidence({stateRoot,policyPaths,policySha2
     const grantAbsent=grantInfo===undefined;
     if(grantInfo&&(!grantInfo.isFile()||grantInfo.isSymbolicLink()))throw new Error(`${plane} grant file type invalid`);
     const validEntry=entry&&entry.configured===true&&typeof entry.armed==='boolean';
-    const validDisarmed=validEntry&&!entry.armed&&grantAbsent&&
-      (entry.reason==='disarmed'||(plane==='autonomous'&&entry.reason==='coding-disarmed'));
+    const grantBytes=grantInfo?await readRegularPinned(checkedPath,`${plane} grant`):null;
+    const grantSha=grantBytes?sha(grantBytes):null;
+    let transactionRevoked=false;
+    if(validEntry&&!entry.armed&&entry.reason==='epoch-revoked'&&grantBytes){
+      let grant;
+      try{grant=JSON.parse(grantBytes.toString('utf8').replace(/^\uFEFF/,''));}catch{}
+      const nonce=grant?.instance_nonce;
+      if(typeof nonce==='string'&&/^[0-9a-f]{64}$/.test(nonce)){
+        const store=epochStoreFactory({runtimeDir:parent,policyBytes});
+        const [audit,head,verification]=await Promise.all([
+          store.auditHistory({plane}),store.readHead({plane}),
+          store.verifyGrant({plane,grantBytes,grantInstanceNonce:nonce,policyBytes})
+        ]);
+        transactionRevoked=audit?.status==='PASS'&&Number.isSafeInteger(audit.verified_events)&&audit.verified_events>0&&
+          head?.action==='transaction_revoke'&&Number.isSafeInteger(head.seq)&&head.seq>0&&
+          /^[0-9a-f]{64}$/.test(String(head.event_sha256??''))&&
+          head.policy_sha256===expectedHash&&head.grant_sha256===grantSha&&head.grant_instance_nonce===nonce&&
+          /^r65-[0-9a-f]{32}$/.test(String(head.update_id??''))&&verification?.trusted===false&&
+          verification?.reason==='epoch-revoked'&&verification?.event_sha256===head.event_sha256;
+      }
+    }
+    const validDisarmed=validEntry&&!entry.armed&&(
+      (grantAbsent&&(entry.reason==='disarmed'||(plane==='autonomous'&&entry.reason==='coding-disarmed')))||transactionRevoked);
     const validArmed=validEntry&&entry.armed&&!grantAbsent&&entry.reason==='standing-grant'&&
       Number.isSafeInteger(entry.epoch_seq)&&entry.epoch_seq>0&&/^[0-9a-f]{64}$/.test(entry.epoch_sha256??'');
-    const grantSha=grantInfo?sha(await readRegularPinned(checkedPath,`${plane} grant`)):null;
     let grantFinal;
     try{grantFinal=await lstat(checkedPath);}
     catch(error){if(error?.code!=='ENOENT')throw error;}
@@ -61,6 +84,7 @@ export async function observeAuthorityEvidence({stateRoot,policyPaths,policySha2
       throw new Error(`${plane} grant identity changed during observation`);
     result[plane]=Object.freeze({state:validDisarmed?'VERIFIED_DISARMED':validArmed?'VERIFIED_ARMED':'UNVERIFIED',
       policy_sha256:expectedHash,grant_absent:grantAbsent,
+      ...(transactionRevoked?{transaction_revoked:true}:{}),
       ...(grantSha?{grant_sha256:grantSha}:{})});
   }
   return Object.freeze(result);

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

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

package/src/activation-lock-r65.mjs

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

package/src/activation-preflight-r65.mjs

@@ -55,14 +55,16 @@ export function classifyActivationPreflight({pointer,expectedParent,candidate,ex
   for(const plane of PLANES){
     const entry=observation?.authority?.[plane],proof=observation?.authority_proof?.[plane];
     if(entry&&typeof entry==='object'){
-      const knownReason=entry.armed?entry.reason==='standing-grant':entry.reason==='disarmed'||entry.reason==='coding-disarmed';
+      const knownReason=entry.armed?entry.reason==='standing-grant':
+        entry.reason==='disarmed'||entry.reason==='coding-disarmed'||entry.reason==='epoch-revoked';
       if(!knownReason)return Object.freeze({state:'AUTHORITY_UNVERIFIED',safe_to_activate:false,reason:`${plane} authority reason unverified`,...bound});
     }
     if(!proof)
       return Object.freeze({state:'AUTHORITY_UNVERIFIED',safe_to_activate:false,reason:`${plane} authority proof missing`,...bound});
     if(proof&&(proof.policy_sha256!==observation?.policy_sha256?.[plane]||
         proof.state!==(authority[plane]?'VERIFIED_ARMED':'VERIFIED_DISARMED')||
-        (!authority[plane]&&proof.grant_absent!==true)))
+        (!authority[plane]&&proof.grant_absent!==true&&
+          !(entry?.reason==='epoch-revoked'&&proof.transaction_revoked===true))))
       return Object.freeze({state:'AUTHORITY_UNVERIFIED',safe_to_activate:false,reason:`${plane} authority proof unverified`,...bound});
   }
   if(PLANES.some(plane=>!HEX64.test(String(observation?.policy_sha256?.[plane]))))

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

@@ -20,6 +20,7 @@ import { classifyRemoteAuditOutcome, createLiveTimelineFilter, createLiveTimelin
 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';
@@ -960,6 +961,23 @@ async function runRemote(args){
   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});

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

@@ -9,6 +9,8 @@ const COMMANDS=new Set([
   '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
@@ -31,6 +33,11 @@ export function selectR168OneShotRemotePath({command,active,cliVersion}={}){
     '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.66';
+export const DEADBYTE_VERSION = '0.15.68';
 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 R168 identity',async()=>{
+test('current successor retains the R130 security baseline with truthful R173 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.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(actual,'0.15.68');
+  assert.equal(release.train,'R173');
+  assert.equal(matrix.train,'R173');
+  assert.equal(release.source_predecessor.version,'0.15.67');
+  assert.equal(release.source_predecessor.train,'R172');
+  assert.match(release.source_predecessor.source_path,/0\.15\.67-r172-final-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');