deadbyte-mcp 0.15.47 → 0.15.49

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});
+  }
+});

package/test/r122-epoch-bounded-read.test.mjs

@@ -0,0 +1,58 @@
+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';
+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 maxRecordBytes = 1048576;
+
+async function withSignedHead(run) {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r122-bounded-'));
+  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}));
+    const writer = createWriterStore({runtimeDir});
+    const head = await writer.append({plane:'process', action:'grant', grantBytes,
+      grantInstanceNonce:nonce});
+    const candidate = createCandidateStore({runtimeDir});
+    await run({runtimeDir, candidate, head});
+  } finally {
+    await rm(root, {recursive:true, force:true, maxRetries:8, retryDelay:100});
+  }
+}
+
+test('R122 oversized but parseable head is rejected by hot read and history audit',
+  () => withSignedHead(async ({runtimeDir, candidate}) => {
+    const headPath = path.join(runtimeDir, 'authority-epochs', 'process', 'head.json');
+    const normal = await readFile(headPath);
+    await writeFile(headPath, Buffer.concat([normal,
+      Buffer.alloc(maxRecordBytes + 1 - normal.length, 0x20)]));
+    await assert.rejects(candidate.readHead({plane:'process'}), /authority epoch head oversized/);
+    await assert.rejects(candidate.auditHistory({plane:'process'}), /authority epoch head oversized/);
+  }));
+
+test('R122 oversized event is rejected before signature or hash work',
+  () => withSignedHead(async ({runtimeDir, candidate, head}) => {
+    const eventPath = path.join(runtimeDir, 'authority-epochs', 'process',
+      'events', head.event_file);
+    const normal = await readFile(eventPath);
+    await writeFile(eventPath, Buffer.concat([normal,
+      Buffer.alloc(maxRecordBytes + 1 - normal.length, 0x20)]));
+    await assert.rejects(candidate.readHead({plane:'process'}), /authority epoch event oversized/);
+    await assert.rejects(candidate.auditHistory({plane:'process'}), /authority epoch event oversized/);
+  }));

package/test/r123-recovery-bounded-read.test.mjs

@@ -0,0 +1,64 @@
+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';
+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 maxRecordBytes = 1048576;
+
+async function withOrphan(run) {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r123-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 grantBytes = Buffer.from(JSON.stringify({instance_nonce:nonce}));
+    const writer = createWriterStore({runtimeDir});
+    const prior = await writer.append({plane:'process', action:'grant', grantBytes,
+      grantInstanceNonce:nonce});
+    const dir = path.join(runtimeDir, 'authority-epochs', 'process');
+    const headPath = path.join(dir, 'head.json');
+    const priorHeadBytes = await readFile(headPath);
+    const orphan = await writer.append({plane:'process', action:'user_revoke', grantBytes,
+      grantInstanceNonce:nonce});
+    await writeFile(headPath, priorHeadBytes);
+    await run({runtimeDir, dir, headPath, prior, orphan,
+      candidate:createCandidateStore({runtimeDir})});
+  } finally {
+    await rm(root, {recursive:true, force:true, maxRetries:8, retryDelay:100});
+  }
+}
+
+test('R123 recovery rejects oversized parseable predecessor head',
+  () => withOrphan(async ({headPath, prior, orphan, candidate}) => {
+    const normal = await readFile(headPath);
+    await writeFile(headPath, Buffer.concat([normal,
+      Buffer.alloc(maxRecordBytes + 1 - normal.length, 0x20)]));
+    await assert.rejects(candidate.reconcileOrphanedRevocation({plane:'process',
+      expectedHeadSha256:prior.event_sha256, expectedOrphanSha256:orphan.event_sha256,
+      operatorConfirmed:true}), /authority epoch head oversized/);
+  }));
+
+test('R123 recovery rejects oversized orphan event before hash or lock acquisition',
+  () => withOrphan(async ({dir, prior, orphan, candidate}) => {
+    const eventPath = path.join(dir, 'events', orphan.event_file);
+    const normal = await readFile(eventPath);
+    await writeFile(eventPath, Buffer.concat([normal,
+      Buffer.alloc(maxRecordBytes + 1 - normal.length, 0x20)]));
+    await assert.rejects(candidate.reconcileOrphanedRevocation({plane:'process',
+      expectedHeadSha256:prior.event_sha256, expectedOrphanSha256:orphan.event_sha256,
+      operatorConfirmed:true}), /authority epoch event oversized/);
+  }));

