deadbyte-mcp 0.15.64 → 0.15.66

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

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {DEADBYTE_VERSION} from '../src/version.mjs';
+
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const read=async rel=>JSON.parse(await readFile(path.join(root,rel),'utf8'));
+const readOptional=async rel=>{try{return await read(rel);}catch(error){if(error?.code==='ENOENT')return null;throw error;}};
+const VERSION='0.15.66';
+const R166_MANIFEST='ad3c091fbbe2bac6d234548724008b67305fd483ad6542f92d5aeb1aa84f5849';
+const R166_TARBALL='3d22412c3cebabd66bfa92ca4dbaaf3ef49acba7f92436a16485d7e4cb18c653';
+
+test('R168 package identity binds published R167 source separately from active R153 runtime',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 version of versions)assert.equal(version,VERSION);
+  assert.equal(release.train,'R168');
+  assert.equal(matrix.train,'R168');
+  assert.equal(bom.serialNumber,'urn:cdx:deadbyte-mcp:r168:0.15.66');
+  assert.deepEqual(release.runtime_predecessor,{
+    version:'0.15.61',release_id:'v0.15.61-055d1ff0aa99e60b',
+    manifest_sha256:'055d1ff0aa99e60bbf9e9f136b02ebd4fffb8391712560f7607cff30af94dcdf',
+    generation_manifest_sha256:'f940e794daac2dda097a66301c4b85c4b29a2df7c669e549503c05a2a55ff6c4'
+  });
+  assert.equal(release.source_predecessor.version,'0.15.65');
+  assert.equal(release.source_predecessor.train,'R167');
+  assert.equal(release.source_predecessor.tarball_sha256,'fc3ae5b1505e316bc9dfedf8d063cb00641754c8f5f1306a31f8cc4bb84c9484');
+  assert.equal(release.r167.source_predecessor_manifest_sha256,R166_MANIFEST);
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,'3316654646cc870584a7c969c2032af6c795229ff8c65e5a8b794f97c2458c41');
+  assert.equal(provenance.source_predecessor_tarball_sha256,'fc3ae5b1505e316bc9dfedf8d063cb00641754c8f5f1306a31f8cc4bb84c9484');
+  assert.equal(release.r167.public_tool_delta,0);
+  assert.equal(release.r167.authority_scope_delta,0);
+  assert.equal(release.r167.production_activation,'NOT_RUN');
+  assert.equal(release.r167.npm_publish,'NOT_RUN');
+});
+
+test('R167 protected continuity remains pending until exact Windows fixture evidence exists',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');
+  assert.equal(provenance.r167.final_manifest_evidence,'PENDING_PROTECTED_WINDOWS_FIXTURE');
+  assert.equal(matrix.r167.protected_epoch_continuity,'PENDING_PROTECTED_WINDOWS_FIXTURE');
+  assert.equal(matrix.r167.new_public_tools,0);
+  assert.equal(matrix.r167.new_authority_scopes,0);
+});

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

@@ -0,0 +1,27 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {readFile} from 'node:fs/promises';
+import {assertR167NpmPublishReady,assertR167PackedIdentity} from '../scripts/npm-release-readiness-r167.mjs';
+
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+
+test('R167 publication refuses absent external exact-byte closure',async()=>{
+  const release=JSON.parse(await readFile(path.join(root,'RELEASE.json'),'utf8'));
+  const prior=process.env.DEADBYTE_R167_CLOSURE_ROOT;
+  try{
+    delete process.env.DEADBYTE_R167_CLOSURE_ROOT;
+    await assert.rejects(assertR167NpmPublishReady(release,{root}),/PUBLISH_BLOCKED R167/);
+  }finally{
+    if(prior===undefined)delete process.env.DEADBYTE_R167_CLOSURE_ROOT;
+    else process.env.DEADBYTE_R167_CLOSURE_ROOT=prior;
+  }
+});
+
+test('R167 publication rejects a repacked artifact that differs from verified closure bytes',()=>{
+  const expected={tarball_sha256:'a'.repeat(64),tarball_integrity:'sha512-expected',tarball_shasum:'b'.repeat(40)};
+  assert.throws(()=>assertR167PackedIdentity({
+    ...expected,observedSha256:'c'.repeat(64),observedIntegrity:'sha512-other',observedShasum:'d'.repeat(40)
+  }),/PUBLISH_BLOCKED R167.*tarball/i);
+});

