deadbyte-mcp 0.15.70 → 0.15.72

package/src/remote-live-log.mjs

@@ -62,6 +62,19 @@ export function formatRemoteLogResetNotice(file,reason){
   return '[LIVELOG] RUNTIME_LOG_REOPENED '+name+' — '+detail+'; console diagnostic continuity may have gaps; audit verification is separate';
 }
 
+// Bound the foreground reader state to the current discovery snapshot.
+// Audit continuity is still enforced by the signed journal, not this cache.
+export function pruneLiveLogReaders(offsets,partialLines,liveFiles){
+  if(!(offsets instanceof Map)||!(partialLines instanceof Map)||
+    !Array.isArray(liveFiles)||liveFiles.some(file=>typeof file!=='string'||!file))
+    throw new Error('live log reader state invalid');
+  const keep=new Set(liveFiles);
+  let cursorsRemoved=0,fragmentsRemoved=0;
+  for(const file of offsets.keys())if(!keep.has(file)){offsets.delete(file);cursorsRemoved++;}
+  for(const file of partialLines.keys())if(!keep.has(file)){partialLines.delete(file);fragmentsRemoved++;}
+  return {cursors_removed:cursorsRemoved,fragments_removed:fragmentsRemoved};
+}
+
 export function selectLiveLogNames({auditNames=[],runtimeNames=[]}={}){
   if(!Array.isArray(auditNames)||!Array.isArray(runtimeNames)) throw new Error('live log names must be arrays');
   const audit=[...new Set(auditNames.filter(name=>typeof name==='string'&&/^segment-\d{8}\.jsonl$/.test(name)))].sort().slice(-2);
@@ -713,6 +726,14 @@ export function formatRuntimeDiagnosticLine(file,line,{verbose=false,displayMode
     return remoteDisplayText('['+label+'.DEBUG] OUT '+output[1],displayMode);
   }
   const compact=line.match(/^\[TOOL\]\s+(\S+)\s+#(\d+)\s+(✓|✗|OK|ERR)\s+([A-Za-z0-9_.-]+)\s+([^\s]+)(?:\s+—\s+(.+))?$/u);
-  if(compact) return verbose?remoteDisplayText('['+label+'.DEBUG] #'+compact[2]+' '+compact[3]+' '+compact[4]+' '+compact[5]+(compact[6]?' — '+compact[6]:''),displayMode):null;
+  if(compact){
+    if(!verbose)return null;
+    // Runtime logs are lower-trust diagnostics than signed audit records.
+    // Never echo a donor/transport error reason before screening and bounding it.
+    const screened=compact[6]?sanitizeAuditArgs(compact[6]):null;
+    const reason=typeof screened==='string'?clipped(screened,180):screened?'[REDACTED]':'';
+    return remoteDisplayText('['+label+'.DEBUG] #'+compact[2]+' '+compact[3]+' '+compact[4]+' '+compact[5]+
+      (reason?' — '+reason:''),displayMode);
+  }
   return null;
 }

package/src/runtime-update.mjs

@@ -23,7 +23,7 @@ import {assertStageOwnedPath,assertStagingBootstrapInputs,assertStagingControlCo
 import { verifyProjectOwnerApproval } from './r70-owner-approval.mjs';
 import {windowsPowerShellEnvironment} from './windows-powershell-environment.mjs';
 import {verifyNarrowedPolicyGeneration} from './clean-activation-recovery-r153.mjs';
-import {parseProtectedEpochRoot,verifyTrustedEpochRelease} from './trusted-epoch-bootstrap-r158.mjs';
+import {parseProtectedEpochRoot,selectActivationEpochRoot,verifyTrustedEpochRelease} from './trusted-epoch-bootstrap-r158.mjs';
 
 export {windowsPowerShellEnvironment};
 
@@ -1913,7 +1913,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
     workspace=await workspacePlan(control.workspaceRoot,state);launchers=await launcherPlan(state);
     // A protected installation is an explicit owner-provisioned candidate.
     // No discovery/fallback to writable npm roots and no automatic grant.
-    const requestedEpochRoot=authorityEpochRoot??control.config.AuthorityEpochRoot;
+    const requestedEpochRoot=selectActivationEpochRoot({stageRoot,configuredEpochRoot:control.config.AuthorityEpochRoot,explicitEpochRoot:authorityEpochRoot});
     if(requestedEpochRoot){
       const proof=await verifyTrustedEpochRelease({
         epochRoot:requestedEpochRoot,releaseRoot:slot.release_root,

package/src/trusted-epoch-bootstrap-r158.mjs

@@ -13,6 +13,14 @@ export function parseProtectedEpochRoot(input){
     throw new Error('authority epoch root may not be a drive root');
   return root;
 }
+// An inherited protected root belongs to the predecessor. Successor bytes
+// must be verified against their own exact, independently ACL-trusted stage.
+export function selectActivationEpochRoot({stageRoot,configuredEpochRoot=null,explicitEpochRoot=null}={}){
+  if(explicitEpochRoot!==null)return parseProtectedEpochRoot(explicitEpochRoot);
+  if(!configuredEpochRoot)return null;
+  parseProtectedEpochRoot(configuredEpochRoot);
+  return parseProtectedEpochRoot(stageRoot);
+}
 // This is a read-only proof, not installation or an authority grant.
 // Windows ACL verification must run against OS Get-Acl, never a staged snapshot.
 export async function verifyTrustedEpochRelease({epochRoot,releaseRoot,nodeExecutable}){

package/src/version.mjs

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

@@ -67,7 +67,17 @@ async function fixture() {
 
 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);
+  // The distributed policy is pinned to its explicit development provenance,
+  // not to the physical extraction path of the exact immutable npm tarball.
+  const release = JSON.parse(await readFile(path.join(repoRoot, 'RELEASE.json'), 'utf8'));
+  const approvedRoot = release.r192?.development_policy_root;
+  assert.equal(typeof approvedRoot, 'string', 'R191 development policy root must be explicit in release metadata');
+  assert.ok(path.isAbsolute(approvedRoot), 'R191 development policy root must be absolute');
+  const expectedRoot = path.resolve(approvedRoot);
+  if (process.env.DEADBYTE_EXPECTED_DEVELOPMENT_ROOT) {
+    assert.equal(path.resolve(process.env.DEADBYTE_EXPECTED_DEVELOPMENT_ROOT), expectedRoot,
+      'caller-supplied development root cannot override R191 release provenance');
+  }
   const policyPath = path.join(repoRoot, 'controller', 'deadbyte-process-policy.json');
   const policy = JSON.parse(await readFile(policyPath, 'utf8'));
   assert.equal(path.resolve(policy.roots.core.path), expectedRoot);

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

@@ -14,14 +14,14 @@ test('current successor retains the R130 security baseline with truthful R190 id
     read('SBOM.cdx.json'),readReleaseLock(root),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.70');
-  assert.equal(release.train,'R190');
-  assert.equal(matrix.train,'R190');
-  assert.equal(release.source_predecessor.version,'0.15.69');
-  assert.equal(release.source_predecessor.train,'R179');
-  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.69\.tgz/i);
-  assert.equal(release.source_predecessor.manifest_status,'PUBLISHED_PREVIEW_MANIFEST_VERIFIED_NOT_ACTIVE');
-  assert.equal(release.runtime_predecessor.version,'0.15.68');
+    assert.equal(actual,'0.15.72');
+  assert.equal(release.train,'R192');
+  assert.equal(matrix.train,'R192');
+  assert.equal(release.source_predecessor.version,'0.15.71');
+  assert.equal(release.source_predecessor.train,'R191');
+  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.71\.tgz/i);
+  assert.equal(release.source_predecessor.manifest_status,'PUBLISHED_EXACT_MANIFEST_VERIFIED_ACTIVE_PRODUCTION');
+  assert.equal(release.runtime_predecessor.version,'0.15.71');
   assert.equal(provenance.r160.source_predecessor_manifest_status,'STALE_REJECTED');
   assert.equal(pkg.dependencies['@modelcontextprotocol/client'],'2.3.1');
   assert.equal(pkg.dependencies['@modelcontextprotocol/server'],'2.3.1');

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

@@ -16,17 +16,17 @@ test('R190 package identity preserves R132 evidence and published R179 source pr
   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,'R190');
-  assert.equal(matrix.train,'R190');
-  assert.equal(release.source_predecessor.version,'0.15.69');
-  assert.equal(release.source_predecessor.train,'R179');
-  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.69\.tgz/i);
+  assert.equal(release.train,'R192');
+  assert.equal(matrix.train,'R192');
+  assert.equal(release.source_predecessor.version,'0.15.71');
+  assert.equal(release.source_predecessor.train,'R191');
+  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.71\.tgz/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,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
+  assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
   assert.notEqual(release.r179.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
-  assert.equal(release.runtime_predecessor.version,'0.15.68');
+  assert.equal(release.runtime_predecessor.version,'0.15.71');
   assert.equal(prov.runtime_predecessor.release_id,release.runtime_predecessor.release_id);
   assert.equal(prov.runtime_predecessor.manifest_sha256,release.runtime_predecessor.manifest_sha256);
   assert.equal(prov.runtime_predecessor.generation_manifest_sha256,release.runtime_predecessor.generation_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.70');
+ assert.equal(state.pkg.version,'0.15.72');
  assert.throws(()=>verifyR153Lineage(state),/package version/);
  await assert.rejects(verifyR153IdentityTree(root),/package version/);
 });

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

@@ -8,9 +8,9 @@ const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 
 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.68');
-  assert.equal(release.runtime_predecessor.release_id,'v0.15.68-ff29dbb2fbb89862');
-  assert.equal(release.runtime_predecessor.manifest_sha256,'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885');
+  assert.equal(release.runtime_predecessor.version,'0.15.71');
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.71-1818abc327478a96');
+  assert.equal(release.runtime_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
   assert.equal(release.r160.runtime_predecessor_version,'0.15.61');
   assert.equal(release.r160.source_predecessor_train,'R159');
   assert.equal(release.r160.public_tool_delta,0);

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.70');
+  assert.equal(JSON.parse(await readFile(path.join(envRoot,'package.json'),'utf8')).version,'0.15.72');
   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');

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

@@ -8,7 +8,7 @@ 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.70';
+const VERSION='0.15.72';
 const R166_MANIFEST='ad3c091fbbe2bac6d234548724008b67305fd483ad6542f92d5aeb1aa84f5849';
 const R166_TARBALL='3d22412c3cebabd66bfa92ca4dbaaf3ef49acba7f92436a16485d7e4cb18c653';
 
@@ -20,20 +20,20 @@ test('current package identity retains the immutable R167/R173 activation lineag
     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,'R190');
-  assert.equal(matrix.train,'R190');
-  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r190:0.15.70');
+  assert.equal(release.train,'R192');
+  assert.equal(matrix.train,'R192');
+  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r192:0.15.72');
   assert.deepEqual(release.runtime_predecessor,{
-    version:'0.15.68',release_id:'v0.15.68-ff29dbb2fbb89862',
-    manifest_sha256:'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885',
-    generation_manifest_sha256:'2887d4a8d54ea6fc6b28869072f72491c892dfe28178b3537936dce958147bd2'
+    version:'0.15.71',release_id:'v0.15.71-1818abc327478a96',
+    manifest_sha256:'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c',
+    generation_manifest_sha256:'aef437280102171a9b68da754fca16a03202104db7d5c420751624580ad6fadc'
   });
-  assert.equal(release.source_predecessor.version,'0.15.69');
-  assert.equal(release.source_predecessor.train,'R179');
-  assert.equal(release.source_predecessor.tarball_sha256,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
+  assert.equal(release.source_predecessor.version,'0.15.71');
+  assert.equal(release.source_predecessor.train,'R191');
+  assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
   assert.equal(release.r173.source_predecessor_version,'0.15.67');
   assert.equal(release.r167.source_predecessor_manifest_sha256,R166_MANIFEST);
-  assert.equal(provenance.source_predecessor_manifest_file_sha256,'cfede112761da00e73b626cfbce23d17e1d4b6e3a325bb675415196d31142ba0');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
   assert.equal(provenance.r173.source_predecessor_manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
   assert.equal(release.r172.source_predecessor_manifest_sha256,'962e227dace247d59aa860211388fbde461c5f9c8a7e8a878e34a14a27d355f8');
   assert.equal(release.r172.source_predecessor_tarball_sha256,'31b194a4fbff7dbdb9f4f275b4ea49c5115f7b0bb2241c0c72d72ef690311a5d');

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

@@ -13,8 +13,10 @@ const predecessorTarball='fc3ae5b1505e316bc9dfedf8d063cb00641754c8f5f1306a31f8cc
 
 test('R172 preserves the immutable R168 publication lineage separately from current identity',async()=>{
  const release=await read('RELEASE.json');
- assert.equal(release.runtime_predecessor.version,'0.15.68');
- assert.equal(release.parent.version,'0.15.68');
+ assert.equal(release.runtime_predecessor.version,'0.15.71');
+ assert.equal(release.parent.version,'0.15.71');
+ assert.equal(release.runtime_predecessor.release_id,'v0.15.71-1818abc327478a96');
+ assert.equal(release.parent.release_id,'v0.15.71-1818abc327478a96');
  assert.notEqual(release.runtime_predecessor.release_id,parent);
  assert.notEqual(release.parent.release_id,parent);
  assert.equal(release.r168.scope,'REMOTE_VERSION_SKEW_FAIL_CLOSED_AND_READONLY_RECONCILIATION');

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

@@ -16,12 +16,12 @@ test('R190 binds the published source predecessor separately from the active run
   const versions=[pkg.version,bridge.version,release.version,provenance.version,matrix.version,
     bom.metadata.component.version,DEADBYTE_VERSION];
   if(lock)versions.push(lock.version,lock.packages[''].version);
-  for(const value of versions)assert.equal(value,'0.15.70');
-  assert.equal(release.train,'R190'); assert.equal(matrix.train,'R190');
-  assert.equal(release.source_predecessor.version,'0.15.69');
-  assert.equal(release.source_predecessor.manifest_sha256,'cfede112761da00e73b626cfbce23d17e1d4b6e3a325bb675415196d31142ba0');
-  assert.equal(release.source_predecessor.tarball_sha256,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
-  assert.equal(release.runtime_predecessor.release_id,'v0.15.68-ff29dbb2fbb89862');
+  for(const value of versions)assert.equal(value,'0.15.72');
+  assert.equal(release.train,'R192'); assert.equal(matrix.train,'R192');
+  assert.equal(release.source_predecessor.version,'0.15.71');
+  assert.equal(release.source_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
+  assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
+  assert.equal(release.runtime_predecessor.release_id,'v0.15.71-1818abc327478a96');
   assert.equal(release.r173.public_tool_delta,0); assert.equal(release.r173.authority_scope_delta,0);
 });
 

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

@@ -13,21 +13,21 @@ test('R190 package identity binds the exact published R179 source and live runti
     json('package.json'),readReleaseLock(root),json('bridge/package.json'),json('RELEASE.json'),
     json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json')
   ]);
-  assert.equal(pkg.version,'0.15.70');
-  assert.equal(lock.version,'0.15.70');
-  assert.equal(lock.packages[''].version,'0.15.70');
-  assert.equal(bridge.version,'0.15.70');
-  assert.equal(release.version,'0.15.70');
-  assert.equal(release.train,'R190');
-  assert.equal(matrix.version,'0.15.70');
-  assert.equal(matrix.train,'R190');
-  assert.equal(sbom.metadata.component.version,'0.15.70');
-  assert.equal(release.source_predecessor.version,'0.15.69');
-  assert.equal(release.source_predecessor.train,'R179');
-  assert.equal(release.source_predecessor.manifest_sha256,'cfede112761da00e73b626cfbce23d17e1d4b6e3a325bb675415196d31142ba0');
-  assert.equal(release.source_predecessor.tarball_sha256,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
-  assert.equal(release.runtime_predecessor.version,'0.15.68');
-  assert.equal(provenance.version,'0.15.70');
+  assert.equal(pkg.version,'0.15.72');
+  assert.equal(lock.version,'0.15.72');
+  assert.equal(lock.packages[''].version,'0.15.72');
+  assert.equal(bridge.version,'0.15.72');
+  assert.equal(release.version,'0.15.72');
+  assert.equal(release.train,'R192');
+  assert.equal(matrix.version,'0.15.72');
+  assert.equal(matrix.train,'R192');
+  assert.equal(sbom.metadata.component.version,'0.15.72');
+  assert.equal(release.source_predecessor.version,'0.15.71');
+  assert.equal(release.source_predecessor.train,'R191');
+  assert.equal(release.source_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
+  assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
+  assert.equal(release.runtime_predecessor.version,'0.15.71');
+  assert.equal(provenance.version,'0.15.72');
   assert.equal(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
   assert.equal(provenance.source_predecessor_manifest_file_sha256,release.source_predecessor.manifest_sha256);
 });

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

@@ -7,23 +7,23 @@ import {DEADBYTE_VERSION} from '../src/version.mjs';
 import {readReleaseLock} from './helpers/release-lock.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
-const parent='v0.15.68-ff29dbb2fbb89862';
-const manifest='ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885';
-const generation='2887d4a8d54ea6fc6b28869072f72491c892dfe28178b3537936dce958147bd2';
+const parent='v0.15.71-1818abc327478a96';
+const manifest='1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c';
+const generation='aef437280102171a9b68da754fca16a03202104db7d5c420751624580ad6fadc';
 const tarball='1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf';
 test('R190 version, lock snapshot, bridge, matrix, SBOM and provenance identify exact 0.15.70 successor',async()=>{
  const [pkg,lock,bridge,release,provenance,matrix,sbom]=await Promise.all([
   read('package.json'),readReleaseLock(root),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,sbom.metadata.component.version,DEADBYTE_VERSION])assert.equal(version,'0.15.70');
- assert.equal(release.train,'R190');assert.equal(matrix.train,'R190');
- assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r190:0.15.70');
+  matrix.version,sbom.metadata.component.version,DEADBYTE_VERSION])assert.equal(version,'0.15.72');
+ assert.equal(release.train,'R192');assert.equal(matrix.train,'R192');
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r192:0.15.72');
  assert.equal(release.parent.release_id,parent);assert.equal(release.parent.manifest_sha256,manifest);
  assert.equal(release.parent.generation_manifest_sha256,generation);
- assert.equal(release.source_predecessor.version,'0.15.69');
- assert.equal(release.source_predecessor.manifest_sha256,'cfede112761da00e73b626cfbce23d17e1d4b6e3a325bb675415196d31142ba0');
- assert.equal(release.source_predecessor.tarball_sha256,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
+ assert.equal(release.source_predecessor.version,'0.15.71');
+ assert.equal(release.source_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
+ assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
  assert.equal(release.runtime_predecessor.release_id,parent);
  assert.equal(provenance.runtime_predecessor.release_id,parent);
  assert.equal(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
@@ -48,7 +48,7 @@ test('R190 retains historical R179 and R173 source evidence without promoting it
  assert.equal(release.r173.source_predecessor_version,'0.15.67');
  assert.equal(release.r173.source_predecessor_manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
  assert.equal(prov.r173.source_predecessor_version,'0.15.67');
- assert.equal(release.source_predecessor.version,'0.15.69');
+ assert.equal(release.source_predecessor.version,'0.15.71');
  assert.notEqual(release.source_predecessor.tarball_sha256,release.r173.source_predecessor_tarball_sha256);
 });
 test('R184 ships a semantic lock snapshot matching installed package identity and dependencies',async()=>{

package/test/r190-foreground-cli.test.mjs

@@ -1,13 +1,17 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {spawnSync} from 'node:child_process';
+import {mkdtemp,stat,rm} from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mjs';
 
 const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 
-test('R190 CLI exposes explicit marker recovery and applies the R89 trust boundary before mutation',async()=>{
+test('R190 CLI proves R89 before touching isolated controller and fails closed on absent launcher',async t=>{
+ const stateRoot=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r191-r190-cli-'));
+ t.after(()=>rm(stateRoot,{recursive:true,force:true}));
  const installation=await inspectTrustedInstallation([
   process.execPath,
   path.join(root,'src','deadbyte-cli.mjs'),
@@ -21,11 +25,17 @@ test('R190 CLI exposes explicit marker recovery and applies the R89 trust bounda
   path.join(root,'bin','deadbyte-epoch-lock-r85.node')
  ]).catch(()=>({trusted:false}));
  const result=spawnSync(process.execPath,['src/deadbyte-cli.mjs','remote','reconcileforeground',
-  '--confirm-marker-sha256','f'.repeat(64)],{encoding:'utf8',windowsHide:true,shell:false});
+  '--confirm-marker-sha256','f'.repeat(64)],{encoding:'utf8',windowsHide:true,shell:false,
+    env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}});
  const output=String(result.stdout||'')+String(result.stderr||'');
  assert.notEqual(result.status,0,output);
- if(installation.trusted) assert.match(output,/marker (?:hash differs from explicit confirmation|absent without a durable R190 intent)/);
- else assert.match(output,/R190_PROTECTED_RECOVERY_REQUIRED/);
+ if(installation.trusted){
+   // R89 succeeded, but this isolated fixture has no controller launcher.
+   // The test must fail closed before foreground marker or production access.
+   assert.match(output,/ENOENT: no such file or directory, lstat .*DEADBYTE-MCP\.ps1/);
+ }else assert.match(output,/R190_PROTECTED_RECOVERY_REQUIRED/);
+ await assert.rejects(stat(path.join(stateRoot,'evidence','foreground-recovery-r190')),{code:'ENOENT'});
+ await assert.rejects(stat(path.join(stateRoot,'runtime','remote-session.json')),{code:'ENOENT'});
  assert.doesNotMatch(output,/unsupported remote command|EXACT_ACTIVE_RELEASE_REQUIRED/);
 });
 

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

@@ -8,17 +8,17 @@ test('R190 candidate identity separates published source 0.15.69 from active run
   json('package.json'),json('bridge/package.json'),json('RELEASE.json'),json('PROVENANCE.json'),
   json('TEST-MATRIX.json'),json('SBOM.cdx.json'),readFile(new URL('../src/version.mjs',import.meta.url),'utf8')]);
  for(const value of [pkg.version,bridge.version,release.version,provenance.version,matrix.version,
-  sbom.metadata.component.version])assert.equal(value,'0.15.70');
- assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.70'/);
- assert.equal(release.train,'R190');assert.equal(matrix.train,'R190');
- assert.equal(release.source_predecessor.version,'0.15.69');
- assert.equal(release.source_predecessor.tarball_sha256,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
- assert.equal(release.source_predecessor.manifest_sha256,'cfede112761da00e73b626cfbce23d17e1d4b6e3a325bb675415196d31142ba0');
- assert.equal(release.runtime_predecessor.version,'0.15.68');
- assert.equal(release.runtime_predecessor.release_id,'v0.15.68-ff29dbb2fbb89862');
- assert.equal(provenance.source_predecessor_version,'0.15.69');
+  sbom.metadata.component.version])assert.equal(value,'0.15.72');
+ assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.72'/);
+ assert.equal(release.train,'R192');assert.equal(matrix.train,'R192');
+ assert.equal(release.source_predecessor.version,'0.15.71');
+ assert.equal(release.source_predecessor.tarball_sha256,'20ed3b20e72b4e4226736a1e432b05b851e9fa265e9bc2966b74f266477b7e27');
+ assert.equal(release.source_predecessor.manifest_sha256,'1818abc327478a96d935c200e25aad8515f15edc1842845b73bd0de57606da8c');
+ assert.equal(release.runtime_predecessor.version,'0.15.71');
+ assert.equal(release.runtime_predecessor.release_id,'v0.15.71-1818abc327478a96');
+ assert.equal(provenance.source_predecessor_version,'0.15.71');
  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
- assert.match(sbom.serialNumber,/r190:0\.15\.70$/);
+ assert.match(sbom.serialNumber,/r192:0\.15\.72$/);
 });
 
 test('R190 release metadata records verified recovery without claiming publication or activation',async()=>{

package/test/r191-epoch-root-selection.test.mjs

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as epoch from '../src/trusted-epoch-bootstrap-r158.mjs';
+
+const predecessor='C:\\Program Files\\DEADBYTE-R173-Protected-0.15.68-ff29dbb2fbb89862-Test';
+const candidate='C:\\Program Files\\DEADBYTE-01571-REGISTRY-candidate';
+test('R191 inherited predecessor epoch is rebound to exact successor staging root',()=>{
+  assert.equal(epoch.selectActivationEpochRoot({
+    configuredEpochRoot:predecessor,explicitEpochRoot:null,stageRoot:candidate
+  }),candidate);
+});
+test('R191 no inherited epoch does not create an authority epoch path',()=>{
+  assert.equal(epoch.selectActivationEpochRoot({
+    configuredEpochRoot:null,explicitEpochRoot:null,stageRoot:candidate
+  }),null);
+});
+test('R191 explicit epoch root remains exact and invalid paths reject',()=>{
+  assert.equal(epoch.selectActivationEpochRoot({
+    configuredEpochRoot:predecessor,explicitEpochRoot:candidate,stageRoot:candidate
+  }),candidate);
+  assert.throws(()=>epoch.selectActivationEpochRoot({
+    configuredEpochRoot:predecessor,explicitEpochRoot:'..\\writable',stageRoot:candidate
+  }),/absolute|root|path/i);
+});

package/test/r191-epoch-source-claim.test.mjs

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,sign} from 'node:crypto';
+import {mkdir,mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {createActivationClaimManager} from '../src/activation-lock-r65.mjs';
+
+const sha=v=>createHash('sha256').update(v).digest('hex');
+const DOMAIN=Buffer.from('DEADBYTE-R27-SLOT-UPDATE-V1\\0'.replace('\\0','\0'),'utf8');
+const manifest='d'.repeat(64);
+function receipt(body,key){
+  const bytes=Buffer.from(canonicalJson(body));
+  const signed=sign(null,Buffer.concat([DOMAIN,bytes]),key.privateKey);
+  const payload={body,body_sha256:sha(bytes),
+    attestation:{algorithm:'ed25519',domain:'DEADBYTE-R27-SLOT-UPDATE-V1',
+      key_id:sha(key.publicKey.export({type:'spki',format:'der'})),signature_base64:signed.toString('base64')}};
+  payload.receipt_sha256=sha(Buffer.from(canonicalJson(payload)));
+  return payload;
+}
+async function fixture({tamper=false,drift=false}={}){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r191-r65-'));
+  const updates=path.join(root,'evidence','updates'),trust=path.join(root,'trust');
+  await mkdir(updates,{recursive:true});await mkdir(trust,{recursive:true});
+  const key=generateKeyPairSync('ed25519');
+  await writeFile(path.join(trust,'ed25519-public.pem'),key.publicKey.export({type:'spki',format:'pem'}));
+  const prior={schema:'deadbyte.active-release.v1',release_id:'v0.15.68-ff29dbb2fbb89862',
+    version:'0.15.68',manifest_sha256:'f'.repeat(64),generation_manifest_sha256:'a'.repeat(64)};
+  await writeFile(path.join(root,'active-release.json'),JSON.stringify(drift?{...prior,release_id:'v0-other'}:prior));
+  const manager=createActivationClaimManager({stateRoot:root}),subject='b'.repeat(64);
+  const claim=await manager.claim(subject);
+  const updateId='r27-'+manifest.slice(0,16)+'-r191proof';
+  const dir=path.join(updates,updateId);await mkdir(dir);
+  const body={schema:'deadbyte.r27-slot-update-failure.v1',update_id:updateId,
+    release_version:'0.15.70',candidate_manifest_sha256:manifest,
+    failed_at_utc:new Date().toISOString(),result:'PRECONDITION_REJECTED',phase:'initial',
+    error:{name:'Error',code:null,message:'authority epoch exact release source hash mismatch: manifest.sha256'},
+    prior_pointer:prior,attempted_pointer:null,
+    rollback:{attempted:false,errors:[]}};
+  const signed=receipt(body,key);
+  if(tamper)signed.body.error.message='altered message';
+  await writeFile(path.join(dir,'failure-receipt.json'),JSON.stringify(signed));
+  await writeFile(path.join(updates,'r65-activation-outcome-r191.json'),JSON.stringify({
+    schema:'deadbyte.r65-activation-outcome.v1',claim_operation_id:claim.operation_id,
+    preflight_subject_sha256:subject,candidate_version:'0.15.70',
+    candidate_manifest_sha256:manifest,predecessor_release_id:prior.release_id,
+    outcome:{state:'ACTIVATION_OUTCOME_UNKNOWN',reason:body.error.message},
+    update_id:null,state_path:null,continuity_update_id:null,observed_at_utc:new Date().toISOString()
+  }));
+  return {root,manager,claim};
+}
+test('R191 signed initial epoch source mismatch may reconcile an R65 claim with unchanged predecessor',async()=>{
+  const f=await fixture();
+  try{const next=await f.manager.claim('c'.repeat(64));
+    assert.notEqual(next.operation_id,f.claim.operation_id);await next.release();
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+test('R191 tampered signed failure receipt cannot reconcile R65 claim',async()=>{
+  const f=await fixture({tamper:true});
+  try{await assert.rejects(()=>f.manager.claim('c'.repeat(64)),/unresolved|in progress/);}
+  finally{await rm(f.root,{recursive:true,force:true});}
+});
+test('R191 changed predecessor pointer cannot reconcile R65 claim',async()=>{
+  const f=await fixture({drift:true});
+  try{await assert.rejects(()=>f.manager.claim('c'.repeat(64)),/unresolved|in progress/);}
+  finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+
+test('R191 read-only inspection reports a safe signed precondition claim without reclaiming it',async()=>{
+  const f=await fixture();
+  try{
+    const before=await readFile(path.join(f.root,'evidence','updates','r65-activation.lock'),'utf8');
+    const audit=await f.manager.inspect();
+    assert.equal(audit.status,'RECONCILABLE');
+    assert.equal(audit.operation_id,f.claim.operation_id);
+    const after=await readFile(path.join(f.root,'evidence','updates','r65-activation.lock'),'utf8');
+    assert.equal(after,before);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+test('R191 read-only inspection leaves a tampered evidence claim blocked',async()=>{
+  const f=await fixture({tamper:true});
+  try{
+    const audit=await f.manager.inspect();
+    assert.equal(audit.status,'UNRESOLVED');
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});

package/test/r191-inherited-epoch-preflight.test.mjs

@@ -0,0 +1,65 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,readFile,readdir,rm,writeFile} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const src=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const H=b=>createHash('sha256').update(b).digest('hex');
+
+test('R191 real preflight rejects writable staging when predecessor has a protected epoch', {skip:process.platform!=='win32'}, async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r191-preflight-'));
+  try{
+    const state=path.join(root,'state'),bin=path.join(state,'bin'),gen=path.join(state,'generations','parent'),policies=path.join(state,'policies');
+    await Promise.all([mkdir(bin,{recursive:true}),mkdir(gen,{recursive:true}),mkdir(policies,{recursive:true}),mkdir(path.join(state,'runtime'),{recursive:true})]);
+    const release=JSON.parse(await readFile(path.join(src,'RELEASE.json'),'utf8'));
+    const configFields={process:'ProcessPolicyFile',coding:'CodingPolicyFile',autonomous:'AutonomousPolicyFile',desktop:'DesktopPolicyFile',host:'HostPolicyFile'};
+    const policyPaths={};
+    for(const plane of Object.keys(configFields)){
+      const f=path.join(policies,plane+'.json');
+      const grant=path.join(state,'runtime',plane+'-grant.json');
+      const grantField=plane==='host'?'arm_file':plane==='process'||plane==='desktop'?'grant_file':'lease_file';
+      await writeFile(f,JSON.stringify({schema:plane==='host'?'deadbyte.host-policy.v2':'deadbyte.'+plane+'-policy.v1',enabled:true,[grantField]:grant}));
+      policyPaths[configFields[plane]]=f;
+    }
+    const configPath=path.join(gen,'controller-config.psd1');
+    const epoch='C:\\Program Files\\DEADBYTE-R173-Protected-0.15.68-ff29dbb2fbb89862-Test';
+    await writeFile(configPath,'@{ '+Object.entries({...policyPaths,AuthorityEpochRoot:epoch}).map(([k,v])=>k+" = '"+v.replaceAll("'","''")+"'").join('; ')+' }');
+    const pointer={schema:'deadbyte.active-release.v1',...release.parent,release_root:path.join(state,'releases',release.parent.release_id),generation_root:gen,
+      launcher_sha256:H('launcher'),config_path:configPath};
+    const pointerBytes=Buffer.from(JSON.stringify(pointer));
+    await writeFile(path.join(state,'active-release.json'),pointerBytes);
+    const disarmed={configured:true,armed:false,reason:'disarmed'};
+    const observation={schema:'deadbyte.controller-observation.v1',state:'ONLINE',local_ready:true,
+      bridge:{alive:true,reason:'verified',pid:111},core:{alive:true,reason:'verified',pid:112},
+      cloud:{alive:true,reason:'verified',pid:113},supervisor:{running:true},
+      authority:Object.fromEntries(Object.keys(configFields).map(plane=>[plane,disarmed]))};
+    const observed=path.join(state,'observed.json');await writeFile(observed,JSON.stringify(observation));
+    const ps="param([string]$Command,[switch]$Json)\nif($Command -ne 'status' -or -not $Json){throw 'unexpected mutation'}\nGet-Content -Raw -LiteralPath '"+observed.replaceAll("'","''")+"'\n";
+    await writeFile(path.join(bin,'DEADBYTE-MCP.ps1'),ps);
+    const result=spawnSync(process.execPath,[path.join(src,'scripts','deploy-r48.mjs'),'--preflight'],{
+      env:{...process.env,DEADBYTE_STATE_ROOT:state},cwd:src,encoding:'utf8',timeout:30000,windowsHide:true});
+    assert.equal(result.status,0,result.stderr);
+    const preflight=JSON.parse(result.stdout.trim());
+    assert.equal(preflight.state,'ONLINE_READY');
+    assert.equal(preflight.authority_continuity,'NOT_APPLICABLE');
+    // The same exact release may execute from a writable developer tree
+    // or from an R89-protected immutable installation. The decision must
+    // follow OS ACL trust, not the test file's assumed extraction location.
+    const {inspectTrustedInstallation,privilegedEpochInstallFiles}=await import('../src/privileged-install-trust-r89.mjs');
+    let stageTrusted=false;
+    try {
+      const trust=await inspectTrustedInstallation(privilegedEpochInstallFiles(src,process.execPath));
+      stageTrusted=trust.trusted===true;
+    } catch {stageTrusted=false;}
+    assert.equal(preflight.safe_to_activate,stageTrusted);
+    assert.equal(preflight.activation_entrypoint_state,stageTrusted?'TRUSTED_READY':'REJECTED');
+    assert.equal(preflight.protected_activation_entrypoint,stageTrusted);
+    if(stageTrusted)assert.equal(preflight.activation_entrypoint_reason,null);
+    else assert.match(preflight.activation_entrypoint_reason,/R89|ACL|protected/i);
+    assert.equal(H(await readFile(path.join(state,'active-release.json'))),H(pointerBytes));
+    await assert.rejects(readdir(path.join(state,'evidence','updates')),e=>e?.code==='ENOENT');
+  } finally {await rm(root,{recursive:true,force:true});}
+});