package/test/r124-live-log-integrity.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,writeFile,appendFile,rename,rm} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import * as live from '../src/remote-live-log.mjs';
+import * as log from '../src/remote-log-decode-r60.mjs';
+
+test('R124 missing terminal outcome cannot show success',()=>{
+  const tracker=live.createLiveTimelineTracker({clock:()=>1000,displayMode:'ascii'});
+  tracker.observe({event_type:'tool.request',tool:'coding_file_write',request_id:'r124-missing',args:{root_id:'core',path:'a.txt'}});
+  const line=tracker.observe({event_type:'tool.result',tool:'coding_file_write',request_id:'r124-missing'});
+  assert.match(line,/OUTCOME_UNKNOWN|FAILED_AFTER_UNKNOWN_EFFECT/);
+  assert.doesNotMatch(line,/SUCCEEDED|\bOK\b/);
+  assert.equal(live.classifyRemoteAuditOutcome({event_type:'tool.result'}),'unknown');
+});
+test('R124 unexpected terminal status cannot imply success',()=>{
+  assert.equal(live.classifyRemoteAuditOutcome({outcome:{status:'threw',is_error:true}}),'error');
+  assert.equal(live.classifyRemoteAuditOutcome({outcome:{status:'alien',is_error:false}}),'unknown');
+  assert.equal(live.classifyRemoteAuditOutcome({outcome:{status:'ok',is_error:false}}),'ok');
+});
+test('R124 audit errors must not hide under missing outcomes in filters',()=>{
+  const filter=live.createLiveTimelineFilter('status=unknown');
+  filter.accept({event_type:'tool.request',tool:'coding_file_write',request_id:'r124-filter',args:{}});
+  assert.equal(filter.accept({event_type:'tool.result',tool:'coding_file_write',request_id:'r124-filter'}),true);
+});
+test('R124 tail reader keeps line bytes and detects rewrite and rotation on the same-size file',async()=>{
+  assert.equal(typeof log.readRemoteLogAppend,'function','export the bounded handle-pinned log reader');
+  const dir=await mkdtemp(path.join(os.tmpdir(),'r124-tail-'));
+  const file=path.join(dir,'segment-00000001.jsonl');
+  try{
+    await writeFile(file,'abc');
+    let {cursor}=await log.readRemoteLogAppend(file,null,{startAtEnd:true});
+    assert.equal(cursor.offset,3);
+    await appendFile(file,'def\n');
+    let chunk=await log.readRemoteLogAppend(file,cursor);
+    assert.equal(chunk.text,'def\n');
+    assert.equal(chunk.reset,false);
+    cursor=chunk.cursor;
+    await writeFile(file,'UVWXYZ\n');
+    chunk=await log.readRemoteLogAppend(file,cursor);
+    assert.equal(chunk.reset,true,'overwrite must be observed, not skipped');
+    assert.equal(chunk.text,'UVWXYZ\n');
+    cursor=chunk.cursor;
+    await rename(file,file+'.old');
+    await writeFile(file,'second\n');
+    chunk=await log.readRemoteLogAppend(file,cursor);
+    assert.equal(chunk.reset,true,'rotation must reset cursor');
+    assert.equal(chunk.text,'second\n');
+  }finally{await rm(dir,{recursive:true,force:true});}
+});
+test('R124 UTF8 partial codepoint stays unread until complete; no duplicate bytes',async()=>{
+  assert.equal(typeof log.readRemoteLogAppend,'function');
+  const dir=await mkdtemp(path.join(os.tmpdir(),'r124-utf8-'));
+  const file=path.join(dir,'bridge.stdout.log');
+  try{
+    await writeFile(file,Buffer.from([0xe0,0xb8]));
+    let chunk=await log.readRemoteLogAppend(file,{offset:0});
+    assert.equal(chunk.text,'');
+    assert.equal(chunk.cursor.offset,0);
+    await appendFile(file,Buffer.from([0x81,10]));
+    chunk=await log.readRemoteLogAppend(file,chunk.cursor);
+    assert.equal(chunk.text,'ก\n');
+    assert.equal(chunk.cursor.offset,4);
+  }finally{await rm(dir,{recursive:true,force:true});}
+});