package/test/r168-combined-targeted-runner.mjs

@@ -0,0 +1,14 @@
+// R168 targeted test entrypoint. Does not invoke production authority.
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+
+const dir=path.dirname(fileURLToPath(import.meta.url));
+const cases=['r168-five-plane-fence.test.mjs','r168-focused-suite.test.mjs','r168-crash-journal.test.mjs','r168-protected-entrypoint.test.mjs','r168-remote-one-shot-coherence.test.mjs'];
+const result=spawnSync(process.execPath,['--test','--test-concurrency=1',...cases.map(x=>path.join(dir,x))],{
+  cwd:dir,encoding:'utf8',shell:false,windowsHide:true,timeout:120000,maxBuffer:3*1024*1024
+});
+if(result.stdout)process.stdout.write(result.stdout);
+if(result.stderr)process.stderr.write(result.stderr);
+if(result.error)throw result.error;
+process.exitCode=result.status??1;

package/test/r168-crash-journal.test.mjs

@@ -0,0 +1,149 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import {mkdtemp,mkdir,lstat,readFile,rm,readdir,writeFile} from 'node:fs/promises';
+import {pathToFileURL} from 'node:url';
+import {simulateR168FivePlaneEpochFence} from '../src/activation-reconciliation-fence-r168.mjs';
+import {queryForegroundIdentity} from '../src/foreground-process-identity.mjs';
+import {readPinnedEpochLockSnapshot,deletePinnedRemoteMarker} from '../src/foreground-marker-cas-win32.mjs';
+import {createHash,generateKeyPairSync,sign} from 'node:crypto';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {createR168ReconciliationSubject,createR168SignedAuthorization,makeR168ConsentChallenge} from '../src/activation-reconciliation-consent-r168.mjs';
+import {createR168TerminalResult} from '../src/activation-reconciliation-terminal-r168.mjs';
+import {prepareR168TerminalIntent,classifyR168Recovery} from '../src/activation-reconciliation-journal-r168.mjs';
+
+const digest=o=>createHash('sha256').update(typeof o==='string'?o:canonicalJson(o)).digest('hex');
+const OWNER=generateKeyPairSync('ed25519'),MACHINE=generateKeyPairSync('ed25519');
+const now='2026-10-26T08:00:00.000Z',later='2026-10-27T08:00:00.000Z';
+function fixture({fileId='1234567890abcdef:1234567890abcdef1234567890abcdef'}={}){
+  const planes=['process','coding','autonomous','desktop','host'];
+  const counts=[27,29,24,28,26];
+  const history=Object.fromEntries(planes.map((p,i)=>[p,{status:'PASS',verified_events:counts[i],event_sha256:digest(p),head_action:p==='coding'?'grant':'user_revoke'}]));
+  const obs={schema:'deadbyte.r168-readonly-reconciliation-observation.v1',
+    status:'NO_MATCHING_TRANSACTION_OBSERVED',terminalization_authorized:false,
+    old_operation_id:'c84d7ffa4eee80a2f467acda3ddd9332',
+    old_continuity_update_id:'r65-ef42bc84451ce024c4dee736d4047b36',
+    old_claim_sha256:digest('claim'),old_outcome_sha256:digest('outcome'),predecessor_pointer_sha256:digest('pointer'),
+    coding_policy_sha256:digest('policy'),coding_grant_sha256:digest('grant'),
+    coding_epoch_sha256:history.coding.event_sha256,candidate_manifest_sha256:digest('candidate'),
+    epoch_history:history,signed_event_count:134,update_inventory_count:376};
+  const observation={...obs,observation_sha256:digest(obs)};
+  const subject=createR168ReconciliationSubject({observation,
+    claimSnapshot:{sha256:obs.old_claim_sha256,fileId},
+    stateRoot:'C:\\Users\\DEADBYTE\\.deadbyte-mcp'});
+  const body={schema:'deadbyte.r168-owner-approval.v1',action:'terminalize_unknown_without_replay',
+    subject_sha256:subject.subject_sha256,claim_operation_id:subject.claim_operation_id,
+    nonce:digest('nonce'),issued_at_utc:'2026-10-26T07:59:00.000Z',expires_at_utc:'2026-10-26T08:04:00.000Z'};
+  const signature=sign(null,Buffer.concat([Buffer.from('DEADBYTE-R168-OWNER-APPROVAL-V1\0'),Buffer.from(canonicalJson(body))]),OWNER.privateKey);
+  const approval={body,attestation:{algorithm:'ed25519',domain:'DEADBYTE-R168-OWNER-APPROVAL-V1',signature_base64:signature.toString('base64')}};
+  const prepared=createR168SignedAuthorization({subject,approval,ownerPublicKey:OWNER.publicKey,
+    machinePrivateKey:MACHINE.privateKey,now,typedConfirmation:makeR168ConsentChallenge(subject)});
+  const common={subject,approval,prepared,ownerPublicKey:OWNER.publicKey,machinePublicKey:MACHINE.publicKey};
+  return common;
+}
+async function isolated(fn){
+ const dir=await mkdtemp(path.join(os.tmpdir(),'r168-crash-journal-'));
+ try{return await fn(dir);}finally{await rm(dir,{recursive:true,force:true});}
+}
+test('R168 terminal intent is exclusive, durable-readback, and cannot be reused or overwritten',()=>isolated(async dir=>{
+ const common=fixture();
+ const result=await prepareR168TerminalIntent({evidenceDir:dir,...common,now});
+ assert.match(result.sha256,/^[0-9a-f]{64}$/);
+ const parsed=JSON.parse(await readFile(result.file,'utf8'));
+ assert.equal(parsed.body.phase,'INTENT_PREPARED_ONLY');
+ assert.equal(parsed.body.terminalization_committed,false);
+ assert.equal(parsed.body.activation_authorized,false);
+ assert.equal(parsed.body.claim_file_id,common.subject.claim_file_id);
+ await assert.rejects(prepareR168TerminalIntent({evidenceDir:dir,...common,now}),/exists|one-use|clobber/i);
+ assert.equal((await readdir(dir)).length,1);
+}));
+test('R168 interrupted operation with original claim still present remains blocked and does not replay CAS',()=>isolated(async dir=>{
+ const common=fixture();
+ const record=await prepareR168TerminalIntent({evidenceDir:dir,...common,now});
+ const observedClaim={state:'PRESENT',fileId:common.subject.claim_file_id,sha256:common.subject.claim_file_sha256};
+ const status=await classifyR168Recovery({...common,recordFile:record.file,observedClaim,now:later});
+ assert.equal(status.state,'PRECOMMIT_CLAIM_PRESENT_BLOCKED');
+ assert.equal(status.activation_authorized,false);
+ assert.equal(status.terminalization_committed,false);
+}));
+test('R168 interrupted operation with missing claim but absent terminal proof stays unknown and blocked',()=>isolated(async dir=>{
+ const common=fixture();
+ const record=await prepareR168TerminalIntent({evidenceDir:dir,...common,now});
+ const status=await classifyR168Recovery({...common,recordFile:record.file,observedClaim:{state:'ABSENT'},now:later});
+ assert.equal(status.state,'CAS_OUTCOME_UNKNOWN_BLOCKED');
+ assert.equal(status.activation_authorized,false);
+}));
+test('R168 claim replacement or tampered journal is never treated as successful reconciliation',()=>isolated(async dir=>{
+ const common=fixture(),record=await prepareR168TerminalIntent({evidenceDir:dir,...common,now});
+ const status=await classifyR168Recovery({...common,recordFile:record.file,
+   observedClaim:{state:'PRESENT',fileId:common.subject.claim_file_id,sha256:digest('new-claim')},now:later});
+ assert.equal(status.state,'CLAIM_CHANGED_BLOCKED');
+ const parsed=JSON.parse(await readFile(record.file,'utf8'));
+ parsed.body.activation_authorized=true;
+ await writeFile(record.file,JSON.stringify(parsed)+'\n');
+ await assert.rejects(classifyR168Recovery({...common,recordFile:record.file,
+   observedClaim:{state:'ABSENT'},now:later}),/journal|digest|tamper/i);
+}));
+test('R168 verified terminal result can be archived after owner approval expiry but never auto-activates',()=>isolated(async dir=>{
+ const common=fixture(),record=await prepareR168TerminalIntent({evidenceDir:dir,...common,now});
+ const after={native_cas_result:'REMOVED',claim_absent:true,
+   pointer_sha256:common.subject.predecessor_pointer_sha256,old_outcome_sha256:common.subject.old_outcome_sha256,
+   coding_policy_sha256:common.subject.coding_policy_sha256,coding_grant_sha256:common.subject.coding_grant_sha256,
+   coding_epoch_sha256:common.subject.coding_epoch_sha256,epoch_history:common.subject.epoch_history};
+ const terminal=createR168TerminalResult({...common,machinePrivateKey:MACHINE.privateKey,after,now});
+ const status=await classifyR168Recovery({...common,recordFile:record.file,
+   observedClaim:{state:'ABSENT'},terminal,after,now:later});
+ assert.equal(status.state,'TERMINAL_VERIFIED_ACTIVATION_SEPARATE');
+ assert.equal(status.terminalization_committed,true);
+ assert.equal(status.activation_authorized,false);
+ await assert.rejects(classifyR168Recovery({...common,recordFile:record.file,
+   observedClaim:{state:'PRESENT',fileId:common.subject.claim_file_id,sha256:common.subject.claim_file_sha256},
+   terminal,after,now:later}),/terminal|claim|ambiguous/i);
+}));
+
+test('R168 real R85 five-plane scratch fence + journal + FileId-bound native CAS + terminal proof',()=>isolated(async root=>{
+ if(process.platform!=='win32')return;
+ const protectedRoot='C:\\Program Files\\DEADBYTE-R167-Protected-0.15.65-3316654646cc8705-Fix6';
+ const originalManifest=await readFile(path.join(protectedRoot,'MANIFEST.SHA256'));
+ assert.equal(createHash('sha256').update(originalManifest).digest('hex'),'3316654646cc870584a7c969c2032af6c795229ff8c65e5a8b794f97c2458c41');
+ const {acquireHeldEpochLock}=await import(pathToFileURL(path.join(protectedRoot,'src','epoch-lock-r85.mjs')).href);
+ const planes=['process','coding','autonomous','desktop','host'];
+ for(const plane of planes)await mkdir(path.join(root,'runtime','authority-epochs',plane),{recursive:true});
+ const evid=path.join(root,'evidence');await mkdir(evid);
+ const claimPath=path.join(root,'r65-activation.lock');
+ await writeFile(claimPath,'claim');
+ const observed=readPinnedEpochLockSnapshot(claimPath);
+ assert.equal(observed.sha256,digest('claim'));
+ const common=fixture({fileId:observed.fileId});
+ const after={native_cas_result:'REMOVED',claim_absent:true,
+   pointer_sha256:common.subject.predecessor_pointer_sha256,old_outcome_sha256:common.subject.old_outcome_sha256,
+   coding_policy_sha256:common.subject.coding_policy_sha256,coding_grant_sha256:common.subject.coding_grant_sha256,
+   coding_epoch_sha256:common.subject.coding_epoch_sha256,epoch_history:common.subject.epoch_history};
+ const result=await simulateR168FivePlaneEpochFence({stateRoot:root,
+   testOwnerIdentity:queryForegroundIdentity(process.pid),testAcquire:acquireHeldEpochLock,
+   onHeld:async({assertHeld})=>{
+     assert.equal(assertHeld(),true);
+     const before=readPinnedEpochLockSnapshot(claimPath);
+     assert.equal(before.fileId,common.subject.claim_file_id);
+     const intent=await prepareR168TerminalIntent({evidenceDir:evid,...common,now});
+     const receiptBefore=await classifyR168Recovery({...common,recordFile:intent.file,
+       observedClaim:{state:'PRESENT',fileId:before.fileId,sha256:before.sha256},now:later});
+     assert.equal(receiptBefore.state,'PRECOMMIT_CLAIM_PRESENT_BLOCKED');
+     const status=deletePinnedRemoteMarker(claimPath,before.sha256,{expectedFileId:before.fileId});
+     assert.equal(status,'REMOVED');
+     assert.equal(readPinnedEpochLockSnapshot(claimPath),null);
+     const terminal=createR168TerminalResult({...common,machinePrivateKey:MACHINE.privateKey,after,now});
+     const final=await classifyR168Recovery({...common,recordFile:intent.file,
+       observedClaim:{state:'ABSENT'},terminal,after,now:later});
+     assert.equal(final.state,'TERMINAL_VERIFIED_ACTIVATION_SEPARATE');
+     assert.equal(final.activation_authorized,false);
+     return final.state;
+   }});
+ assert.equal(result,'TERMINAL_VERIFIED_ACTIVATION_SEPARATE');
+ await assert.rejects(lstat(claimPath),e=>e.code==='ENOENT');
+ for(const plane of planes){
+   await assert.rejects(lstat(path.join(root,'runtime','authority-epochs',plane,'.lock')),
+     e=>e.code==='ENOENT');
+ }
+}));

