deadbyte-mcp 0.15.48 → 0.15.49

package/test/r114-supervisor-absence-proof.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {randomBytes} from 'node:crypto';
+import childProcess from 'node:child_process';
+import {syncBuiltinESMExports} from 'node:module';
+import {promisify} from 'node:util';
+import {mkdtemp, readFile, rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+const moduleUrl=new URL('../src/autonomous-local-supervisor.mjs',import.meta.url);
+
+test('CIM false absence cannot authorize takeover of a live marker owner', {skip:process.platform!=='win32'}, async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r114-cim-absence-'));
+  const markerPath=path.join(root,'owner.json');
+  const originalExec=childProcess.execFile;
+  try {
+    const baseline=await import(`${moduleUrl.href}?baseline=${randomBytes(8).toString('hex')}`);
+    await baseline.claimSupervisor({markerPath});
+    const before=await readFile(markerPath);
+    let deniedLookups=0, falseAbsences=0;
+    const mock=function(...args){return originalExec.apply(this,args);};
+    mock[promisify.custom]=function(...args){
+      const shellArgs=Array.isArray(args[1])?args[1]:[];
+      const script=String(shellArgs[shellArgs.indexOf('-Command')+1]??'');
+      if(script.includes('Get-Process -Id')) {deniedLookups++;return Promise.reject(new Error('process identity access denied'));}
+      if(script.includes('Get-CimInstance Win32_Process')) {falseAbsences++;return Promise.resolve({stdout:'ABSENT\n',stderr:''});}
+      return originalExec[promisify.custom].apply(originalExec,args);
+    };
+    childProcess.execFile=mock;
+    syncBuiltinESMExports();
+    const module=await import(`${moduleUrl.href}?attack=${randomBytes(8).toString('hex')}`);
+    const observed=await module.observeSupervisor({markerPath});
+    assert.equal(observed.status,'unverified','a native live handle must outweigh a false CIM null');
+    assert.equal(observed.reason,'process_unobservable');
+    await assert.rejects(module.takeoverSupervisor({markerPath}),/unverified|unobservable|ownership/i);
+    assert.deepEqual(await readFile(markerPath),before,'live owner marker must remain byte-identical');
+    assert.ok(deniedLookups>=2);
+    assert.ok(falseAbsences>=2);
+  } finally {
+    childProcess.execFile=originalExec;
+    syncBuiltinESMExports();
+    await rm(root,{recursive:true,force:true});
+  }
+});

package/test/r115-posix-continuity-entrypoint.test.mjs

@@ -0,0 +1,17 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp, rm, access} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {createEpochNativeContinuityEngine} from '../src/activation-continuity-engine-r65.mjs';
+
+test('POSIX continuity engine refuses activation authority before any filesystem mutation',
+  {skip:process.platform==='win32'},async()=>{
+    const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r115-posix-continuity-'));
+    try{
+      assert.throws(()=>createEpochNativeContinuityEngine({
+        stateRoot:root,predecessorPolicyPaths:{},successorPolicyPaths:async()=>({}),updateId:'r115-posix'
+      }),/POSIX.*unsupported|Windows-only/i);
+      await assert.rejects(access(path.join(root,'runtime')),{code:'ENOENT'});
+    }finally{await rm(root,{recursive:true,force:true});}
+  });

package/test/r116-authority-crash-matrix.test.mjs

