deadbyte-mcp 0.15.69 → 0.15.71

package/src/foreground-owner-recovery-r190.mjs

@@ -0,0 +1,117 @@
+// Explicit, marker-only recovery for pre-R175 foreground ownership records.
+// It never starts/stops runtime processes and never creates, revokes or restores
+// authority. The caller must provide native CAS deletion and no-clobber evidence.
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {canonicalJson} from './canonical-json.mjs';
+import {foregroundIdentityMatches,validForegroundIdentity} from './foreground-process-identity.mjs';
+
+const SHA=/^[0-9a-f]{64}$/;
+const PLANES=['process','coding','autonomous','desktop','host'];
+const hash=value=>createHash('sha256').update(Buffer.from(canonicalJson(value))).digest('hex');
+function insist(condition,message){if(!condition)throw new Error(`R190 foreground recovery blocked: ${message}`);}
+function pointerSubject(pointer){
+ const fields=['release_id','version','manifest_sha256','generation_manifest_sha256','generation_root'];
+ insist(pointer&&typeof pointer==='object','active pointer missing');
+ for(const field of fields)insist(typeof pointer[field]==='string'&&pointer[field].length>0,`active pointer ${field} invalid`);
+ insist(SHA.test(pointer.manifest_sha256)&&SHA.test(pointer.generation_manifest_sha256),'active pointer digest invalid');
+ insist(path.isAbsolute(pointer.generation_root),'active generation root invalid');
+ return Object.freeze(Object.fromEntries(fields.map(field=>[field,pointer[field]])));
+}
+function authoritySubject(observation){
+ insist(observation?.state==='ONLINE'&&observation.local_ready===true,'runtime is not verified ONLINE');
+ insist(observation?.supervisor?.running===true,'supervisor is not verified running');
+ const subject={state:'ONLINE',local_ready:true,supervisor_running:true};
+ for(const plane of PLANES){
+  const value=observation.authority?.[plane];
+  insist(value?.configured===true&&typeof value.armed==='boolean'&&typeof value.reason==='string',`${plane} authority unverified`);
+  subject[plane]=Object.freeze({configured:true,armed:value.armed,reason:value.reason});
+ }
+ return Object.freeze(subject);
+}
+function staleIdentity(identity,queryIdentity,label){
+ insist(validForegroundIdentity(identity),`${label} identity invalid`);
+ let actual;
+ try{actual=queryIdentity(identity);}catch{throw new Error(`R190 foreground recovery blocked: ${label} identity observation unavailable`);}
+ if(actual===null)return Object.freeze({pid:identity.pid,state:'absent'});
+ insist(validForegroundIdentity(actual),`${label} current identity invalid`);
+ insist(!foregroundIdentityMatches(identity,actual),`${label} process is still active`);
+ return Object.freeze({pid:identity.pid,state:'pid_reused',actual_creation_utc:actual.creation_utc,
+  actual_executable_path:actual.executable_path});
+}
+function terminalFor(intent,status,completedAt){
+ const body={schema:'deadbyte.r190-foreground-recovery-terminal.v1',status,
+  intent_sha256:intent.intent_sha256,marker_sha256:intent.marker_sha256,
+  pointer:intent.pointer,authority:intent.authority,completed_at_utc:completedAt};
+ return Object.freeze({...body,receipt_sha256:hash(body)});
+}
+function validateIntent(intent,expected,pointer,authority){
+ insist(intent?.schema==='deadbyte.r190-foreground-recovery-intent.v1','recovery intent schema invalid');
+ insist(intent.marker_sha256===expected,'recovery intent marker mismatch');
+ const body={...intent};delete body.intent_sha256;
+ insist(SHA.test(String(intent.intent_sha256))&&hash(body)===intent.intent_sha256,'recovery intent digest invalid');
+ insist(canonicalJson(intent.pointer)===canonicalJson(pointer),'active pointer drift after marker delete');
+ insist(canonicalJson(intent.authority)===canonicalJson(authority),'authority drift after marker delete');
+}
+
+export async function recoverLegacyForegroundOwnership({
+ expectedMarkerSha256,readMarkerSnapshot,deleteMarkerIfHash,readActivePointer,readAuthority,
+ queryIdentity,loadIntent,loadTerminal,publishIntent,publishTerminal,now=()=>new Date()
+}={}){
+ insist(typeof expectedMarkerSha256==='string'&&SHA.test(expectedMarkerSha256),'confirmation SHA-256 invalid');
+ for(const [name,fn] of Object.entries({readMarkerSnapshot,deleteMarkerIfHash,readActivePointer,
+  readAuthority,queryIdentity,loadIntent,loadTerminal,publishIntent,publishTerminal}))
+  insist(typeof fn==='function',`${name} callback missing`);
+ const pointer=pointerSubject(await readActivePointer());
+ const authority=authoritySubject(await readAuthority());
+ const snapshot=await readMarkerSnapshot();
+ const priorIntent=await loadIntent();
+ const priorTerminal=await loadTerminal();
+ if(snapshot===null){
+  insist(priorIntent,'marker absent without a durable R190 intent');
+  validateIntent(priorIntent,expectedMarkerSha256,pointer,authority);
+  if(priorTerminal){
+   insist(priorTerminal.intent_sha256===priorIntent.intent_sha256&&priorTerminal.marker_sha256===expectedMarkerSha256,
+    'terminal identity mismatch');
+   return Object.freeze({status:'MARKER_ALREADY_RECONCILED',marker_sha256:expectedMarkerSha256,
+    intent_sha256:priorIntent.intent_sha256,receipt_sha256:priorTerminal.receipt_sha256});
+  }
+  const terminal=terminalFor(priorIntent,'MARKER_RECONCILED_AFTER_DELETE',now().toISOString());
+  await publishTerminal(terminal);
+  return Object.freeze({status:terminal.status,marker_sha256:expectedMarkerSha256,
+   intent_sha256:priorIntent.intent_sha256,receipt_sha256:terminal.receipt_sha256});
+ }
+ insist(snapshot?.sha256===expectedMarkerSha256,'marker hash differs from explicit confirmation');
+ const marker=snapshot.marker;
+ insist(marker?.schema==='deadbyte.remote-session.v2','marker schema is not recoverable');
+ insist(marker.authority_scope===undefined||marker.authority_scope===null,'scoped marker must use its normal lifecycle');
+ insist(Number.isInteger(marker.owner_pid)&&marker.owner_pid>0&&marker.owner_identity,'owner marker identity invalid');
+ insist(Number.isInteger(marker.guardian_pid)&&marker.guardian_pid>0&&marker.guardian_identity,'guardian marker identity invalid');
+ const owner=staleIdentity(marker.owner_identity,queryIdentity,'owner');
+ const guardian=staleIdentity(marker.guardian_identity,queryIdentity,'guardian');
+ const intentBody={schema:'deadbyte.r190-foreground-recovery-intent.v1',action:'reconcile_legacy_foreground_marker_only',
+  marker_sha256:expectedMarkerSha256,pointer,authority,owner,guardian,requested_at_utc:now().toISOString(),
+  authority_mutation_allowed:false,runtime_mutation_allowed:false};
+ const intent=Object.freeze({...intentBody,intent_sha256:hash(intentBody)});
+ if(priorIntent)validateIntent(priorIntent,expectedMarkerSha256,pointer,authority);
+ else await publishIntent(intent);
+ const pinnedIntent=priorIntent??intent;
+ const pointerBeforeDelete=pointerSubject(await readActivePointer());
+ const authorityBeforeDelete=authoritySubject(await readAuthority());
+ insist(canonicalJson(pointerBeforeDelete)===canonicalJson(pointer),'active pointer drift before CAS delete');
+ insist(canonicalJson(authorityBeforeDelete)===canonicalJson(authority),'authority drift before CAS delete');
+ const current=await readMarkerSnapshot();
+ insist(current?.sha256===expectedMarkerSha256,'marker changed before CAS delete');
+ staleIdentity(marker.owner_identity,queryIdentity,'owner');
+ staleIdentity(marker.guardian_identity,queryIdentity,'guardian');
+ insist(await deleteMarkerIfHash(expectedMarkerSha256)==='REMOVED','native marker CAS did not remove exact identity');
+ insist(await readMarkerSnapshot()===null,'marker remained or reappeared after CAS delete');
+ const finalPointer=pointerSubject(await readActivePointer());
+ const finalAuthority=authoritySubject(await readAuthority());
+ insist(canonicalJson(finalPointer)===canonicalJson(pointer),'active pointer drift after CAS delete');
+ insist(canonicalJson(finalAuthority)===canonicalJson(authority),'authority drift after CAS delete');
+ const terminal=terminalFor(pinnedIntent,'MARKER_RECONCILED',now().toISOString());
+ await publishTerminal(terminal);
+ return Object.freeze({status:terminal.status,marker_sha256:expectedMarkerSha256,
+  intent_sha256:pinnedIntent.intent_sha256,receipt_sha256:terminal.receipt_sha256});
+}

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.69';
+export const DEADBYTE_VERSION = '0.15.71';
 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.r191_activation_repair?.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