package/test/r168-five-plane-fence-runner.mjs

@@ -0,0 +1,11 @@
+// Explicit Node --test worker isolation for R168 native fence test adapters.
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+const file=fileURLToPath(new URL('./r168-five-plane-fence.test.mjs',import.meta.url));
+const child=spawnSync(process.execPath,['--test',file],{cwd:path.dirname(file),
+  shell:false,encoding:'utf8',timeout:60000,windowsHide:true,maxBuffer:1024*1024});
+process.stdout.write(child.stdout??'');
+process.stderr.write(child.stderr??'');
+if(child.error)throw child.error;
+process.exitCode=child.status??1;

package/test/r168-five-plane-fence.test.mjs

@@ -0,0 +1,128 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,rm} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {simulateR168FivePlaneEpochFence,withR168FivePlaneEpochFence} from '../src/activation-reconciliation-fence-r168.mjs';
+
+const planes=['process','coding','autonomous','desktop','host'];
+async function fixture(run){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r168-fence-'));
+  try{
+    for(const plane of planes)await mkdir(path.join(root,'runtime','authority-epochs',plane),{recursive:true});
+    return await run(root);
+  }finally{await rm(root,{recursive:true,force:true});}
+}
+const makeAcquire=(calls,{rejectPlane=null,releaseFailurePlane=null,observedLocks=null}={})=>
+  async(file,bytes)=>{
+    const plane=path.basename(path.dirname(file));
+    const owner=JSON.parse(bytes.toString('utf8'));
+    assert.equal(owner.schema,'deadbyte.authority-epoch-lock.r65.v1');
+    assert.equal(owner.pid,process.pid);
+    assert.match(owner.token,/^[a-f0-9]{32}$/);
+    calls.push('acquire:'+plane);
+    if(rejectPlane===plane)return null;
+    observedLocks?.add(plane);
+    let done=false;
+    return {async release(){
+      assert.equal(done,false);done=true;
+      calls.push('release:'+plane);
+      observedLocks?.delete(plane);
+      if(releaseFailurePlane===plane)throw new Error('release exploded:'+plane);
+    }};
+  };
+async function gated(root,calls,work,options={}){
+  return simulateR168FivePlaneEpochFence({
+    stateRoot:root,onHeld:work,
+    testAcquire:makeAcquire(calls,options),
+    testOwnerIdentity:{schema:'deadbyte.foreground-process.v1',pid:process.pid,
+      parent_pid:0,creation_utc:'2026-10-26T00:00:00.000Z',executable_path:process.execPath,
+      command_line_sha256:'a'.repeat(64)}
+  });
+}
+test('R168 takes all five R85 epoch locks in deterministic order before final audit/CAS callback',()=>fixture(async root=>{
+  const calls=[],locks=new Set();
+  const result=await simulateR168FivePlaneEpochFence({stateRoot:root,
+    testAcquire:makeAcquire(calls,{observedLocks:locks}),
+    testOwnerIdentity:{schema:'deadbyte.foreground-process.v1',pid:process.pid,parent_pid:0,
+      creation_utc:'2026-10-26T00:00:00.000Z',executable_path:process.execPath,command_line_sha256:'a'.repeat(64)},
+    onHeld:async({planeOrder,assertHeld})=>{
+      assert.deepEqual(planeOrder,planes);
+      assert.deepEqual([...locks],planes);
+      assert.equal(assertHeld(),true);
+      calls.push('final-audit');
+      calls.push('expected-CAS-not-executed');
+      return 'R168_NO_MUTATION';
+    }
+  });
+  assert.equal(result,'R168_NO_MUTATION');
+  assert.deepEqual(calls,[
+    ...planes.map(p=>'acquire:'+p),'final-audit','expected-CAS-not-executed',
+    ...planes.toReversed().map(p=>'release:'+p)
+  ]);
+  assert.equal(locks.size,0);
+}));
+test('R168 partial native acquisition failure releases prior handles in reverse and never runs audit',()=>fixture(async root=>{
+  const calls=[];
+  await assert.rejects(gated(root,calls,async()=>{calls.push('UNEXPECTED_AUDIT');},{rejectPlane:'desktop'}),
+    /lock|held|busy/i);
+  assert.deepEqual(calls,['acquire:process','acquire:coding','acquire:autonomous','acquire:desktop',
+    'release:autonomous','release:coding','release:process']);
+}));
+test('R168 work abort releases all native handles; error is not reported as terminal success',()=>fixture(async root=>{
+  const calls=[];
+  await assert.rejects(gated(root,calls,async()=>{calls.push('signed-audit');throw new Error('audit mismatch');}),/audit mismatch/);
+  assert.deepEqual(calls.slice(-5),planes.toReversed().map(p=>'release:'+p));
+}));
+test('R168 native release ambiguity cannot be suppressed by callback success',()=>fixture(async root=>{
+  const calls=[];
+  await assert.rejects(gated(root,calls,async()=>true,{releaseFailurePlane:'coding'}),
+    error=>error instanceof AggregateError&&/release ambiguous/i.test(error.message)&&
+      error.errors.some(e=>e.cause?.message==='release exploded:coding'));
+  assert.deepEqual(calls.slice(-5),planes.toReversed().map(p=>'release:'+p));
+}));
+test('R168 missing epoch-plane directory stops before any acquisition',()=>fixture(async root=>{
+  const calls=[];
+  await rm(path.join(root,'runtime','authority-epochs','host'),{recursive:true});
+  await assert.rejects(gated(root,calls,async()=>true),/directory|epoch/i);
+  assert.deepEqual(calls,[]);
+}));
+
+test('R168 holding five epoch locks excludes concurrent normal authority append on every plane',()=>fixture(async root=>{
+  const active=new Set(),calls=[];
+  const nativeLikeAcquire=async(file)=>{
+    const plane=path.basename(path.dirname(file));
+    calls.push('acquire:'+plane);
+    if(active.has(plane))return null;
+    active.add(plane);
+    return {async release(){active.delete(plane);}};
+  };
+  const result=await simulateR168FivePlaneEpochFence({stateRoot:root,
+    testAcquire:nativeLikeAcquire,
+    testOwnerIdentity:{schema:'deadbyte.foreground-process.v1',pid:process.pid,parent_pid:0,
+      creation_utc:'2026-10-26T00:00:00.000Z',executable_path:process.execPath,command_line_sha256:'a'.repeat(64)},
+    onHeld:async({assertHeld})=>{
+      assertHeld();
+      for(const plane of planes){
+        const normalAppend=await nativeLikeAcquire(path.join(root,'runtime','authority-epochs',plane,'.lock'));
+        assert.equal(normalAppend,null,'append must not acquire '+plane+' while R168 holds exclusion');
+      }
+      return 'NO_MUTATION';
+    }
+  });
+  assert.equal(result,'NO_MUTATION');
+  assert.deepEqual([...active],[]);
+  assert.equal(calls.length,10);
+}));
+test('R168 never attempts stale epoch-lock recovery when busy; fail closed',()=>fixture(async root=>{
+  const calls=[];
+  await assert.rejects(gated(root,calls,async()=>{throw new Error('should not audit')},
+    {rejectPlane:'coding'}),/native lock busy: coding/);
+  assert.deepEqual(calls,['acquire:process','acquire:coding','release:process']);
+}));
+
+test('R168 protected production API refuses injection even inside test worker',()=>fixture(async root=>{
+  const acquire=async()=>({release:async()=>{}});
+  await assert.rejects(withR168FivePlaneEpochFence({stateRoot:root,onHeld:async()=>true,
+    testAcquire:acquire}),/forbids injected/);
+}));