@@ -0,0 +1,83 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync, randomBytes, createHash} from 'node:crypto';
+import {mkdtemp, mkdir, writeFile, rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {createAuthorityEpochStore} from '../src/authority-continuity-r65.mjs';
+
+const phases = ['event_created', 'event_written', 'event_file_synced',
+  'event_directory_barrier', 'head_temp_created', 'head_temp_written',
+  'head_temp_file_synced', 'head_renamed', 'head_directory_barrier'];
+const sha256 = value => createHash('sha256').update(value).digest('hex');
+const grant = nonce => Buffer.from(JSON.stringify({instance_nonce:nonce, fixture:'R116 isolated'}));
+
+async function fixture(run) {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r116-epoch-'));
+  try {
+    const runtimeDir = path.join(root, 'runtime');
+    const trust = path.join(root, 'trust');
+    await mkdir(runtimeDir); await mkdir(trust);
+    const keys = generateKeyPairSync('ed25519');
+    await writeFile(path.join(trust, 'ed25519-private.pem'), keys.privateKey.export({type:'pkcs8', format:'pem'}), {flag:'wx'});
+    await writeFile(path.join(trust, 'ed25519-public.pem'), keys.publicKey.export({type:'spki', format:'pem'}), {flag:'wx'});
+    await run(runtimeDir);
+  } finally {
+    await rm(root, {recursive:true, force:true});
+  }
+}
+
+for (const phase of phases) {
+  test(`R116 interrupted user revoke at ${phase} never verifies the old grant`, () => fixture(async runtimeDir => {
+    const oldNonce = randomBytes(32).toString('hex');
+    const oldGrant = grant(oldNonce);
+    const store = createAuthorityEpochStore({runtimeDir});
+    await store.append({plane:'process', action:'grant', grantBytes:oldGrant, grantInstanceNonce:oldNonce});
+    assert.equal((await store.verifyGrant({plane:'process', grantBytes:oldGrant, grantInstanceNonce:oldNonce})).trusted, true);
+    const interrupted = createAuthorityEpochStore({runtimeDir, onDurabilityStage:at => {
+      if (at === phase) throw new Error(`R116_INTERRUPTED:${at}`);
+    }});
+    await assert.rejects(interrupted.append({plane:'process', action:'user_revoke', grantBytes:oldGrant,
+      grantInstanceNonce:oldNonce}), /R116_INTERRUPTED/);
+    const fresh = createAuthorityEpochStore({runtimeDir});
+    assert.equal((await fresh.verifyGrant({plane:'process', grantBytes:oldGrant,
+      grantInstanceNonce:oldNonce})).trusted, false);
+    if (phase === 'head_renamed' || phase === 'head_directory_barrier') {
+      assert.equal((await fresh.readHead({plane:'process'})).action, 'user_revoke');
+    } else {
+      await assert.rejects(fresh.readHead({plane:'process'}), /replay or incomplete write/);
+    }
+  }));
+
+  test(`R116 interrupted transaction restore at ${phase} is observed, never inferred`, () => fixture(async runtimeDir => {
+    const oldNonce = randomBytes(32).toString('hex');
+    const newNonce = randomBytes(32).toString('hex');
+    const oldGrant = grant(oldNonce);
+    const newGrant = grant(newNonce);
+    const store = createAuthorityEpochStore({runtimeDir});
+    const original = await store.append({plane:'process', action:'grant', grantBytes:oldGrant,
+      grantInstanceNonce:oldNonce});
+    const revoked = await store.append({plane:'process', action:'transaction_revoke', grantBytes:oldGrant,
+      grantInstanceNonce:oldNonce, updateId:'r116-isolated', expectedHeadSha256:original.event_sha256});
+    assert.equal((await store.verifyGrant({plane:'process', grantBytes:oldGrant,
+      grantInstanceNonce:oldNonce})).trusted, false);
+    const interrupted = createAuthorityEpochStore({runtimeDir, onDurabilityStage:at => {
+      if (at === phase) throw new Error(`R116_INTERRUPTED:${at}`);
+    }});
+    const restoreBinding = {
+      prior_grant_sha256:sha256(oldGrant), prior_grant_instance_nonce:oldNonce,
+      predecessor_policy_envelope_sha256:'1'.repeat(64),
+      successor_policy_envelope_sha256:'2'.repeat(64),
+      candidate_manifest_sha256:'3'.repeat(64), continuity_subject_sha256:'4'.repeat(64)
+    };
+    await assert.rejects(interrupted.append({plane:'process', action:'transaction_restore', grantBytes:newGrant,
+      grantInstanceNonce:newNonce, updateId:'r116-isolated', expectedHeadSha256:revoked.event_sha256,
+      restoreBinding}), /R116_INTERRUPTED/);
+    const fresh = createAuthorityEpochStore({runtimeDir});
+    const observed = await fresh.verifyGrant({plane:'process', grantBytes:newGrant, grantInstanceNonce:newNonce});
+    const committed = phase === 'head_renamed' || phase === 'head_directory_barrier';
+    assert.equal(observed.trusted, committed);
+    if (committed) assert.equal((await fresh.readHead({plane:'process'})).action, 'transaction_restore');
+    else await assert.rejects(fresh.readHead({plane:'process'}), /replay or incomplete write/);
+  }));
+}

package/test/r117-concurrent-orphan-recovery.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync, randomBytes} from 'node:crypto';
+import {mkdtemp, mkdir, readFile, writeFile, rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+// A writable development checkout cannot load the privileged Windows addon.
+// The optional test-only override must point to a protected, byte-identical
+// source installation; callers verify that hash before using this mode.
+const epochModule = process.env.DEADBYTE_TEST_PROTECTED_EPOCH_MODULE
+  ? pathToFileURL(process.env.DEADBYTE_TEST_PROTECTED_EPOCH_MODULE).href
+  : new URL('../src/authority-continuity-r65.mjs', import.meta.url).href;
+const {createAuthorityEpochStore} = await import(epochModule);
+
+test('R117 two independent recoverers commit one orphaned revoke at most once', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r117-recovery-'));
+  try {
+    const runtimeDir = path.join(root, 'runtime');
+    const trust = path.join(root, 'trust');
+    await mkdir(runtimeDir); await mkdir(trust);
+    const keys = generateKeyPairSync('ed25519');
+    await writeFile(path.join(trust, 'ed25519-private.pem'), keys.privateKey.export({type:'pkcs8', format:'pem'}), {flag:'wx'});
+    await writeFile(path.join(trust, 'ed25519-public.pem'), keys.publicKey.export({type:'spki', format:'pem'}), {flag:'wx'});
+    const nonce = randomBytes(32).toString('hex');
+    const bytes = Buffer.from(JSON.stringify({instance_nonce:nonce, fixture:'R117 isolated'}));
+    const writer = createAuthorityEpochStore({runtimeDir});
+    const granted = await writer.append({plane:'process', action:'grant', grantBytes:bytes, grantInstanceNonce:nonce});
+    const headPath = path.join(runtimeDir, 'authority-epochs', 'process', 'head.json');
+    const predecessorBytes = await readFile(headPath);
+    const orphan = await writer.append({plane:'process', action:'user_revoke', grantBytes:bytes, grantInstanceNonce:nonce});
+    // Simulate interruption before the new head becomes visible. The signed
+    // revoke event remains, while the exact prior signed head is restored.
+    await writeFile(headPath, predecessorBytes);
+    const observed = createAuthorityEpochStore({runtimeDir});
+    assert.equal((await observed.verifyGrant({plane:'process', grantBytes:bytes, grantInstanceNonce:nonce})).trusted, false);
+    const recover = () => createAuthorityEpochStore({runtimeDir}).reconcileOrphanedRevocation({
+      plane:'process', expectedHeadSha256:granted.event_sha256,
+      expectedOrphanSha256:orphan.event_sha256, operatorConfirmed:true
+    });
+    const outcomes = await Promise.allSettled([recover(), recover()]);
+    assert.equal(outcomes.filter(item => item.status === 'fulfilled').length, 1,
+      'two independent attempts cannot both claim the same recovery');
+    assert.equal(outcomes.filter(item => item.status === 'rejected').length, 1);
+    assert.equal(outcomes.find(item => item.status === 'fulfilled').value.status, 'REVOKED_ONLY_RECONCILED');
+    const finalStore = createAuthorityEpochStore({runtimeDir});
+    assert.equal((await finalStore.readHead({plane:'process'})).event_sha256, orphan.event_sha256);
+    assert.equal((await finalStore.verifyGrant({plane:'process', grantBytes:bytes,
+      grantInstanceNonce:nonce})).trusted, false);
+  } finally {
+    await rm(root, {recursive:true, force:true});
+  }
+});