package/test/r124-live-log-tail-boundaries.test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,writeFile,appendFile,rm} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {readRemoteLogAppend} from '../src/remote-log-decode-r60.mjs';
+
+async function fixture(fn){
+  const dir=await mkdtemp(path.join(os.tmpdir(),'r124-log-edge-'));
+  try{await fn(dir);}finally{await rm(dir,{recursive:true,force:true});}
+}
+
+test('R124 log catch-up is bounded and byte-exact across multiple chunks',()=>fixture(async dir=>{
+  const file=path.join(dir,'segment-00000001.jsonl');
+  const payload='0123456789'.repeat(47)+'\n';
+  await writeFile(file,payload);
+  let cursor=null,seen='';
+  for(let i=0;i<100&&seen.length<payload.length;i++){
+    const page=await readRemoteLogAppend(file,cursor,{maxBytes:11});
+    assert.ok(page.text.length<=11);
+    assert.equal(page.reset,false);
+    cursor=page.cursor;seen+=page.text;
+  }
+  assert.equal(seen,payload);
+  assert.equal(cursor.offset,Buffer.byteLength(payload));
+}));
+
+test('R124 UTF16LE tail makes forward progress on complete code units',()=>fixture(async dir=>{
+  const file=path.join(dir,'controller.stdout.log');
+  const data=Buffer.concat([Buffer.from([0xff,0xfe]),Buffer.from('กข\n','utf16le')]);
+  await writeFile(file,data);
+  let cursor=null,text='';
+  for(let i=0;i<10&&cursor?.offset!==data.length;i++){
+    const page=await readRemoteLogAppend(file,cursor,{maxBytes:4});
+    cursor=page.cursor;text+=page.text;
+  }
+  assert.equal(text,'กข\n');
+  assert.equal(cursor.offset,data.length);
+}));
+
+test('R124 disappearance surfaces explicit reset and does not silently preserve stale cursor',()=>fixture(async dir=>{
+  const file=path.join(dir,'bridge.stdout.log');
+  await writeFile(file,'abc\n');
+  const old=(await readRemoteLogAppend(file,null,{startAtEnd:true})).cursor;
+  await rm(file);
+  const disappeared=await readRemoteLogAppend(file,old);
+  assert.equal(disappeared.reset,true);
+  assert.equal(disappeared.resetReason,'file disappeared');
+  assert.equal(disappeared.cursor,null);
+  await writeFile(file,'new\n');
+  const newlyCreated=await readRemoteLogAppend(file,disappeared.cursor);
+  assert.equal(newlyCreated.text,'new\n');
+}));
+
+test('R124 invalid too-small chunk is rejected rather than livelocking on UTF8',async()=>{
+  await assert.rejects(readRemoteLogAppend('ignore.log',null,{maxBytes:1}),/arguments invalid/);
+});

package/test/r124-signed-predecessor-shape.test.mjs

