deadbyte-mcp 0.15.68 → 0.15.70

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

@@ -4,28 +4,29 @@ import {readFile} from 'node:fs/promises';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 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 rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 
-test('R173 package identity preserves R132 evidence and published R172 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'),read('package-lock.json'),read('RELEASE.json'),
+    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,'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.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(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,'0fe761f035f38730a4717448da4217f55464c38cd1616126b5850ff44411cd6d');
-  assert.equal(release.r173.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
-  assert.equal(release.runtime_predecessor.version,'0.15.61');
+  assert.equal(release.source_predecessor.tarball_sha256,'578c1630608f9df816524c78abc9e1a55357fdc3cd25e142122f1a823e1d69e3');
+  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);
   assert.equal(prov.runtime_predecessor.generation_manifest_sha256,release.runtime_predecessor.generation_manifest_sha256);
@@ -36,7 +37,7 @@ test('R173 package identity preserves R132 evidence and published R172 source pr
 });
 
 test('R132 shipped SBOM matches the actual audited bundled MCP SDK',async()=>{
-  const [pkg,bom,lock]=await Promise.all([read('package.json'),read('SBOM.cdx.json'),read('package-lock.json')]);
+  const [pkg,bom,lock]=await Promise.all([read('package.json'),read('SBOM.cdx.json'),readReleaseLock(root)]);
   for(const name of ['@modelcontextprotocol/client','@modelcontextprotocol/server','@modelcontextprotocol/core']){
     const entry=bom.components.find(v=>v.name===name);
     assert.ok(entry,'missing SBOM component: '+name);

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.68');
+ assert.equal(state.pkg.version,'0.15.70');
  assert.throws(()=>verifyR153Lineage(state),/package version/);
  await assert.rejects(verifyR153IdentityTree(root),/package version/);
 });

package/test/r155-default-live-log.test.mjs

@@ -14,25 +14,25 @@ function defaultTracker(){
  return live.createLiveTimelineTracker({clock:now,...live.defaultForegroundTimelineOptions({verbose:false})});
 }
 
-test('R155 ordinary remote has per-call START and DONE without opt-in flag',()=>{
+test('R176 default folds harmless status polling',()=>{
  const tracker=defaultTracker();
  const start=tracker.observe({event_type:'tool.request',request_id:'abc012345678',tool:'machine_status',args:{}},{sequence:1});
- assert.match(start,/Received tool call/);
- assert.match(start,/machine_status/);
+ assert.equal(start,null);
  const done=tracker.observe({event_type:'tool.result',request_id:'abc012345678',tool:'machine_status',outcome:{status:'ok',duration_ms:3}},{sequence:2});
- assert.match(done,/completed/);
- assert.match(done,/3ms/);
+ assert.equal(done,null);
+ assert.match(tracker.reconcileInterrupted().join('\n'),/machine_status.*×1/);
 });
 
-test('R155 ordinary remote does not fold successive status calls into a burst',()=>{
+test('R176 status bursts collapse without losing event totals',()=>{
  const tracker=defaultTracker();
  for(let n=0;n<3;n++){
   const id='repeat-'+n;
-  assert.match(tracker.observe({event_type:'tool.request',request_id:id,tool:'machine_ping',args:{}},{sequence:n*2+1}),/Received tool call/);
-  assert.match(tracker.observe({event_type:'tool.result',request_id:id,tool:'machine_ping',outcome:{status:'ok',duration_ms:1}},{sequence:n*2+2}),/completed/);
+  assert.equal(tracker.observe({event_type:'tool.request',request_id:id,tool:'machine_ping',args:{}},{sequence:n*2+1}),null);
+  assert.equal(tracker.observe({event_type:'tool.result',request_id:id,tool:'machine_ping',outcome:{status:'ok',duration_ms:1}},{sequence:n*2+2}),null);
  }
+ assert.match(tracker.reconcileInterrupted().join('\n'),/machine_ping.*×3/);
  assert.match(tracker.summary(),/3 calls \| 3 ok/);
- assert.doesNotMatch(tracker.summary(),/folded [1-9]/);
+ assert.match(tracker.summary(),/folded 2 heartbeat/);
 });
 
 test('R155 ordinary remote keeps credentials and payload opaque by default',()=>{
@@ -42,7 +42,7 @@ test('R155 ordinary remote keeps credentials and payload opaque by default',()=>
    command_id:'node_script',path:'C:\\Safe\\test.js',
    metadata:{token:'Bearer should-not-appear'}
  }},{sequence:1});
- assert.match(line,/Received tool call/);
+ assert.match(line,/START/);
  assert.match(line,/node_script/);
  assert.doesNotMatch(line,/sk-secret-test|PRIVATE SOURCE CONTENT|should-not-appear/);
 });
@@ -51,10 +51,10 @@ test('R155 ordinary remote prints DENIED and UNKNOWN as failures rather than com
  const tracker=defaultTracker();
  tracker.observe({event_type:'tool.request',request_id:'one',tool:'host_file_read',args:{path:'a.txt'}},{sequence:1});
  const fail=tracker.observe({event_type:'tool.result',request_id:'one',tool:'host_file_read',outcome:{status:'denied',is_error:true,reason:'arm file missing'}},{sequence:2});
- assert.match(fail,/failed/);assert.match(fail,/arm file missing/);
+ assert.match(fail,/DENIED/);assert.match(fail,/arm file missing/);
  tracker.observe({event_type:'tool.request',request_id:'two',tool:'coding_file_write',args:{path:'x.txt'}},{sequence:3});
  const unknown=tracker.observe({event_type:'tool.result',request_id:'two',tool:'coding_file_write',outcome:{status:'interrupted',side_effect_state:'unknown'}},{sequence:4});
- assert.match(unknown,/OUTCOME_UNKNOWN/);
+ assert.match(unknown,/UNKNOWN/);
 });
 
 test('R155 ordinary remote has no new CLI live-log mode and wired default live behavior',()=>{
@@ -66,16 +66,17 @@ test('R155 ordinary remote has no new CLI live-log mode and wired default live b
  assert.match(source,/defaultForegroundTimelineOptions\(\{verbose\}\)/);
 });
 
-test('R155 unchanged capability polling still has a matching visible DONE for every CALL',()=>{
+test('R176 same snapshot suppresses repeated capability messages',()=>{
  const tracker=defaultTracker();
  const snapshot='a'.repeat(64);
  for(let n=0;n<2;n++){
   const id='cap-'+n;
-  assert.match(tracker.observe({event_type:'tool.request',request_id:id,tool:'capability_manifest',args:{}},{sequence:n*2+1}),/Received tool call/);
+  assert.equal(tracker.observe({event_type:'tool.request',request_id:id,tool:'capability_manifest',args:{}},{sequence:n*2+1}),null);
   const done=tracker.observe({event_type:'tool.result',request_id:id,tool:'capability_manifest',outcome:{status:'ok',snapshot_id:snapshot,state_epoch:1,duration_ms:2}},{sequence:n*2+2});
-  assert.match(done,/completed/);
+  if(n===0) assert.match(done,/PASS/);
+  else assert.equal(done,null);
  }
- assert.match(tracker.summary(),/2 calls \\| 2 ok/);
+ assert.match(tracker.summary(),/2 calls \| 2 ok/);
 });
 
 test('R155 runtime-only stream reset does not claim audit corruption, audit reset remains severe',()=>{

package/test/r160-package-decision-manifest.test.mjs

@@ -59,7 +59,7 @@ test('R160 startup decision manifest rejects a newly required recovery module om
 test('R160 remote startup verifies decision bytes before evidence recovery and foreground claim',async()=>{
   const source=await readFile(new URL('../src/deadbyte-cli.mjs',import.meta.url),'utf8');
   const verifyAt=source.indexOf('await verifyPackageDecisionManifest({root:CURRENT_PACKAGE_ROOT,expectedVersion:DEADBYTE_VERSION})');
-  const recoverAt=source.indexOf('const migrationContext=await recoverRemoteSession(ctx,{displayMode})');
+  const recoverAt=source.indexOf('await recoverRemoteSession(ctx,{displayMode})');
   const claimAt=source.indexOf('marker=await claimRemoteSession(ctx)');
   assert.ok(verifyAt>0&&verifyAt<recoverAt&&recoverAt<claimAt,
     'package decision manifest must be verified before recovery and claim');

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

@@ -8,12 +8,11 @@ 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.61');
-  assert.equal(release.runtime_predecessor.release_id,'v0.15.61-055d1ff0aa99e60b');
-  assert.equal(release.runtime_predecessor.manifest_sha256,'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf');
-  assert.equal(release.runtime_predecessor.generation_manifest_sha256,'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4');
-  assert.equal(release.r160.source_predecessor_train,'R159');
+  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.r160.runtime_predecessor_version,'0.15.61');
+  assert.equal(release.r160.source_predecessor_train,'R159');
   assert.equal(release.r160.public_tool_delta,0);
   assert.equal(release.r160.authority_scope_delta,0);
   assert.equal(release.r160.production_activation,'NOT_RUN');

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

@@ -8,9 +8,10 @@ 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.68';
-const parent=path.join(os.homedir(),'.deadbyte-mcp','releases','v0.15.61-055d1ff0aa99e60b');
-const parentDigest='055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf';
+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');
 async function generation(state,label){
   const root=path.join(state,'generations',label);
@@ -21,17 +22,16 @@ 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('R173 isolated immutable slot activates, rolls back, and restores 0.15.68 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);
     const nextDigest=sha(nextManifest);
-    const parentSlot=await materializeReleaseSlot({source:parent,stateRoot:state,version:'0.15.61',manifestSha256:parentDigest});
+    const parentSlot=await materializeReleaseSlot({source:parent,stateRoot:state,version:'0.15.68',manifestSha256:parentDigest});
     const nextSlot=await materializeReleaseSlot({source:candidate,stateRoot:state,version,manifestSha256:nextDigest});
     const pGen=await generation(state,'r165-parent');
     const nGen=await generation(state,'r165-next');
@@ -43,7 +43,7 @@ test('R173 isolated immutable slot activates, rolls back, and restores 0.15.68 w
     const activated=await atomicWriteActivePointer(pointerPath,ptr(nextSlot,version,nGen));
     assert.equal(activated.release_id,nextSlot.release_id);
     await verifyManifestTreeExact(nextSlot.release_root,parseManifest(nextManifest.toString('utf8')));
-    const rolled=await atomicWriteActivePointer(pointerPath,ptr(parentSlot,'0.15.61',pGen));
+    const rolled=await atomicWriteActivePointer(pointerPath,ptr(parentSlot,'0.15.68',pGen));
     assert.equal(rolled.release_id,parentSlot.release_id);
     assert.equal(rolled.manifest_sha256,parentDigest);
     await verifyManifestTreeExact(parentSlot.release_root,parseManifest(parentManifest.toString('utf8')));

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.68');
+  assert.equal(JSON.parse(await readFile(path.join(envRoot,'package.json'),'utf8')).version,'0.15.70');
   const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r164-skew-e2e-'));
   t.after(async()=>{await rm(dir,{recursive:true,force:true,maxRetries:10,retryDelay:150});});
   const state=path.join(dir,'state'),bin=path.join(state,'bin');
@@ -65,26 +65,26 @@ async function run(fx){
  assert.doesNotMatch(trace,/\b(?:start|restart|armprocess|armcoding|armautonomous|deploy)\b/i,'unexpected runtime operation');
  return {output:(result.stderr||'')+'\n'+(result.stdout||''),trace};
 }
-gate('R168 executable CLI blocks npm-cache activation on version skew before touching R159 history',async t=>{
+gate('R175 executable CLI blocks foreground observation on version skew before touching history',async t=>{
  const fx=await fixture(t,'completed');
  const r=await run(fx);
- assert.match(r.output,/R168 version skew.*0\.15\.61.*0\.15\.68/i,r.output);
+ assert.match(r.output,/R175_EXACT_ACTIVE_RELEASE_REQUIRED/i,r.output);
  assert.doesNotMatch(r.output,/R159 ambiguous multiple completed/i);
  assert.equal(r.trace,'');
  assert.doesNotMatch(r.trace,/disarmdesktop/);
 });
 gate('R165 executable CLI rejects pending current reconciliation before upgrade',async t=>{
  const fx=await fixture(t,'pending'),r=await run(fx);
- assert.match(r.output,/R168 version skew/i,r.output);
+ assert.match(r.output,/R175_EXACT_ACTIVE_RELEASE_REQUIRED/i,r.output);
  assert.doesNotMatch(r.trace,/disarmhost/);
 });
 gate('R165 executable CLI rejects tampered terminal before upgrade',async t=>{
  const fx=await fixture(t,'tampered'),r=await run(fx);
- assert.match(r.output,/R168 version skew/i,r.output);
+ assert.match(r.output,/R175_EXACT_ACTIVE_RELEASE_REQUIRED/i,r.output);
  assert.doesNotMatch(r.trace,/disarmhost/);
 });
 gate('R165 executable CLI keeps ambiguous history fail-closed when predecessor is not ONLINE',async t=>{
  const fx=await fixture(t,'offline'),r=await run(fx);
- assert.match(r.output,/R168 version skew/i,r.output);
+ assert.match(r.output,/R175_EXACT_ACTIVE_RELEASE_REQUIRED/i,r.output);
  assert.doesNotMatch(r.trace,/disarmhost/);
 });

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

@@ -8,11 +8,11 @@ import {DEADBYTE_VERSION} from '../src/version.mjs';
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
 const readOptional=async rel=>{try{return await read(rel);}catch(error){if(error?.code==='ENOENT')return null;throw error;}};
-const VERSION='0.15.68';
+const VERSION='0.15.70';
 const R166_MANIFEST='ad3c091fbbe2bac6d234548724008b67305fd483ad6542f92d5aeb1aa84f5849';
 const R166_TARBALL='3d22412c3cebabd66bfa92ca4dbaaf3ef49acba7f92436a16485d7e4cb18c653';
 
-test('R173 package identity binds published R172 source separately from active R153 runtime',async()=>{
+test('current package identity retains the immutable R167/R173 activation lineage',async()=>{
   const [pkg,lock,bridge,release,provenance,matrix,bom]=await Promise.all([
     read('package.json'),readOptional('package-lock.json'),read('bridge/package.json'),read('RELEASE.json'),
     read('PROVENANCE.json'),read('TEST-MATRIX.json'),read('SBOM.cdx.json')]);
@@ -20,19 +20,21 @@ test('R173 package identity binds published R172 source separately from active R
     provenance.version,matrix.version,bom.metadata.component.version,DEADBYTE_VERSION];
   if(lock)versions.push(lock.version,lock.packages[''].version);
   for(const version of versions)assert.equal(version,VERSION);
-  assert.equal(release.train,'R173');
-  assert.equal(matrix.train,'R173');
-  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r173:0.15.68');
+  assert.equal(release.train,'R190');
+  assert.equal(matrix.train,'R190');
+  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r190:0.15.70');
   assert.deepEqual(release.runtime_predecessor,{
-    version:'0.15.61',release_id:'v0.15.61-055d1ff0aa99e60b',
-    manifest_sha256:'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf',
-    generation_manifest_sha256:'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4'
+    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.67');
-  assert.equal(release.source_predecessor.train,'R172');
-  assert.equal(release.source_predecessor.tarball_sha256,'0fe761f035f38730a4717448da4217f55464c38cd1616126b5850ff44411cd6d');
+  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.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,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'cfede112761da00e73b626cfbce23d17e1d4b6e3a325bb675415196d31142ba0');
+  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');
   assert.equal(release.r167.public_tool_delta,0);
@@ -41,7 +43,7 @@ test('R173 package identity binds published R172 source separately from active R
   assert.equal(release.r167.npm_publish,'NOT_RUN');
 });
 
-test('R167 protected continuity remains pending until exact Windows fixture evidence exists',async()=>{
+test('R167 historical protected continuity remains recorded without overriding current release truth',async()=>{
   const [release,provenance,matrix]=await Promise.all([
     read('RELEASE.json'),read('PROVENANCE.json'),read('TEST-MATRIX.json')]);
   assert.equal(release.r167.protected_entrypoint_continuity,'PENDING_PROTECTED_WINDOWS_FIXTURE');

package/test/r168-protected-entrypoint.test.mjs

@@ -10,13 +10,16 @@ const script=path.join(root,'scripts','r173-protected-preflight.mjs');
 const protectedRoot='C:\\Program Files';
 const relative=path.win32.relative(protectedRoot,root);
 const isProtected=process.platform==='win32'&&relative!==''&&relative!=='..'&&!relative.startsWith('..'+path.win32.sep)&&!path.win32.isAbsolute(relative);
+const packageIdentity=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));
+const releaseIdentity=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+const isR173Identity=packageIdentity.version==='0.15.68'&&releaseIdentity.version==='0.15.68'&&releaseIdentity.train==='R173';
 function launch(file,...args){return spawnSync(process.execPath,[file,...args],{
   encoding:'utf8',windowsHide:true,shell:false,timeout:15000,maxBuffer:65536
 });}
 
 test('R173 installed preflight respects R89 protected-vs-writable execution context',()=>{
   const result=launch(script);
-  if(isProtected){
+  if(isProtected&&isR173Identity){
     assert.equal(result.status,0,result.stderr);
     assert.match(result.stdout,/R173_PROTECTED_PREFLIGHT_READONLY_PASS/);
     assert.match(result.stdout,/"terminalization_authorized":false/);
@@ -24,7 +27,7 @@ test('R173 installed preflight respects R89 protected-vs-writable execution cont
   }else{
     assert.notEqual(result.status,0);
     assert.match(result.stderr,/R173_PROTECTED_PREFLIGHT=BLOCKED/);
-    assert.match(result.stderr,/R173_.*_(UNPROTECTED|VERSION_DRIFT)/);
+    assert.match(result.stderr,isProtected?/R173_VERSION_DRIFT/:/R173_.*_UNPROTECTED/);
   }
 });
 

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

@@ -13,9 +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.61');
- assert.equal(release.runtime_predecessor.release_id,parent);
- assert.equal(release.parent.release_id,parent);
+ assert.equal(release.runtime_predecessor.version,'0.15.68');
+ assert.equal(release.parent.version,'0.15.68');
+ 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');
  assert.equal(release.r168.source_predecessor_version,'0.15.65');
  assert.equal(release.r168.source_predecessor_manifest_sha256,predecessorManifest);

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

@@ -60,7 +60,8 @@ test('R168 foreground remote refuses npm-cache version skew before session marke
   const source=cli.slice(start,end);
   assert.match(source,/selectR168OneShotRemotePath/);
   const safety=source.indexOf('selectR168OneShotRemotePath');
-  for(const operation of ['recoverRemoteSession(ctx','acquireForegroundSessionLock({root','synchronizeForegroundRuntime(ctx']){
+  for(const operation of ['recoverRemoteSession(ctx','acquireForegroundSessionLock({root','readRemoteSessionMarker(ctx.root)','claimRemoteSession(ctx)']){
     assert.ok(safety<source.indexOf(operation),'version guard must precede '+operation);
   }
+  assert.doesNotMatch(source,/synchronizeForegroundRuntime\(/,'R175 foreground must remain observation-only');
 });

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

@@ -9,19 +9,19 @@ 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('R173 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.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.manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
-  assert.equal(release.source_predecessor.tarball_sha256,'0fe761f035f38730a4717448da4217f55464c38cd1616126b5850ff44411cd6d');
-  assert.equal(release.runtime_predecessor.release_id,'v0.15.61-055d1ff0aa99e60b');
+  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');
   assert.equal(release.r173.public_tool_delta,0); assert.equal(release.r173.authority_scope_delta,0);
 });
 

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

@@ -3,30 +3,31 @@ import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
+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('R173 package identity binds the exact published R172 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'),json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
+    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.68');
-  assert.equal(lock.version,'0.15.68');
-  assert.equal(lock.packages[''].version,'0.15.68');
-  assert.equal(bridge.version,'0.15.68');
-  assert.equal(release.version,'0.15.68');
-  assert.equal(release.train,'R173');
-  assert.equal(matrix.version,'0.15.68');
-  assert.equal(matrix.train,'R173');
-  assert.equal(sbom.metadata.component.version,'0.15.68');
-  assert.equal(release.source_predecessor.version,'0.15.67');
-  assert.equal(release.source_predecessor.train,'R172');
-  assert.equal(release.source_predecessor.manifest_sha256,'4fd7bfc76b1de6401c142b607cc84e847434b28c888bc99ceb09c9e8e5adc8f8');
-  assert.equal(release.source_predecessor.tarball_sha256,'0fe761f035f38730a4717448da4217f55464c38cd1616126b5850ff44411cd6d');
-  assert.equal(release.runtime_predecessor.version,'0.15.61');
-  assert.equal(provenance.version,'0.15.68');
+  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(provenance.parent_tarball_sha256,release.source_predecessor.tarball_sha256);
   assert.equal(provenance.source_predecessor_manifest_file_sha256,release.source_predecessor.manifest_sha256);
 });

package/test/r174-owner-webauthn.test.mjs

@@ -0,0 +1,144 @@
+import test from 'node:test';
+import {mkdtemp,readdir,readFile,rm,symlink} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync,randomBytes,sign} from 'node:crypto';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {verifyR174OwnerAssertion,acceptR174OwnerProof} from '../src/r174-owner-webauthn.mjs';
+const sha=b=>createHash('sha256').update(b).digest();
+const hex=b=>sha(b).toString('hex');
+const b64=b=>Buffer.from(b).toString('base64url');
+function fixture(){
+  const pair=generateKeyPairSync('ec',{namedCurve:'prime256v1'});
+  const credential={schema:'deadbyte.r174-owner-credential.v1',
+    credential_id_b64url:b64(randomBytes(32)),rp_id:'owner.deadbyte.local',
+    origin:'https://owner.deadbyte.local',
+    public_key_spki_pem:pair.publicKey.export({type:'spki',format:'pem'}),
+    algorithm:'ES256',sign_count:4};
+  const subject={schema:'deadbyte.r174-autonomous-owner-subject.v1',
+    release_manifest_sha256:'a'.repeat(64),coding_policy_sha256:'b'.repeat(64),
+    autonomous_policy_sha256:'c'.repeat(64),root_id:'core',
+    project_root:'D:\\Projects\\deadbyte-mcp',effect:'autonomous_goal_run',max_seconds:3600};
+  const transaction={schema:'deadbyte.r174-owner-challenge.v1',
+    challenge_b64url:b64(randomBytes(32)),subject_sha256:hex(Buffer.from(canonicalJson(subject))),
+    issued_at_utc:'2026-10-27T06:59:00.000Z',expires_at_utc:'2026-10-27T07:04:00.000Z'};
+  const clientData=Buffer.from(JSON.stringify({type:'webauthn.get',challenge:transaction.challenge_b64url,origin:credential.origin,crossOrigin:false}));
+  const authData=Buffer.alloc(37);
+  sha(Buffer.from(credential.rp_id)).copy(authData);
+  authData[32]=5;authData.writeUInt32BE(5,33);
+  const assertion={credential_id_b64url:credential.credential_id_b64url,
+    client_data_json_b64url:b64(clientData),authenticator_data_b64url:b64(authData),
+    signature_b64url:b64(sign('sha256',Buffer.concat([authData,sha(clientData)]),pair.privateKey))};
+  const ownerTrust={schema:'deadbyte.r174-owner-trust-binding.v1',
+    credential_id_b64url:credential.credential_id_b64url,
+    public_key_spki_sha256:hex(pair.publicKey.export({type:'spki',format:'der'})),
+    rp_id:credential.rp_id,origin:credential.origin,
+    subject_sha256:transaction.subject_sha256};
+  return {credential,subject,transaction,assertion,ownerTrust,now:new Date('2026-10-27T07:00:00.000Z'),privateKey:pair.privateKey,clientData,authData};
+}
+function reSign(f){
+ f.assertion.client_data_json_b64url=b64(f.clientData);
+ f.assertion.authenticator_data_b64url=b64(f.authData);
+ f.assertion.signature_b64url=b64(sign('sha256',Buffer.concat([f.authData,sha(f.clientData)]),f.privateKey));
+}
+test('R174 verifies ES256 authenticator signature and owner UV with bound challenge',async()=>{
+ const f=fixture();const r=await verifyR174OwnerAssertion(f);
+ assert.equal(r.status,'verified');assert.equal(r.sign_count,5);
+ assert.equal(r.subject_sha256,f.transaction.subject_sha256);assert.equal(r.user_verified,true);
+});
+test('R174 refuses invalid signature and UV=false even when resigned',async()=>{
+ const f=fixture();f.assertion.signature_b64url=b64(randomBytes(70));
+ await assert.rejects(verifyR174OwnerAssertion(f),/signature/i);
+ const g=fixture();g.authData[32]=1;reSign(g);
+ await assert.rejects(verifyR174OwnerAssertion(g),/user verification/i);
+});
+test('R174 refuses RP ID, origin, credential ID, and signature counter drift',async()=>{
+ const f=fixture();f.credential.rp_id='evil.example';
+ await assert.rejects(verifyR174OwnerAssertion(f),/rp id/i);
+ const g=fixture();g.credential.origin='https://evil.example';
+ await assert.rejects(verifyR174OwnerAssertion(g),/origin/i);
+ const h=fixture();h.credential.credential_id_b64url=b64(randomBytes(32));
+ await assert.rejects(verifyR174OwnerAssertion(h),/credential id/i);
+ const j=fixture();j.credential.sign_count=5;
+ await assert.rejects(verifyR174OwnerAssertion(j),/sign counter/i);
+});
+test('R174 refuses signed wrong challenge, cross origin, expired transaction',async()=>{
+ const f=fixture();f.clientData=Buffer.from(JSON.stringify({type:'webauthn.get',challenge:b64(randomBytes(32)),origin:f.credential.origin}));reSign(f);
+ await assert.rejects(verifyR174OwnerAssertion(f),/challenge/i);
+ const g=fixture();g.clientData=Buffer.from(JSON.stringify({type:'webauthn.get',challenge:g.transaction.challenge_b64url,origin:g.credential.origin,crossOrigin:true}));reSign(g);
+ await assert.rejects(verifyR174OwnerAssertion(g),/cross.origin/i);
+ const h=fixture();h.now=new Date('2026-10-27T07:05:00.000Z');
+ await assert.rejects(verifyR174OwnerAssertion(h),/expired/i);
+});
+test('R174 refuses policy-bound subject drift and overlong approval',async()=>{
+ const f=fixture();f.subject.root_id='projects';
+ await assert.rejects(verifyR174OwnerAssertion(f),/subject/i);
+ const g=fixture();g.transaction.expires_at_utc='2026-10-27T09:04:00.000Z';
+ await assert.rejects(verifyR174OwnerAssertion(g),/lifetime/i);
+});
+async function withLedger(work){
+  const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r174-owner-ledger-'));
+  try{return await work(dir);}finally{await rm(dir,{recursive:true,force:true});}
+}
+test('R174 consumes verified assertion once with append-only JSON receipt and no authority grant',()=>withLedger(async ledgerRoot=>{
+  const result=await acceptR174OwnerProof({...fixture(),ledgerRoot});
+  assert.equal(result.status,'consumed');
+  assert.equal(result.authority_granted,false);
+  const files=await readdir(ledgerRoot);
+  assert.equal(files.length,1);
+  const receipt=JSON.parse(await readFile(path.join(ledgerRoot,files[0]),'utf8'));
+  assert.equal(receipt.schema,'deadbyte.r174-consumed-owner-challenge.v1');
+  assert.equal(receipt.subject_sha256,result.subject_sha256);
+  assert.equal(receipt.authority_granted,false);
+}));
+test('R174 rejects repeated or concurrent presentation of the same signed challenge',()=>withLedger(async ledgerRoot=>{
+  const f=fixture();const once=await acceptR174OwnerProof({...f,ledgerRoot});
+  assert.equal(once.status,'consumed');
+  await assert.rejects(acceptR174OwnerProof({...f,ledgerRoot}),/replay/i);
+  const another=fixture();
+  const results=await Promise.allSettled([
+    acceptR174OwnerProof({...another,ledgerRoot}),
+    acceptR174OwnerProof({...another,ledgerRoot})
+  ]);
+  assert.deepEqual(results.map(x=>x.status).sort(),['fulfilled','rejected']);
+  assert.equal((await readdir(ledgerRoot)).length,2);
+}));
+test('R174 invalid assertion never consumes challenge',()=>withLedger(async ledgerRoot=>{
+  const f=fixture();f.assertion.signature_b64url=b64(randomBytes(70));
+  await assert.rejects(acceptR174OwnerProof({...f,ledgerRoot}),/signature/i);
+  assert.equal((await readdir(ledgerRoot)).length,0);
+}));
+test('R174 same challenge cannot be reused with a different credential',()=>withLedger(async ledgerRoot=>{
+ const f=fixture();
+ const g=fixture();
+ g.transaction.challenge_b64url=f.transaction.challenge_b64url;
+ g.clientData=Buffer.from(JSON.stringify({type:'webauthn.get',challenge:g.transaction.challenge_b64url,origin:g.credential.origin,crossOrigin:false}));
+ reSign(g);
+ assert.equal((await acceptR174OwnerProof({...f,ledgerRoot})).status,'consumed');
+ await assert.rejects(acceptR174OwnerProof({...g,ledgerRoot}),/replay/i);
+}));
+test('R174 rejects counter downgrade from nonzero previous to zero',async()=>{
+ const f=fixture();f.authData.writeUInt32BE(0,33);reSign(f);
+ await assert.rejects(verifyR174OwnerAssertion(f),/sign counter/i);
+});
+test('R174 refuses consumption when independently pinned owner trust is missing',()=>withLedger(async ledgerRoot=>{
+ const f=fixture();delete f.ownerTrust;
+ await assert.rejects(acceptR174OwnerProof({...f,ledgerRoot}),/owner trust/i);
+ assert.equal((await readdir(ledgerRoot)).length,0);
+}));
+test('R174 refuses self-signed substitute owner credential against pinned trust',()=>withLedger(async ledgerRoot=>{
+ const known=fixture(),impostor=fixture();
+ impostor.ownerTrust=known.ownerTrust;
+ await assert.rejects(acceptR174OwnerProof({...impostor,ledgerRoot}),/owner trust|credential|public key/i);
+ assert.equal((await readdir(ledgerRoot)).length,0);
+}));
+test('R174 refuses legitimate key if expected reviewed subject changed',()=>withLedger(async ledgerRoot=>{
+ const f=fixture();
+ f.subject.max_seconds=100;
+ f.transaction.subject_sha256=hex(Buffer.from(canonicalJson(f.subject)));
+ await assert.rejects(acceptR174OwnerProof({...f,ledgerRoot}),/owner trust|subject/i);
+ assert.equal((await readdir(ledgerRoot)).length,0);
+}));
+
+

package/test/r175-cli-flags.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,readdir,rm} from 'node:fs/promises';
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import os from 'node:os';
+import path from 'node:path';
+
+const cli=fileURLToPath(new URL('../src/deadbyte-cli.mjs',import.meta.url));
+for(const mode of ['--operator','--desktop','--host','--full']){
+ test('R175 '+mode+' refuses implicit session-owned grant escalation before runtime state access',async()=>{
+  const state=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r175-flags-'));
+  try{
+   const child=spawnSync(process.execPath,[cli,'remote',mode],{
+    encoding:'utf8',windowsHide:true,timeout:15000,env:{...process.env,DEADBYTE_STATE_ROOT:state}
+   });
+   assert.equal(child.error,undefined,String(child.error));
+   assert.notEqual(child.status,0);
+   assert.match(child.stderr,/R175_FOREGROUND_OWNER_BOUNDARY/);
+   assert.deepEqual(await readdir(state),[],'failed flag must not create an authority marker or any state');
+  }finally{await rm(state,{recursive:true,force:true});}
+ });
+}