package/test/r118-cross-process-orphan-recovery.test.mjs

@@ -0,0 +1,99 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync, randomBytes} from 'node:crypto';
+import {spawn} from 'node:child_process';
+import {mkdtemp, mkdir, readFile, writeFile, rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+const moduleUrl = process.env.DEADBYTE_TEST_PROTECTED_EPOCH_MODULE
+  ? pathToFileURL(process.env.DEADBYTE_TEST_PROTECTED_EPOCH_MODULE).href
+  : new URL('../src/authority-continuity-r65.mjs', import.meta.url).href;
+const {createAuthorityEpochStore} = await import(moduleUrl);
+
+function recoverer(runtimeDir, expectedHeadSha256, expectedOrphanSha256) {
+  // Each invocation is a separate OS process using the real native lock.
+  // IPC is only a starting barrier and result channel; it cannot bypass the
+  // authority store's signature, file identity, or ownership checks.
+  const code = `
+    import {createAuthorityEpochStore} from ${JSON.stringify(moduleUrl)};
+    process.once('message', async () => {
+      let result;
+      try {
+        const value = await createAuthorityEpochStore({runtimeDir:${JSON.stringify(runtimeDir)}})
+          .reconcileOrphanedRevocation({plane:'process',
+            expectedHeadSha256:${JSON.stringify(expectedHeadSha256)},
+            expectedOrphanSha256:${JSON.stringify(expectedOrphanSha256)},operatorConfirmed:true});
+        result = {kind:'RESULT',status:'FULFILLED',value:value.status};
+      } catch (error) {
+        result = {kind:'RESULT',status:'REJECTED',reason:String(error?.message??error)};
+      }
+      process.send(result, () => process.disconnect());
+    });
+    process.send({kind:'READY'});
+  `;
+  const child = spawn(process.execPath, ['--input-type=module', '-e', code], {
+    env:process.env, stdio:['ignore', 'ignore', 'pipe', 'ipc'], windowsHide:true
+  });
+  let stderr = '';
+  child.stderr.on('data', chunk => { stderr = (stderr + chunk.toString()).slice(-2048); });
+  let readyResolve, readyReject, resultResolve, resultReject;
+  const ready = new Promise((resolve, reject) => {readyResolve=resolve; readyReject=reject;});
+  const result = new Promise((resolve, reject) => {resultResolve=resolve; resultReject=reject;});
+  let readySeen = false, resultSeen = false;
+  child.on('message', message => {
+    if (message?.kind === 'READY') {readySeen=true; readyResolve();}
+    if (message?.kind === 'RESULT') {resultSeen=true; resultResolve(message);}
+  });
+  child.once('error', error => {readyReject(error); resultReject(error);});
+  child.once('exit', (code, signal) => {
+    const error = new Error(`R118 child exited before result code=${code} signal=${signal} stderr=${stderr}`);
+    if (!readySeen) readyReject(error);
+    if (!resultSeen) resultReject(error);
+  });
+  return {child, ready, result};
+}
+
+test('R118 two OS processes cannot both commit one signed orphaned user revoke',
+  {timeout:30000}, async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r118-cross-process-'));
+    const children = [];
+    try {
+      const runtimeDir = path.join(root, 'runtime');
+      const trust = path.join(root, 'trust');
+      await mkdir(runtimeDir); await mkdir(trust);
+      const keys = generateKeyPairSync('ed25519');
+      await writeFile(path.join(trust, 'ed25519-private.pem'),
+        keys.privateKey.export({type:'pkcs8', format:'pem'}), {flag:'wx'});
+      await writeFile(path.join(trust, 'ed25519-public.pem'),
+        keys.publicKey.export({type:'spki', format:'pem'}), {flag:'wx'});
+      const nonce = randomBytes(32).toString('hex');
+      const grantBytes = Buffer.from(JSON.stringify({instance_nonce:nonce, fixture:'R118 isolated'}));
+      const store = createAuthorityEpochStore({runtimeDir});
+      const granted = await store.append({plane:'process', action:'grant',
+        grantBytes, grantInstanceNonce:nonce});
+      const headPath = path.join(runtimeDir, 'authority-epochs', 'process', 'head.json');
+      const predecessorBytes = await readFile(headPath);
+      const orphan = await store.append({plane:'process', action:'user_revoke',
+        grantBytes, grantInstanceNonce:nonce});
+      await writeFile(headPath, predecessorBytes);
+      assert.equal((await store.verifyGrant({plane:'process', grantBytes,
+        grantInstanceNonce:nonce})).trusted, false);
+      children.push(recoverer(runtimeDir, granted.event_sha256, orphan.event_sha256));
+      children.push(recoverer(runtimeDir, granted.event_sha256, orphan.event_sha256));
+      await Promise.all(children.map(item => item.ready));
+      children.forEach(item => item.child.send({kind:'GO'}));
+      const results = await Promise.all(children.map(item => item.result));
+      assert.equal(results.filter(item => item.status === 'FULFILLED').length, 1, JSON.stringify(results));
+      assert.equal(results.filter(item => item.status === 'REJECTED').length, 1, JSON.stringify(results));
+      assert.equal(results.find(item => item.status === 'FULFILLED').value, 'REVOKED_ONLY_RECONCILED');
+      const fresh = createAuthorityEpochStore({runtimeDir});
+      assert.equal((await fresh.readHead({plane:'process'})).event_sha256, orphan.event_sha256);
+      assert.equal((await fresh.verifyGrant({plane:'process', grantBytes,
+        grantInstanceNonce:nonce})).trusted, false);
+    } finally {
+      for (const item of children) if (item.child.exitCode === null) item.child.kill();
+      await rm(root, {recursive:true, force:true, maxRetries:8, retryDelay:100});
+    }
+  });