@@ -0,0 +1,66 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash, generateKeyPairSync, randomBytes, sign} from 'node:crypto';
+import {mkdtemp, mkdir, rm, writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {canonicalJson} from '../src/canonical-json.mjs';
+import {createAuthorityEpochStore} from '../src/authority-continuity-r65.mjs';
+
+const domain = Buffer.from('DEADBYTE-AUTHORITY-DURABLE-EPOCH-R65-V1\0', 'utf8');
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+
+for (const [caseName, priorIdentity] of [
+  ['unknown action', {action:'made_up', update_id:null, restore_binding:null}],
+  ['stray update identity', {action:'grant', update_id:'unexpected', restore_binding:null}],
+  ['unexpected restore binding', {action:'grant', update_id:null, restore_binding:{unapproved:true}}],
+  ['wrong event schema', {action:'grant', update_id:null, restore_binding:null, schema:'not-an-epoch-event'}],
+  ['invalid grant nonce', {action:'grant', update_id:null, restore_binding:null, grant_instance_nonce:'bad'}],
+  ['non-genesis predecessor link', {action:'grant', update_id:null, restore_binding:null, previous_event_sha256:'0'.repeat(64)}],
+  ['incomplete policy binding', {action:'grant', update_id:null, restore_binding:null, policy_sha256:'0'.repeat(64)}],
+  ['array grant nonce', {action:'grant', update_id:null, restore_binding:null, grant_instance_nonce:['1'.repeat(64)]}],
+]) test(`R124 hot authority read rejects signed predecessor with ${caseName}`, async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r124-predecessor-'));
+  try {
+    const runtimeDir = path.join(root, 'runtime');
+    const trust = path.join(root, 'trust');
+    const dir = path.join(runtimeDir, 'authority-epochs', 'process');
+    await mkdir(path.join(dir, 'events'), {recursive:true});
+    await mkdir(trust);
+    const keys = generateKeyPairSync('ed25519');
+    const publicBytes = keys.publicKey.export({type:'spki', format:'pem'});
+    await writeFile(path.join(trust, 'ed25519-public.pem'), publicBytes);
+    const keyId = sha(keys.publicKey.export({type:'spki', format:'der'}));
+    const signed = body => {
+      const signature = sign(null, Buffer.concat([domain, Buffer.from(canonicalJson(body))]), keys.privateKey);
+      const event = {...body, attestation:{algorithm:'ed25519', domain:'DEADBYTE-AUTHORITY-DURABLE-EPOCH-R65-V1', key_id:keyId, signature_base64:signature.toString('base64')}};
+      const bytes = Buffer.from(canonicalJson(event));
+      return {bytes, hash:sha(bytes), event};
+    };
+    const grantBytes = Buffer.from('isolated grant');
+    const oldNonce = randomBytes(32).toString('hex');
+    const nonce = randomBytes(32).toString('hex');
+    const old = signed({schema:'deadbyte.authority-epoch-event.r65.v1', plane:'process', seq:1,
+      action:'grant', update_id:null, grant_sha256:sha(Buffer.from('old grant')),
+      grant_instance_nonce:oldNonce, restore_binding:null, previous_event_sha256:null,
+      recorded_at_utc:new Date().toISOString(), ...priorIdentity});
+    const currentBody = {schema:'deadbyte.authority-epoch-event.r65.v1', plane:'process', seq:2,
+      action:'grant', update_id:null, grant_sha256:sha(grantBytes), grant_instance_nonce:nonce,
+      restore_binding:null, previous_event_sha256:old.hash, recorded_at_utc:new Date().toISOString()};
+    const current = signed(currentBody);
+    const eventName = (seq, hash) => `${String(seq).padStart(16, '0')}-${hash}.json`;
+    await writeFile(path.join(dir, 'events', eventName(1, old.hash)), old.bytes);
+    await writeFile(path.join(dir, 'events', eventName(2, current.hash)), current.bytes);
+    await writeFile(path.join(dir, 'head.json'), Buffer.from(canonicalJson({
+      schema:'deadbyte.authority-epoch-head.r65.v1', plane:'process', seq:2,
+      action:'grant', update_id:null, grant_sha256:currentBody.grant_sha256,
+      grant_instance_nonce:nonce, restore_binding:null, previous_event_sha256:old.hash,
+      event_sha256:current.hash, event_file:eventName(2, current.hash)})));
+    const store = createAuthorityEpochStore({runtimeDir});
+    await assert.rejects(store.readHead({plane:'process'}), /authority epoch transition invalid/);
+    const decision = await store.verifyGrant({plane:'process', grantBytes, grantInstanceNonce:nonce});
+    assert.equal(decision.trusted, false);
+  } finally {
+    await rm(root, {recursive:true, force:true, maxRetries:8, retryDelay:100});
+  }
+});