@@ -8,19 +8,19 @@ 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'));
-test('current successor retains the R130 security baseline with truthful R179 identity',async()=>{
+test('current successor retains the R130 security baseline with truthful R190 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'),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.69');
-  assert.equal(release.train,'R179');
-  assert.equal(matrix.train,'R179');
-  assert.equal(release.source_predecessor.version,'0.15.68');
-  assert.equal(release.source_predecessor.train,'R173');
-  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.68\.tgz/i);
-  assert.equal(release.source_predecessor.manifest_status,'ACTIVE_PRODUCTION_MANIFEST_VERIFIED');
+    assert.equal(actual,'0.15.71');
+  assert.equal(release.train,'R191');
+  assert.equal(matrix.train,'R191');
+  assert.equal(release.source_predecessor.version,'0.15.70');
+  assert.equal(release.source_predecessor.train,'R190');
+  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.70\.tgz/i);
+  assert.equal(release.source_predecessor.manifest_status,'PUBLISHED_EXACT_MANIFEST_VERIFIED_NOT_ACTIVE');
   assert.equal(release.runtime_predecessor.version,'0.15.68');
   assert.equal(provenance.r160.source_predecessor_manifest_status,'STALE_REJECTED');
   assert.equal(pkg.dependencies['@modelcontextprotocol/client'],'2.3.1');

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