package/test/r119-recovery-crash-after-commit.test.mjs

@@ -0,0 +1,91 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync, randomBytes} from 'node:crypto';
+import {spawn} from 'node:child_process';
+import {mkdtemp, mkdir, readFile, writeFile, access, rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+const moduleUrl = process.env.DEADBYTE_TEST_PROTECTED_EPOCH_MODULE
+  ? pathToFileURL(process.env.DEADBYTE_TEST_PROTECTED_EPOCH_MODULE).href
+  : new URL('../src/authority-continuity-r65.mjs', import.meta.url).href;
+const {createAuthorityEpochStore} = await import(moduleUrl);
+const exists = file => access(file).then(() => true, () => false);
+
+function crashRecovery(runtimeDir, expectedHeadSha256, expectedOrphanSha256) {
+  const code = `
+    import {createAuthorityEpochStore} from ${JSON.stringify(moduleUrl)};
+    const store = createAuthorityEpochStore({runtimeDir:${JSON.stringify(runtimeDir)},
+      onDurabilityStage:stage => {
+        if (stage === 'head_renamed') process.kill(process.pid, 'SIGKILL');
+      }});
+    await store.reconcileOrphanedRevocation({plane:'process',
+      expectedHeadSha256:${JSON.stringify(expectedHeadSha256)},
+      expectedOrphanSha256:${JSON.stringify(expectedOrphanSha256)},
+      operatorConfirmed:true});
+  `;
+  const child = spawn(process.execPath, ['--input-type=module', '-e', code], {
+    env:{...process.env, NODE_TEST_CONTEXT:'child-v8'},
+    stdio:['ignore', 'ignore', 'pipe'], windowsHide:true
+  });
+  let stderr = '';
+  child.stderr.on('data', bytes => {stderr = (stderr + bytes.toString()).slice(-1000);});
+  const done = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {child.kill(); reject(new Error('R119 recovery crash child timeout'));}, 12000);
+    child.once('error', error => {clearTimeout(timer); reject(error);});
+    child.once('exit', (code, signal) => {clearTimeout(timer); resolve({code, signal, stderr});});
+  });
+  return {child, done};
+}
+
+test('R119 crash after recovered head rename leaves revoke committed and dead lock recoverable',
+  {skip:process.platform !== 'win32', timeout:30000}, async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r119-recovery-crash-'));
+    let worker;
+    try {
+      const runtimeDir = path.join(root, 'runtime');
+      const trust = path.join(root, 'trust');
+      await mkdir(runtimeDir); await mkdir(trust);
+      const keys = generateKeyPairSync('ed25519');
+      await writeFile(path.join(trust, 'ed25519-private.pem'),
+        keys.privateKey.export({type:'pkcs8', format:'pem'}), {flag:'wx'});
+      await writeFile(path.join(trust, 'ed25519-public.pem'),
+        keys.publicKey.export({type:'spki', format:'pem'}), {flag:'wx'});
+      const nonce = randomBytes(32).toString('hex');
+      const grantBytes = Buffer.from(JSON.stringify({instance_nonce:nonce, fixture:'R119 isolated'}));
+      const store = createAuthorityEpochStore({runtimeDir});
+      const prior = await store.append({plane:'process', action:'grant',
+        grantBytes, grantInstanceNonce:nonce});
+      const epochDir = path.join(runtimeDir, 'authority-epochs', 'process');
+      const headPath = path.join(epochDir, 'head.json');
+      const priorHeadBytes = await readFile(headPath);
+      const orphan = await store.append({plane:'process', action:'user_revoke',
+        grantBytes, grantInstanceNonce:nonce});
+      await writeFile(headPath, priorHeadBytes);
+      assert.equal((await store.verifyGrant({plane:'process', grantBytes,
+        grantInstanceNonce:nonce})).trusted, false);
+
+      worker = crashRecovery(runtimeDir, prior.event_sha256, orphan.event_sha256);
+      const outcome = await worker.done;
+      assert.notEqual(outcome.code, 0, `recovery worker must die at head rename: ${outcome.stderr}`);
+      assert.equal((await store.readHead({plane:'process'})).event_sha256, orphan.event_sha256);
+      assert.equal((await store.verifyGrant({plane:'process', grantBytes,
+        grantInstanceNonce:nonce})).trusted, false);
+      const lockPath = path.join(epochDir, '.lock');
+      assert.equal(await exists(lockPath), true, 'dead recovery owner leaves a lock identity');
+      await assert.rejects(store.reconcileOrphanedRevocation({plane:'process',
+        expectedHeadSha256:prior.event_sha256,
+        expectedOrphanSha256:orphan.event_sha256, operatorConfirmed:true}),
+      /exactly one orphan event/);
+      const next = await store.append({plane:'process', action:'user_revoke',
+        grantBytes, grantInstanceNonce:nonce});
+      assert.equal(next.seq, orphan.seq + 1);
+      assert.equal((await store.verifyGrant({plane:'process', grantBytes,
+        grantInstanceNonce:nonce})).trusted, false);
+      assert.equal(await exists(lockPath), false, 'verified dead lock is reclaimed and released');
+    } finally {
+      if (worker?.child.exitCode === null) worker.child.kill();
+      await rm(root, {recursive:true, force:true, maxRetries:8, retryDelay:100});
+    }
+  });