package/test/r168-focused-suite.test.mjs

@@ -0,0 +1,4 @@
+// R168 integrated focused suite: live-free and without any production mutation.
+import './r168-reconciliation-audit.test.mjs';
+import './r168-owner-reconciliation-contract.test.mjs';
+import './r168-npm-resume-identity.test.mjs';

package/test/r168-native-five-plane-runner.mjs

@@ -0,0 +1,11 @@
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const target=fileURLToPath(new URL('./r168-native-five-plane-scratch.test.mjs',import.meta.url));
+const result=spawnSync(process.execPath,['--test',target],{
+  cwd:path.dirname(target),encoding:'utf8',windowsHide:true,shell:false,timeout:90000,maxBuffer:1024*1024
+});
+process.stdout.write(result.stdout??'');
+process.stderr.write(result.stderr??'');
+if(result.error)throw result.error;
+process.exitCode=result.status??1;

package/test/r168-native-five-plane-scratch.test.mjs

@@ -0,0 +1,49 @@
+// R168 five-plane real Win32 R85 lock test on disposable scratch ONLY.
+// Runs inside Node --test and reuses R89-verified R167 protected native addon.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {readFile,mkdir,mkdtemp,rm,lstat} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {pathToFileURL} from 'node:url';
+import {simulateR168FivePlaneEpochFence} from '../src/activation-reconciliation-fence-r168.mjs';
+import {queryForegroundIdentity} from '../src/foreground-process-identity.mjs';
+
+const C='C:\\Program Files\\DEADBYTE-R167-Protected-0.15.65-3316654646cc8705-Fix6';
+const sha=createHash('sha256');
+const expected='3316654646cc870584a7c969c2032af6c795229ff8c65e5a8b794f97c2458c41';
+const planes=['process','coding','autonomous','desktop','host'];
+
+test('R168 holds five real protected R85 native kernel locks together on isolated scratch',async()=>{
+  if(process.platform!=='win32')return;
+  const manifest=await readFile(path.join(C,'MANIFEST.SHA256'));
+  assert.equal(createHash('sha256').update(manifest).digest('hex'),expected);
+  const {acquireHeldEpochLock}=await import(pathToFileURL(path.join(C,'src','epoch-lock-r85.mjs')).href);
+  const stateRoot=await mkdtemp(path.join(os.tmpdir(),'r168-real-five-plane-'));
+  try{
+    for(const plane of planes)await mkdir(path.join(stateRoot,'runtime','authority-epochs',plane),{recursive:true});
+    const owner=queryForegroundIdentity(process.pid);
+    const result=await simulateR168FivePlaneEpochFence({
+      stateRoot,
+      testOwnerIdentity:owner,
+      testAcquire:acquireHeldEpochLock,
+      onHeld:async({planeOrder,assertHeld})=>{
+        assertHeld();
+        assert.deepEqual(planeOrder,planes);
+        for(const plane of planes){
+          const lock=path.join(stateRoot,'runtime','authority-epochs',plane,'.lock');
+          assert.ok((await lstat(lock)).isFile());
+          const competitor=await acquireHeldEpochLock(lock,Buffer.from('R168 scratch competitor'));
+          assert.equal(competitor,null,'native lock allowed duplicate owner for '+plane);
+        }
+        return 'REAL_NATIVE_FENCE_HELD';
+      }
+    });
+    assert.equal(result,'REAL_NATIVE_FENCE_HELD');
+    for(const plane of planes){
+      const lock=path.join(stateRoot,'runtime','authority-epochs',plane,'.lock');
+      await assert.rejects(lstat(lock),error=>error.code==='ENOENT');
+    }
+  }finally{await rm(stateRoot,{recursive:true,force:true});}
+});