@@ -9,23 +9,23 @@ import {readReleaseLock} from './helpers/release-lock.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('R179 package identity preserves R132 evidence and published R173 source predecessor',async()=>{
+test('R190 package identity preserves R132 evidence and published R179 source predecessor',async()=>{
   const [pkg,lock,release,prov,bom,matrix]=await Promise.all([
     read('package.json'),readReleaseLock(root),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,'R179');
-  assert.equal(matrix.train,'R179');
-  assert.equal(release.source_predecessor.version,'0.15.68');
-  assert.equal(release.source_predecessor.train,'R173');
-  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.68\.tgz/i);
+  assert.equal(release.train,'R191');
+  assert.equal(matrix.train,'R191');
+  assert.equal(release.source_predecessor.version,'0.15.70');
+  assert.equal(release.source_predecessor.train,'R190');
+  assert.match(release.source_predecessor.source_path,/deadbyte-mcp-0\.15\.70\.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,'1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf');
-  assert.equal(release.r179.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+  assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
+  assert.notEqual(release.r179.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
   assert.equal(release.runtime_predecessor.version,'0.15.68');
   assert.equal(prov.runtime_predecessor.release_id,release.runtime_predecessor.release_id);
   assert.equal(prov.runtime_predecessor.manifest_sha256,release.runtime_predecessor.manifest_sha256);

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

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

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

@@ -8,7 +8,8 @@ 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.69';
+const packageIdentity=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+const version=packageIdentity.version;
 const parent=path.join(os.homedir(),'.deadbyte-mcp','releases','v0.15.68-ff29dbb2fbb89862');
 const parentDigest='ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885';
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
@@ -21,12 +22,11 @@ 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('R179 isolated immutable slot activates, rolls back, and restores 0.15.69 without authority or production mutation',async()=>{
+test('R179 isolated immutable slot activates, rolls back, and restores the current successor without authority or production mutation',async()=>{
   const stateBase=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r163-isolated-'));
   const state=path.join(stateBase,'state');
   try{
-    const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
-    assert.equal(pkg.version,version);
+    assert.match(version,/^0\.15\.\d+$/);
     const parentManifest=await readFile(path.join(parent,'MANIFEST.SHA256'));
     const nextManifest=await readFile(path.join(candidate,'MANIFEST.SHA256'));
     assert.equal(sha(parentManifest),parentDigest);

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.69');
+  assert.equal(JSON.parse(await readFile(path.join(envRoot,'package.json'),'utf8')).version,'0.15.71');
   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.69';
+const VERSION='0.15.71';
 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,'R179');
-  assert.equal(matrix.train,'R179');
-  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r179:0.15.69');
+  assert.equal(release.train,'R191');
+  assert.equal(matrix.train,'R191');
+  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r191:0.15.71');
   assert.deepEqual(release.runtime_predecessor,{
     version:'0.15.68',release_id:'v0.15.68-ff29dbb2fbb89862',
     manifest_sha256:'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885',
     generation_manifest_sha256:'2887d4a8d54ea6fc6b28869072f72491c892dfe28178b3537936dce958147bd2'
   });
-  assert.equal(release.source_predecessor.version,'0.15.68');
-  assert.equal(release.source_predecessor.train,'R173');
-  assert.equal(release.source_predecessor.tarball_sha256,'1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf');
+  assert.equal(release.source_predecessor.version,'0.15.70');
+  assert.equal(release.source_predecessor.train,'R190');
+  assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
   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,'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
   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/r172-release-contract.test.mjs

@@ -9,18 +9,18 @@ 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;}};
 
-test('R179 binds the published source predecessor separately from the active runtime predecessor',async()=>{
+test('R190 binds the published source predecessor separately from the active runtime predecessor',async()=>{
   const [pkg,lock,bridge,release,provenance,matrix,bom]=await Promise.all([
     read('package.json'),readOptional('package-lock.json'),read('bridge/package.json'),read('RELEASE.json'),
     read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
   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.69');
-  assert.equal(release.train,'R179'); assert.equal(matrix.train,'R179');
-  assert.equal(release.source_predecessor.version,'0.15.68');
-  assert.equal(release.source_predecessor.manifest_sha256,'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885');
-  assert.equal(release.source_predecessor.tarball_sha256,'1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf');
+  for(const value of versions)assert.equal(value,'0.15.71');
+  assert.equal(release.train,'R191'); assert.equal(matrix.train,'R191');
+  assert.equal(release.source_predecessor.version,'0.15.70');
+  assert.equal(release.source_predecessor.manifest_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
+  assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
   assert.equal(release.runtime_predecessor.release_id,'v0.15.68-ff29dbb2fbb89862');
   assert.equal(release.r173.public_tool_delta,0); assert.equal(release.r173.authority_scope_delta,0);
 });

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

@@ -8,26 +8,26 @@ import {readReleaseLock} from './helpers/release-lock.mjs';
 const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
 const json=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
 
-test('R179 package identity binds the exact published R173 source and live runtime predecessor',async()=>{
+test('R190 package identity binds the exact published R179 source and live runtime predecessor',async()=>{
   const [pkg,lock,bridge,release,provenance,matrix,sbom]=await Promise.all([
     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.69');
-  assert.equal(lock.version,'0.15.69');
-  assert.equal(lock.packages[''].version,'0.15.69');
-  assert.equal(bridge.version,'0.15.69');
-  assert.equal(release.version,'0.15.69');
-  assert.equal(release.train,'R179');
-  assert.equal(matrix.version,'0.15.69');
-  assert.equal(matrix.train,'R179');
-  assert.equal(sbom.metadata.component.version,'0.15.69');
-  assert.equal(release.source_predecessor.version,'0.15.68');
-  assert.equal(release.source_predecessor.train,'R173');
-  assert.equal(release.source_predecessor.manifest_sha256,'ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885');
-  assert.equal(release.source_predecessor.tarball_sha256,'1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf');
+  assert.equal(pkg.version,'0.15.71');
+  assert.equal(lock.version,'0.15.71');
+  assert.equal(lock.packages[''].version,'0.15.71');
+  assert.equal(bridge.version,'0.15.71');
+  assert.equal(release.version,'0.15.71');
+  assert.equal(release.train,'R191');
+  assert.equal(matrix.version,'0.15.71');
+  assert.equal(matrix.train,'R191');
+  assert.equal(sbom.metadata.component.version,'0.15.71');
+  assert.equal(release.source_predecessor.version,'0.15.70');
+  assert.equal(release.source_predecessor.train,'R190');
+  assert.equal(release.source_predecessor.manifest_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
+  assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
   assert.equal(release.runtime_predecessor.version,'0.15.68');
-  assert.equal(provenance.version,'0.15.69');
+  assert.equal(provenance.version,'0.15.71');
   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

@@ -11,23 +11,23 @@ const parent='v0.15.68-ff29dbb2fbb89862';
 const manifest='ff29dbb2fbb898625592afb47835a4a62ef289429f1e0a89a83242398cd98885';
 const generation='2887d4a8d54ea6fc6b28869072f72491c892dfe28178b3537936dce958147bd2';
 const tarball='1a7f1fe05a06178b8d772a140be6e0470790b743cef690c3f8f8165cc61075bf';
-test('R179 version, lockfile, bridge, matrix, SBOM and provenance identify exact 0.15.69 successor',async()=>{
+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.69');
- assert.equal(release.train,'R179');assert.equal(matrix.train,'R179');
- assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r179:0.15.69');
+  matrix.version,sbom.metadata.component.version,DEADBYTE_VERSION])assert.equal(version,'0.15.71');
+ assert.equal(release.train,'R191');assert.equal(matrix.train,'R191');
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r191:0.15.71');
  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.68');
- assert.equal(release.source_predecessor.manifest_sha256,manifest);
- assert.equal(release.source_predecessor.tarball_sha256,tarball);
+ assert.equal(release.source_predecessor.version,'0.15.70');
+ assert.equal(release.source_predecessor.manifest_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
+ assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
  assert.equal(release.runtime_predecessor.release_id,parent);
  assert.equal(provenance.runtime_predecessor.release_id,parent);
- assert.equal(provenance.parent_tarball_sha256,tarball);
- assert.equal(provenance.source_predecessor_tarball_sha256,tarball);
+ assert.equal(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
+ assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
 });
 test('R179 does not misrepresent owner Autonomous enrollment, protected regression or publication as finished',async()=>{
  const [release,prov,matrix]=await Promise.all(['RELEASE.json','PROVENANCE.json','TEST-MATRIX.json'].map(read));
@@ -43,12 +43,12 @@ test('R179 does not misrepresent owner Autonomous enrollment, protected regressi
  assert.ok(matrix.required.some(r=>r.id==='r179-owner-authorized-autonomous'));
  assert.ok(matrix.required.some(r=>r.id==='r179-protected-full'));
 });
-test('R179 retains historical R173 source ancestor evidence without promoting it to current parent',async()=>{
+test('R190 retains historical R179 and R173 source evidence without promoting it to current parent',async()=>{
  const [release,prov]=await Promise.all(['RELEASE.json','PROVENANCE.json'].map(read));
  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.68');
+ assert.equal(release.source_predecessor.version,'0.15.70');
  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

@@ -0,0 +1,51 @@
+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 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'),
+  path.join(root,'MANIFEST.SHA256'),
+  path.join(root,'src','foreground-owner-recovery-r190.mjs'),
+  path.join(root,'src','foreground-marker-cas-win32.mjs'),
+  path.join(root,'src','foreground-process-identity.mjs'),
+  path.join(root,'src','foreground-session-lock.mjs'),
+  path.join(root,'src','privileged-install-trust-r89.mjs'),
+  path.join(root,'src','canonical-json.mjs'),
+  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,
+    env:{...process.env,DEADBYTE_STATE_ROOT:stateRoot}});
+ const output=String(result.stdout||'')+String(result.stderr||'');
+ assert.notEqual(result.status,0,output);
+ 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/);
+});
+
+test('R190 CLI requires exact marker hash and never accepts recovery confirmation on another command',()=>{
+ const missing=spawnSync(process.execPath,['src/deadbyte-cli.mjs','remote','reconcileforeground'],
+  {encoding:'utf8',windowsHide:true,shell:false});
+ assert.notEqual(missing.status,0);
+ assert.match(String(missing.stderr),/requires --confirm-marker-sha256/);
+ const confused=spawnSync(process.execPath,['src/deadbyte-cli.mjs','remote','status',
+  '--confirm-marker-sha256','f'.repeat(64)],{encoding:'utf8',windowsHide:true,shell:false});
+ assert.notEqual(confused.status,0);
+ assert.match(String(confused.stderr),/valid only with reconcileforeground/);
+});

package/test/r190-foreground-owner-recovery.test.mjs

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {recoverLegacyForegroundOwnership} from '../src/foreground-owner-recovery-r190.mjs';
+
+const H=char=>char.repeat(64);
+const owner={schema:'deadbyte.foreground-process.v1',pid:9496,parent_pid:5272,
+ creation_utc:'2026-10-27T12:25:38.764342Z',executable_path:'C:\\Program Files\\nodejs\\node.exe',command_line_sha256:H('a')};
+const guardian={...owner,pid:10456,parent_pid:9496,creation_utc:'2026-10-27T12:25:39.244355Z',command_line_sha256:H('b')};
+const marker={schema:'deadbyte.remote-session.v2',owner_pid:9496,guardian_pid:10456,
+ session_nonce:H('c'),result_session_id:'b0015a97167ff20bf4e15588',started_at_utc:'2026-10-27T12:25:38.994Z',owner_identity:owner,guardian_identity:guardian};
+const pointer={release_id:'v0.15.68-'+H('d').slice(0,16),version:'0.15.68',manifest_sha256:H('d'),
+ generation_manifest_sha256:H('e'),generation_root:'C:\\Users\\DEADBYTE\\.deadbyte-mcp\\generations\\fixture'};
+const authority={state:'ONLINE',local_ready:true,supervisor:{running:true},authority:Object.fromEntries(
+ ['process','coding','autonomous','desktop','host'].map((plane,index)=>[plane,{configured:true,armed:[true,true,false,false,true][index],reason:[true,true,false,false,true][index]?'standing-grant':'disarmed'}]))};
+
+function harness({ownerActual={...owner,pid:9496,creation_utc:'2026-10-28T03:22:41.668663Z',executable_path:'C:\\Windows\\WidgetBoard.exe'},
+ guardianActual=null,driftPointer=false,terminalFailure=false}={}){
+ let snapshot={marker,sha256:H('f')},intent=null,terminal=null,deletes=0,pointerReads=0;
+ return {state:()=>({snapshot,intent,terminal,deletes}),run:()=>recoverLegacyForegroundOwnership({
+  expectedMarkerSha256:H('f'),readMarkerSnapshot:async()=>snapshot,
+  deleteMarkerIfHash:async expected=>{assert.equal(expected,H('f'));snapshot=null;deletes++;return 'REMOVED';},
+  readActivePointer:async()=>{pointerReads++;return driftPointer&&pointerReads>1?{...pointer,release_id:'changed'}:pointer;},
+  readAuthority:async()=>authority,
+  queryIdentity:identity=>identity.pid===owner.pid?ownerActual:guardianActual,
+  loadIntent:async()=>intent,loadTerminal:async()=>terminal,
+  publishIntent:async value=>{intent=value;return {sha256:value.intent_sha256};},
+  publishTerminal:async value=>{if(terminalFailure){terminalFailure=false;throw new Error('terminal write failed');}terminal=value;return {sha256:value.receipt_sha256};},
+  now:()=>new Date('2026-10-28T07:00:00.000Z')
+ })};
+}
+
+test('R190 explicit owner recovery CAS-removes only a PID-reused legacy marker and preserves authority vector',async()=>{
+ const h=harness(),result=await h.run(),state=h.state();
+ assert.equal(result.status,'MARKER_RECONCILED');
+ assert.equal(state.deletes,1);
+ assert.equal(state.snapshot,null);
+ assert.equal(state.intent.authority.process.armed,true);
+ assert.equal(state.intent.authority.coding.armed,true);
+ assert.equal(state.intent.authority.autonomous.armed,false);
+ assert.equal(state.intent.authority.host.armed,true);
+ assert.equal(state.terminal.marker_sha256,H('f'));
+});
+
+test('R190 refuses live matching owner and pointer drift without deleting marker',async()=>{
+ const live=harness({ownerActual:owner});
+ await assert.rejects(()=>live.run(),/owner.*active/i);
+ assert.equal(live.state().deletes,0);
+ const drift=harness({driftPointer:true});
+ await assert.rejects(()=>drift.run(),/pointer.*drift/i);
+ assert.equal(drift.state().deletes,0);
+});
+
+test('R190 resumes terminal publication after crash following native CAS delete without repeating mutation',async()=>{
+ const h=harness({terminalFailure:true});
+ await assert.rejects(()=>h.run(),/terminal write failed/);
+ assert.equal(h.state().deletes,1);
+ const result=await h.run();
+ assert.equal(result.status,'MARKER_RECONCILED_AFTER_DELETE');
+ assert.equal(h.state().deletes,1);
+ assert.ok(h.state().terminal);
+});

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

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const json=async file=>JSON.parse(await readFile(new URL('../'+file,import.meta.url),'utf8'));
+test('R190 candidate identity separates published source 0.15.69 from active runtime 0.15.68',async()=>{
+ const [pkg,bridge,release,provenance,matrix,sbom,versionSource]=await Promise.all([
+  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.71');
+ assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.71'/);
+ assert.equal(release.train,'R191');assert.equal(matrix.train,'R191');
+ assert.equal(release.source_predecessor.version,'0.15.70');
+ assert.equal(release.source_predecessor.tarball_sha256,'1a5f5f30bf4781ed951d6d201b8a972d088b2091555d7f4cc2e2bb899ed5707e');
+ assert.equal(release.source_predecessor.manifest_sha256,'df15db35c7ddddd769650f5c86557159d10d99e9eef4dd232cae67faeb8ad6e3');
+ 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.70');
+ assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
+ assert.match(sbom.serialNumber,/r191:0\.15\.71$/);
+});
+
+test('R190 release metadata records verified recovery without claiming publication or activation',async()=>{
+ const release=await json('RELEASE.json');
+ assert.equal(release.r190_foreground_recovery.status,'PREPUBLISH_VERIFIED');
+ assert.equal(release.r190_foreground_recovery.npm_published,false);
+ assert.equal(release.r190_foreground_recovery.production_activated,false);
+ assert.equal(release.r190_foreground_recovery.live_marker_reconciled,true);
+ assert.equal(release.r190_foreground_recovery.authority_mutation_allowed,false);
+ assert.equal(release.r190_foreground_recovery.runtime_mutation_allowed,false);
+ assert.match(release.r190_foreground_recovery.protected_full_regression,/0_FAIL$/);
+});