package/test/r120-authority-history-audit.test.mjs

@@ -0,0 +1,103 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync, randomBytes} from 'node:crypto';
+import {spawnSync} from 'node:child_process';
+import {mkdtemp, mkdir, readdir, readFile, writeFile, unlink, rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath, pathToFileURL} from 'node:url';
+import {createAuthorityEpochStore as createCandidateStore} from '../src/authority-continuity-r65.mjs';
+
+const protectedModule = process.env.DEADBYTE_TEST_PROTECTED_EPOCH_MODULE;
+const createWriterStore = protectedModule
+  ? (await import(pathToFileURL(protectedModule).href)).createAuthorityEpochStore
+  : createCandidateStore;
+const repo = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const auditScript = path.join(repo, 'scripts', 'verify-authority-epoch-history.mjs');
+
+async function threeEvents(run) {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r120-history-'));
+  try {
+    const runtimeDir = path.join(root, 'runtime');
+    const trust = path.join(root, 'trust');
+    await mkdir(runtimeDir); await mkdir(trust);
+    const keys = generateKeyPairSync('ed25519');
+    await writeFile(path.join(trust, 'ed25519-private.pem'),
+      keys.privateKey.export({type:'pkcs8', format:'pem'}), {flag:'wx'});
+    await writeFile(path.join(trust, 'ed25519-public.pem'),
+      keys.publicKey.export({type:'spki', format:'pem'}), {flag:'wx'});
+    const writer = createWriterStore({runtimeDir});
+    const firstNonce = randomBytes(32).toString('hex');
+    const latestNonce = randomBytes(32).toString('hex');
+    const firstBytes = Buffer.from(JSON.stringify({instance_nonce:firstNonce, fixture:'R120 first'}));
+    const latestBytes = Buffer.from(JSON.stringify({instance_nonce:latestNonce, fixture:'R120 latest'}));
+    const first = await writer.append({plane:'process', action:'grant',
+      grantBytes:firstBytes, grantInstanceNonce:firstNonce});
+    await writer.append({plane:'process', action:'user_revoke',
+      grantBytes:firstBytes, grantInstanceNonce:firstNonce});
+    const latest = await writer.append({plane:'process', action:'grant',
+      grantBytes:latestBytes, grantInstanceNonce:latestNonce});
+    const auditor = createCandidateStore({runtimeDir});
+    await run({runtimeDir, auditor, first, latest, latestBytes, latestNonce});
+  } finally {
+    await rm(root, {recursive:true, force:true, maxRetries:8, retryDelay:100});
+  }
+}
+
+test('R120 independent audit verifies the complete signed history, not just newest two events',
+  () => threeEvents(async ({auditor, latest}) => {
+    const result = await auditor.auditHistory({plane:'process'});
+    assert.equal(result.status, 'PASS');
+    assert.equal(result.seq, 3);
+    assert.equal(result.event_sha256, latest.event_sha256);
+    assert.equal(result.verified_events, 3);
+  }));
+
+test('R120 oldest event corruption is rejected even when current grant head still verifies',
+  () => threeEvents(async ({runtimeDir, auditor, first, latestBytes, latestNonce}) => {
+    const events = path.join(runtimeDir, 'authority-epochs', 'process', 'events');
+    const names = await readdir(events);
+    const firstName = names.find(name => name.startsWith('0000000000000001-'));
+    assert.ok(firstName);
+    const firstPath = path.join(events, firstName);
+    const original = await readFile(firstPath);
+    await writeFile(firstPath, Buffer.from('{}'));
+    assert.equal((await auditor.verifyGrant({plane:'process', grantBytes:latestBytes,
+      grantInstanceNonce:latestNonce})).trusted, true,
+      'hot-path head and immediate predecessor do not inspect oldest event');
+    await assert.rejects(auditor.auditHistory({plane:'process'}), /history.*hash mismatch/);
+    assert.notEqual(first.event_sha256, latestNonce);
+    assert.notDeepEqual(await readFile(firstPath), original);
+  }));
+
+test('R120 CLI audit binds the exact expected head and rejects a wrong identity',
+  () => threeEvents(async ({runtimeDir, latest}) => {
+    const base = [auditScript, '--runtime-dir', runtimeDir, '--plane', 'process',
+      '--expected-head', latest.event_sha256];
+    const correct = spawnSync(process.execPath, base, {cwd:repo, encoding:'utf8', timeout:10000});
+    assert.equal(correct.status, 0, correct.stderr);
+    const result = JSON.parse(correct.stdout);
+    assert.equal(result.status, 'PASS');
+    assert.equal(result.event_sha256, latest.event_sha256);
+    const wrong = spawnSync(process.execPath,
+      [auditScript, '--runtime-dir', runtimeDir, '--plane', 'process',
+        '--expected-head', 'f'.repeat(64)], {cwd:repo, encoding:'utf8', timeout:10000});
+    assert.notEqual(wrong.status, 0);
+    assert.match(wrong.stderr, /expected head mismatch/);
+  }));
+
+test('R120 missing oldest event and duplicate signed-looking history fail the audit',
+  () => threeEvents(async ({runtimeDir, auditor, latestBytes, latestNonce}) => {
+    const events = path.join(runtimeDir, 'authority-epochs', 'process', 'events');
+    const names = await readdir(events);
+    const oldest = names.find(name => name.startsWith('0000000000000001-'));
+    assert.ok(oldest);
+    const original = await readFile(path.join(events, oldest));
+    await unlink(path.join(events, oldest));
+    assert.equal((await auditor.verifyGrant({plane:'process', grantBytes:latestBytes,
+      grantInstanceNonce:latestNonce})).trusted, true);
+    await assert.rejects(auditor.auditHistory({plane:'process'}), /history event count mismatch/);
+    await writeFile(path.join(events, oldest), original, {flag:'wx'});
+    await writeFile(path.join(events, `0000000000000001-${'f'.repeat(64)}.json`), original, {flag:'wx'});
+    await assert.rejects(auditor.auditHistory({plane:'process'}), /history event count mismatch/);
+  }));