package/test/r168-native-r85-protected-scratch.test.mjs

@@ -0,0 +1,44 @@
+// R168 nonproduction integration smoke: real R85 addon from R167 R89-trusted
+// Program Files install, applied ONLY to an isolated disposable scratch lock.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {readFile,mkdtemp,mkdir,rm,lstat} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+const protectedRoot='C:\\Program Files\\DEADBYTE-R167-Protected-0.15.65-3316654646cc8705-Fix6';
+const manifestHash='3316654646cc870584a7c969c2032af6c795229ff8c65e5a8b794f97c2458c41';
+
+test('R168 R85 protected addon enforces exclusive kernel handle on disposable local scratch',async()=>{
+  if(process.platform!=='win32'){test.skip('Windows only');return;}
+  const manifest=await readFile(path.join(protectedRoot,'MANIFEST.SHA256'));
+  assert.equal(createHash('sha256').update(manifest).digest('hex'),manifestHash);
+  const release=JSON.parse(await readFile(path.join(protectedRoot,'RELEASE.json'),'utf8'));
+  assert.equal(release.version,'0.15.65');
+  assert.equal(release.train,'R167');
+  // Loading the addon checks the protected code's own R89 ACL trust path.
+  const {acquireHeldEpochLock}=await import(pathToFileURL(path.join(protectedRoot,'src','epoch-lock-r85.mjs')).href);
+  const scratch=await mkdtemp(path.join(os.tmpdir(),'r168-real-r85-test-'));
+  const folder=path.join(scratch,'authority-epochs','coding');
+  await mkdir(folder,{recursive:true});
+  const lockFile=path.join(folder,'.lock');
+  const bytes=Buffer.from(JSON.stringify({schema:'deadbyte.r168-scratch-lock.v1',pid:process.pid,nonce:'scratch-only'}));
+  let first=null,second=null;
+  try{
+    first=await acquireHeldEpochLock(lockFile,bytes);
+    assert.ok(first,'protected R85 addon failed to acquire scratch lock');
+    assert.equal(await acquireHeldEpochLock(lockFile,bytes),null,'exclusive held lock accepted a competing acquisition');
+    await first.release();first=null;
+    await assert.rejects(lstat(lockFile),e=>e.code==='ENOENT');
+    second=await acquireHeldEpochLock(lockFile,bytes);
+    assert.ok(second,'R85 scratch lock cannot reacquire after verified release');
+    await second.release();second=null;
+    await assert.rejects(lstat(lockFile),e=>e.code==='ENOENT');
+  }finally{
+    if(second)await second.release();
+    if(first)await first.release();
+    await rm(scratch,{recursive:true,force:true});
+  }
+});