package/test/r121-signed-transition-invariant.test.mjs

@@ -0,0 +1,132 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash, generateKeyPairSync, randomBytes, sign as cryptoSign} from 'node:crypto';
+import {mkdtemp, mkdir, readFile, writeFile, rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {createAuthorityEpochStore as createCandidateStore} from '../src/authority-continuity-r65.mjs';
+
+const protectedModule = process.env.DEADBYTE_TEST_PROTECTED_EPOCH_MODULE;
+const createWriterStore = protectedModule
+  ? (await import(pathToFileURL(protectedModule).href)).createAuthorityEpochStore
+  : createCandidateStore;
+const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
+const domain = Buffer.from('DEADBYTE-AUTHORITY-DURABLE-EPOCH-R65-V1\0', 'utf8');
+
+test('R121 correctly signed restore after user revoke is still an invalid authority transition',
+  async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r121-transition-'));
+    try {
+      const runtimeDir = path.join(root, 'runtime');
+      const trust = path.join(root, 'trust');
+      await mkdir(runtimeDir); await mkdir(trust);
+      const keys = generateKeyPairSync('ed25519');
+      await writeFile(path.join(trust, 'ed25519-private.pem'),
+        keys.privateKey.export({type:'pkcs8', format:'pem'}), {flag:'wx'});
+      await writeFile(path.join(trust, 'ed25519-public.pem'),
+        keys.publicKey.export({type:'spki', format:'pem'}), {flag:'wx'});
+      const firstNonce = randomBytes(32).toString('hex');
+      const nextNonce = randomBytes(32).toString('hex');
+      const oldGrant = Buffer.from(JSON.stringify({instance_nonce:firstNonce, fixture:'R121 old'}));
+      const nextGrant = Buffer.from(JSON.stringify({instance_nonce:nextNonce, fixture:'R121 next'}));
+      const writer = createWriterStore({runtimeDir});
+      await writer.append({plane:'process', action:'grant', grantBytes:oldGrant,
+        grantInstanceNonce:firstNonce});
+      const revoked = await writer.append({plane:'process', action:'user_revoke',
+        grantBytes:oldGrant, grantInstanceNonce:firstNonce});
+      const dir = path.join(runtimeDir, 'authority-epochs', 'process');
+      const restoreBinding = {
+        prior_grant_sha256:sha256(oldGrant), prior_grant_instance_nonce:firstNonce,
+        predecessor_policy_envelope_sha256:'1'.repeat(64),
+        successor_policy_envelope_sha256:'2'.repeat(64),
+        candidate_manifest_sha256:'3'.repeat(64),
+        continuity_subject_sha256:'4'.repeat(64)
+      };
+      const body = {
+        schema:'deadbyte.authority-epoch-event.r65.v1', plane:'process', seq:3,
+        action:'transaction_restore', update_id:'forged-restore',
+        grant_sha256:sha256(nextGrant), grant_instance_nonce:nextNonce,
+        restore_binding:restoreBinding, previous_event_sha256:revoked.event_sha256,
+        recorded_at_utc:new Date().toISOString()
+      };
+      const keyId = sha256(keys.publicKey.export({format:'der', type:'spki'}));
+      const signature = cryptoSign(null,
+        Buffer.concat([domain, Buffer.from(canonicalJson(body), 'utf8')]), keys.privateKey);
+      const event = {...body, attestation:{algorithm:'ed25519',
+        domain:'DEADBYTE-AUTHORITY-DURABLE-EPOCH-R65-V1', key_id:keyId,
+        signature_base64:signature.toString('base64')}};
+      const eventBytes = Buffer.from(canonicalJson(event), 'utf8');
+      const eventSha = sha256(eventBytes);
+      const eventFile = `${String(3).padStart(16, '0')}-${eventSha}.json`;
+      await writeFile(path.join(dir, 'events', eventFile), eventBytes, {flag:'wx'});
+      const head = {
+        schema:'deadbyte.authority-epoch-head.r65.v1', plane:'process', seq:3,
+        action:body.action, update_id:body.update_id,
+        grant_sha256:body.grant_sha256, grant_instance_nonce:body.grant_instance_nonce,
+        restore_binding:restoreBinding, previous_event_sha256:revoked.event_sha256,
+        event_sha256:eventSha, event_file:eventFile
+      };
+      await writeFile(path.join(dir, 'head.json'), Buffer.from(canonicalJson(head), 'utf8'));
+      const candidate = createCandidateStore({runtimeDir});
+      assert.equal((await candidate.verifyGrant({plane:'process', grantBytes:nextGrant,
+        grantInstanceNonce:nextNonce})).trusted, false);
+      await assert.rejects(candidate.readHead({plane:'process'}), /authority epoch transition invalid/);
+      await assert.rejects(candidate.auditHistory({plane:'process'}), /authority epoch transition invalid/);
+      assert.equal((await readFile(path.join(dir, 'events', eventFile))).equals(eventBytes), true);
+
+      // An older source can append a fresh grant over this forged head because
+      // its immediate-predecessor check lacks transition semantics. The new
+      // hot path checks the newest pair, while explicit audit must detect the
+      // invalid transition that is now deeper in history.
+      const finalNonce = randomBytes(32).toString('hex');
+      const finalGrant = Buffer.from(JSON.stringify({instance_nonce:finalNonce, fixture:'R121 final'}));
+      const finalHead = await writer.append({plane:'process', action:'grant',
+        grantBytes:finalGrant, grantInstanceNonce:finalNonce});
+      assert.equal((await candidate.readHead({plane:'process'})).event_sha256, finalHead.event_sha256);
+      assert.equal((await candidate.verifyGrant({plane:'process', grantBytes:finalGrant,
+        grantInstanceNonce:finalNonce})).trusted, true);
+      await assert.rejects(candidate.auditHistory({plane:'process'}), /authority epoch transition invalid/);
+    } finally {
+      await rm(root, {recursive:true, force:true, maxRetries:8, retryDelay:100});
+    }
+  });
+
+test('R121 valid grant → transaction revoke → transaction restore remains trusted', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r121-valid-restore-'));
+  try {
+    const runtimeDir = path.join(root, 'runtime');
+    const trust = path.join(root, 'trust');
+    await mkdir(runtimeDir); await mkdir(trust);
+    const keys = generateKeyPairSync('ed25519');
+    await writeFile(path.join(trust, 'ed25519-private.pem'),
+      keys.privateKey.export({type:'pkcs8', format:'pem'}), {flag:'wx'});
+    await writeFile(path.join(trust, 'ed25519-public.pem'),
+      keys.publicKey.export({type:'spki', format:'pem'}), {flag:'wx'});
+    const firstNonce = randomBytes(32).toString('hex');
+    const nextNonce = randomBytes(32).toString('hex');
+    const oldGrant = Buffer.from(JSON.stringify({instance_nonce:firstNonce, fixture:'R121 valid old'}));
+    const nextGrant = Buffer.from(JSON.stringify({instance_nonce:nextNonce, fixture:'R121 valid next'}));
+    const writer = createWriterStore({runtimeDir});
+    const granted = await writer.append({plane:'process', action:'grant',
+      grantBytes:oldGrant, grantInstanceNonce:firstNonce});
+    const revoked = await writer.append({plane:'process', action:'transaction_revoke',
+      grantBytes:oldGrant, grantInstanceNonce:firstNonce, updateId:'r121-valid',
+      expectedHeadSha256:granted.event_sha256});
+    const restored = await writer.append({plane:'process', action:'transaction_restore',
+      grantBytes:nextGrant, grantInstanceNonce:nextNonce, updateId:'r121-valid',
+      expectedHeadSha256:revoked.event_sha256,
+      restoreBinding:{prior_grant_sha256:sha256(oldGrant), prior_grant_instance_nonce:firstNonce,
+        predecessor_policy_envelope_sha256:'1'.repeat(64),
+        successor_policy_envelope_sha256:'2'.repeat(64),
+        candidate_manifest_sha256:'3'.repeat(64), continuity_subject_sha256:'4'.repeat(64)}});
+    const candidate = createCandidateStore({runtimeDir});
+    assert.equal((await candidate.readHead({plane:'process'})).event_sha256, restored.event_sha256);
+    assert.equal((await candidate.verifyGrant({plane:'process', grantBytes:nextGrant,
+      grantInstanceNonce:nextNonce})).trusted, true);
+    assert.equal((await candidate.auditHistory({plane:'process'})).status, 'PASS');
+  } finally {
+    await rm(root, {recursive:true, force:true, maxRetries:8, retryDelay:100});
+  }
+});