package/test/r168-npm-resume-identity.test.mjs

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {resumePackRecord} from '../src/npm-publication-resume-r168.mjs';
+import * as childProcess from 'node:child_process';
+import * as nodeUrl from 'node:url';
+
+const hash=(alg,x)=>createHash(alg).update(x).digest(alg==='sha512'?'base64':'hex');
+const bytes=Buffer.from('R168 immutable artifact sample');
+const manifest=hash('sha256',Buffer.from('manifest'));
+const claim={schema:'deadbyte.npm-publication-claim.r65.v1',version:'0.15.65',
+  manifest_sha256:manifest,tarball_sha256:hash('sha256',bytes)};
+const args={filename:'deadbyte-mcp-0.15.65.tgz',localBytes:bytes,claim,version:'0.15.65',manifestSha256:manifest};
+
+test('R168 resume derives npm shasum and integrity from verified preserved tarball',()=>{
+  const record=resumePackRecord(args);
+  assert.equal(record.filename,args.filename);
+  assert.equal(record.shasum,hash('sha1',bytes));
+  assert.equal(record.integrity,'sha512-'+hash('sha512',bytes));
+  assert.equal(record.sha256,hash('sha256',bytes));
+});
+test('R168 resume rejects immutable claim version, schema or manifest drift',()=>{
+  assert.throws(()=>resumePackRecord({...args,claim:{...claim,version:'0.15.64'}}),/claim|version/);
+  assert.throws(()=>resumePackRecord({...args,claim:{...claim,schema:'unknown'}}),/claim|schema/);
+  assert.throws(()=>resumePackRecord({...args,manifestSha256:'f'.repeat(64)}),/claim|manifest/);
+});
+test('R168 resume rejects altered tarball bytes instead of reconciling or publishing',()=>{
+  assert.throws(()=>resumePackRecord({...args,localBytes:Buffer.from('altered')}),/tarball|digest|claim/);
+  assert.throws(()=>resumePackRecord({...args,localBytes:null}),/tarball|bytes/);
+});
+
+test('R168 publisher wires verified resume record to R167 exact-byte publication fence',async()=>{
+  const {readFile}=await import('node:fs/promises');
+  const src=await readFile(new URL('../scripts/npm-release-r48.mjs',import.meta.url),'utf8');
+  assert.match(src,/const preservedRecord=resuming\?resumePackRecord\(/);
+  assert.match(src,/const packRecord=resuming\?preservedRecord:/);
+  assert.match(src,/observedShasum:packRecord\.shasum/);
+  assert.match(src,/claimData\.manifest_sha256!==currentManifestSha256/);
+  assert.doesNotMatch(src,/resuming\?\{filename:path\.basename\(preservedTarball\)\}/);
+});
+
+test('R168 publisher parses without invoking npm publish',()=>{
+  const {spawnSync}=childProcess;
+  const {fileURLToPath}=nodeUrl;
+  const target=fileURLToPath(new URL('../scripts/npm-release-r48.mjs',import.meta.url));
+  const child=spawnSync(process.execPath,['--check',target],{
+    encoding:'utf8',shell:false,windowsHide:true,timeout:15000});
+  assert.equal(child.status,0,child.stderr);
+});