deadbyte-mcp 0.15.46 → 0.15.48

package/test/r74-kernel-lock.test.mjs

@@ -0,0 +1,156 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {copyFile,mkdir,mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath,pathToFileURL} from 'node:url';
+import {acquireKernelExclusiveLock, verifyKernelLockBinary} from '../src/kernel-lock-r74.mjs';
+
+const checkout=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+
+async function safeRm(dir) {
+  for (let i = 0; i < 15; i++) {
+    try {
+      await rm(dir, {recursive: true, force: true});
+      return;
+    } catch (err) {
+      if (err.code !== 'EBUSY' && err.code !== 'EPERM') throw err;
+      await new Promise(r => setTimeout(r, 40));
+    }
+  }
+  await rm(dir, {recursive: true, force: true});
+}
+
+test('kernel lock binary is verified and hash-pinned', async () => {
+  const verified = await verifyKernelLockBinary();
+  assert.equal(verified.ok, true, verified.reason);
+  assert.ok(/^[0-9a-f]{64}$/.test(verified.sha256));
+});
+
+test('kernel exclusive lock can be acquired and released normally', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r74-lock-basic-'));
+  const lock = path.join(root, 'target.lock');
+  try {
+    const release = await acquireKernelExclusiveLock(lock);
+    assert.equal(typeof release, 'function');
+    assert.ok(Number.isSafeInteger(release.pid));
+    await release();
+    const content = await readFile(lock, 'utf8');
+    assert.match(content, /^deadbyte\.kernel-lock\.r74:pid=\d+/);
+  } finally {
+    await safeRm(root);
+  }
+});
+
+test('concurrent writer is blocked while lock is held by another process', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r74-lock-contention-'));
+  const lock = path.join(root, 'target.lock');
+  try {
+    const release = await acquireKernelExclusiveLock(lock);
+    let error = null;
+    try {
+      await acquireKernelExclusiveLock(lock, {timeoutMs: 100, pollMs: 15});
+    } catch (err) {
+      error = err;
+    }
+    assert.ok(error, 'second writer should have been blocked');
+    assert.match(error.message, /atomic mutation lock timed out/);
+    await release();
+  } finally {
+    await safeRm(root);
+  }
+});
+
+test('crash-safe recovery: killed owner releases handle via OS, successor acquires without deleting lock pathname', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r74-lock-crash-'));
+  const lock = path.join(root, 'target.lock');
+  try {
+    const releaseFirst = await acquireKernelExclusiveLock(lock);
+    const lockPid = releaseFirst.pid;
+    assert.ok(Number.isSafeInteger(lockPid));
+
+    // Abrupt termination (simulating crash)
+    process.kill(lockPid, 'SIGKILL');
+
+    // Wait a brief moment for Windows kernel to close the handle
+    await new Promise(r => setTimeout(r, 60));
+
+    // Successor MUST be able to acquire the lock immediately WITHOUT deleting the lock file!
+    const releaseSecond = await acquireKernelExclusiveLock(lock, {timeoutMs: 1000});
+    assert.equal(typeof releaseSecond, 'function');
+
+    // Clean release
+    await releaseSecond();
+  } finally {
+    await safeRm(root);
+  }
+});
+
+test('dead PID or stale on-disk marker does not block new acquisition when no handle is held', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r74-lock-pidreuse-'));
+  const lock = path.join(root, 'target.lock');
+  try {
+    // Write a stale/foreign PID into the lock file
+    await writeFile(lock, 'deadbyte.kernel-lock.r74:pid=999999999\n');
+
+    // Because no live kernel handle holds the file, acquisition must succeed immediately
+    const release = await acquireKernelExclusiveLock(lock, {timeoutMs: 500});
+    assert.equal(typeof release, 'function');
+    await release();
+  } finally {
+    await safeRm(root);
+  }
+});
+
+test('concurrent recovery: exactly one worker acquires lock, others are serialized', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r74-lock-concurrent-'));
+  const lock = path.join(root, 'target.lock');
+  const sequence = [];
+  try {
+    const runWorker = async (id) => {
+      const release = await acquireKernelExclusiveLock(lock, {timeoutMs: 5000, pollMs: 10});
+      sequence.push(`enter_${id}`);
+      await new Promise(r => setTimeout(r, 20));
+      sequence.push(`exit_${id}`);
+      await release();
+    };
+
+    // Run 3 workers concurrently
+    await Promise.all([runWorker(1), runWorker(2), runWorker(3)]);
+
+    assert.equal(sequence.length, 6);
+    // Every enter must be followed by its matching exit before next enter
+    for (let i = 0; i < sequence.length; i += 2) {
+      const enter = sequence[i];
+      const exit = sequence[i + 1];
+      const id = enter.split('_')[1];
+      assert.equal(exit, `exit_${id}`, `non-exclusive execution detected: ${enter} followed by ${exit}`);
+    }
+  } finally {
+    await safeRm(root);
+  }
+});
+
+test('replaced binary negative: tampered executable fails closed with recovery blocked', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r74-lock-tampered-'));
+  const lock = path.join(root, 'target.lock');
+  try {
+    for(const dir of ['src','docs','bin'])await mkdir(path.join(root,dir));
+    for(const rel of ['src/kernel-lock-r74.mjs','docs/R74-KERNEL-LOCK-BINARY.json',
+      'bin/deadbyte-kernel-lock-r74.exe'])
+      await copyFile(path.join(checkout,rel),path.join(root,rel));
+    const fixture=await import(pathToFileURL(path.join(root,'src','kernel-lock-r74.mjs')).href);
+    const metaPath=path.join(root,'docs','R74-KERNEL-LOCK-BINARY.json');
+    const originalMeta = await readFile(metaPath, 'utf8');
+    const tampered = JSON.parse(originalMeta);
+    tampered.sha256 = '0'.repeat(64);
+    await writeFile(metaPath, JSON.stringify(tampered, null, 2) + '\n');
+
+    await assert.rejects(
+      fixture.acquireKernelExclusiveLock(lock, {timeoutMs: 200}),
+      /atomic mutation lock recovery blocked: native exclusive locking unavailable/
+    );
+  } finally {
+    await safeRm(root);
+  }
+});

package/test/r74-prepublish-contract.test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp, readFile, rm, cp, writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {verifyR74PrepublishContract} from '../scripts/npm-prepublish-contract-r74.mjs';
+
+const repoRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+
+test('R74 prepublish contract: positive path succeeds and verifies identities', async () => {
+  const result = await verifyR74PrepublishContract({rootPath: repoRoot});
+  assert.equal(result.schema, 'deadbyte.r74-prepublish-contract.v1');
+  assert.equal(result.valid, true);
+  assert.equal(result.checks.predecessors_distinct, true);
+  assert.equal(result.checks.manifest_exists, true);
+  assert.equal(result.checks.manifest_verified, true);
+  assert.equal(result.checks.package_leak_check.ok, true);
+  assert.equal(result.checks.no_self_referential_tarball_hash, true);
+  assert.equal(result.identities.package_name, 'deadbyte-mcp');
+  assert.equal(result.identities.package_version, '0.15.48');
+  assert.equal(result.identities.target_train, 'R74');
+  assert.equal(result.identities.published_source_predecessor, '0.15.46');
+  assert.notEqual(result.identities.published_source_predecessor, result.identities.runtime_predecessor);
+});
+
+test('R74 prepublish contract: negative - tampered native binary hash fails closed', async () => {
+  const sandbox = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r74-prepub-tamper-'));
+  try {
+    // Copy minimal required files to sandbox
+    await cp(path.join(repoRoot, 'package.json'), path.join(sandbox, 'package.json'));
+    await cp(path.join(repoRoot, 'RELEASE.json'), path.join(sandbox, 'RELEASE.json'));
+    await cp(path.join(repoRoot, 'MANIFEST.SHA256'), path.join(sandbox, 'MANIFEST.SHA256'));
+    await cp(path.join(repoRoot, 'docs'), path.join(sandbox, 'docs'), {recursive: true});
+    await cp(path.join(repoRoot, 'bin'), path.join(sandbox, 'bin'), {recursive: true});
+
+    // Tamper with binary
+    const exePath = path.join(sandbox, 'bin', 'deadbyte-kernel-lock-r74.exe');
+    await writeFile(exePath, 'TAMPERED_BYTES_R74');
+
+    await assert.rejects(
+      async () => {
+        await verifyR74PrepublishContract({rootPath: sandbox});
+      },
+      /Prepublish contract failed: native binary .* hash mismatch/
+    );
+  } finally {
+    await rm(sandbox, {recursive: true, force: true}).catch(() => {});
+  }
+});
+
+test('R74 prepublish contract: negative - predecessor collision fails closed', async () => {
+  const sandbox = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-r74-prepub-collision-'));
+  try {
+    const pkg = JSON.parse(await readFile(path.join(repoRoot, 'package.json'), 'utf8'));
+    const release = JSON.parse(await readFile(path.join(repoRoot, 'RELEASE.json'), 'utf8'));
+    
+    // Set runtime predecessor to match published source predecessor (0.15.46)
+    release.parent = release.parent || {};
+    release.parent.version = '0.15.46';
+
+    await writeFile(path.join(sandbox, 'package.json'), JSON.stringify(pkg, null, 2));
+    await writeFile(path.join(sandbox, 'RELEASE.json'), JSON.stringify(release, null, 2));
+
+    await assert.rejects(
+      async () => {
+        await verifyR74PrepublishContract({rootPath: sandbox});
+      },
+      /Prepublish contract failed: published source and runtime predecessor must be distinct/
+    );
+  } finally {
+    await rm(sandbox, {recursive: true, force: true}).catch(() => {});
+  }
+});
+
+test('R74 prepublish contract: negative - package leakage fails closed', async () => {
+  // Verify that filter catches testing/, references/, .git, .env
+  const leakedNames = ['testing/secret.json', 'references/doc.md', '.git/config', '.env'];
+  for (const name of leakedNames) {
+    const isLeaked = /^(?:testing|references|\.git)(?:\/|$)|(?:^|\/)\.env(?:\.|$)/i.test(name);
+    assert.equal(isLeaked, true, `Expected ${name} to be detected as leaked`);
+  }
+});
+
+test('R74 prepublish contract: non-self-referential tarball check', async () => {
+  // Verify that RELEASE.json does NOT contain a prospective hash of the tarball that contains it
+  const release = JSON.parse(await readFile(path.join(repoRoot, 'RELEASE.json'), 'utf8'));
+  assert.equal(release.tarball_sha256, undefined, 'RELEASE.json must not claim self-referential tarball hash');
+});

package/test/r75-activation-authority-proof.test.mjs

@@ -0,0 +1,46 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {classifyActivationPreflight} from '../src/activation-preflight-r65.mjs';
+
+const planes=['process','coding','autonomous','desktop','host'];
+const parent={release_id:'v-parent',version:'0.15.45',manifest_sha256:'a'.repeat(64),generation_manifest_sha256:'b'.repeat(64)};
+const candidate={version:'0.15.47',manifest_sha256:'c'.repeat(64)};
+const policy_sha256=Object.fromEntries(planes.map((plane,index)=>[plane,String(index+1).repeat(64)]));
+const disarmed=Object.fromEntries(planes.map(plane=>[plane,{configured:true,armed:false,reason:'disarmed'}]));
+const proof=Object.fromEntries(planes.map(plane=>[plane,{state:'VERIFIED_DISARMED',policy_sha256:policy_sha256[plane],grant_absent:true}]));
+const observation={state:'OFFLINE',authority:disarmed,authority_proof:proof,policy_sha256,
+  bridge:{alive:false},core:{alive:false},cloud:{alive:false},supervisor:{running:false},
+  active_release_id:parent.release_id,active_manifest_sha256:parent.manifest_sha256,
+  active_generation_manifest_sha256:parent.generation_manifest_sha256};
+const classify=observed=>classifyActivationPreflight({pointer:parent,expectedParent:parent,candidate,expectedCandidate:candidate,observation:observed});
+
+test('verified absent grants and exact disarmed observation allow offline preflight',()=>{
+  const result=classify(observation);
+  assert.equal(result.state,'OFFLINE_CLEAN');
+  assert.equal(result.safe_to_activate,true);
+});
+
+test('Autonomous armed=false with an unverified reason is not activation-safe',()=>{
+  const result=classify({...observation,authority:{...disarmed,autonomous:{configured:true,armed:false,reason:'coding policy contains a broad filesystem root'}}});
+  assert.equal(result.safe_to_activate,false);
+  assert.equal(result.state,'AUTHORITY_UNVERIFIED');
+});
+
+test('a missing direct grant proof cannot be inferred safe from armed=false',()=>{
+  const result=classify({...observation,authority_proof:{...proof,autonomous:{state:'UNVERIFIED',policy_sha256:policy_sha256.autonomous,grant_absent:false}}});
+  assert.equal(result.safe_to_activate,false);
+  assert.equal(result.state,'AUTHORITY_UNVERIFIED');
+});
+
+test('controller object observations without direct grant proof cannot activate',()=>{
+  const result=classify({...observation,authority_proof:undefined});
+  assert.equal(result.safe_to_activate,false);
+  assert.equal(result.state,'AUTHORITY_UNVERIFIED');
+});
+
+test('legacy Boolean authority observations without direct proof cannot activate',()=>{
+  const legacy=Object.fromEntries(planes.map(plane=>[plane,false]));
+  const result=classify({...observation,authority:legacy,authority_proof:undefined});
+  assert.equal(result.safe_to_activate,false);
+  assert.equal(result.state,'AUTHORITY_UNVERIFIED');
+});

package/test/r75-authority-evidence.test.mjs

@@ -0,0 +1,77 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,writeFile,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {observeAuthorityEvidence} from '../src/activation-authority-proof-r75.mjs';
+
+const planes=['process','coding','autonomous','desktop','host'];
+const grantField={process:'grant_file',coding:'lease_file',autonomous:'lease_file',desktop:'grant_file',host:'arm_file'};
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function fixture({broadCodingRoot=false,hostSchema=2}={}){
+  const stateRoot=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r75-authority-'));
+  const runtime=path.join(stateRoot,'runtime'),policies=path.join(stateRoot,'policies');
+  await mkdir(runtime);await mkdir(policies);
+  const policyPaths={},policySha256={},grantPaths={};
+  for(const plane of planes){
+    const grant=path.join(runtime,`${plane}-grant.json`),policyPath=path.join(policies,`${plane}.json`);
+    const bytes=Buffer.from(JSON.stringify({schema:`deadbyte.${plane}-policy.v${plane==='host'?hostSchema:1}`,enabled:true,
+      [grantField[plane]]:grant,...(plane==='coding'&&broadCodingRoot?{roots:{broad:{path:path.parse(stateRoot).root}}}:{})}));
+    await writeFile(policyPath,bytes);
+    policyPaths[plane]=policyPath;policySha256[plane]=sha(bytes);grantPaths[plane]=grant;
+  }
+  const authority=Object.fromEntries(planes.map(plane=>[plane,{configured:true,armed:false,reason:'disarmed'}]));
+  return {stateRoot,policyPaths,policySha256,grantPaths,authority,cleanup:()=>rm(stateRoot,{recursive:true,force:true})};
+}
+
+test('direct policy-bound grant absence proves clean disarmed despite broad issuance root',async()=>{
+  const f=await fixture({broadCodingRoot:true});
+  try{
+    const proof=await observeAuthorityEvidence(f);
+    for(const plane of planes){assert.equal(proof[plane].state,'VERIFIED_DISARMED');assert.equal(proof[plane].grant_absent,true);}
+  }finally{await f.cleanup();}
+});
+
+test('legacy host-policy.v1 accepted by the controller remains eligible for proof',async()=>{
+  const f=await fixture({hostSchema:1});
+  try{assert.equal((await observeAuthorityEvidence(f)).host.state,'VERIFIED_DISARMED');}
+  finally{await f.cleanup();}
+});
+
+test('a present grant with controller armed=false is unverified, not clean',async()=>{
+  const f=await fixture();
+  try{
+    await writeFile(f.grantPaths.autonomous,'{}');
+    const proof=await observeAuthorityEvidence(f);
+    assert.equal(proof.autonomous.state,'UNVERIFIED');
+  }finally{await f.cleanup();}
+});
+
+test('malformed policy cannot provide disarmed proof',async()=>{
+  const f=await fixture();
+  try{
+    await writeFile(f.policyPaths.autonomous,'not-json');
+    await assert.rejects(observeAuthorityEvidence(f),/policy/i);
+  }finally{await f.cleanup();}
+});
+
+test('policy-bound grant path outside isolated runtime cannot provide disarmed proof',async()=>{
+  const f=await fixture();
+  try{
+    const bytes=Buffer.from(JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
+      lease_file:path.join(os.tmpdir(),'outside-autonomous-grant.json')}));
+    await writeFile(f.policyPaths.autonomous,bytes);
+    f.policySha256.autonomous=sha(bytes);
+    await assert.rejects(observeAuthorityEvidence(f),/outside runtime/);
+  }finally{await f.cleanup();}
+});
+
+test('policy digest drift cannot provide stale disarmed proof',async()=>{
+  const f=await fixture();
+  try{
+    await writeFile(f.policyPaths.autonomous,'{}');
+    await assert.rejects(observeAuthorityEvidence(f),/digest changed/);
+  }finally{await f.cleanup();}
+});

package/test/r76-pinned-marker-cas.test.mjs

@@ -0,0 +1,78 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,writeFile,open,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {readRemoteMarkerSnapshot,deletePinnedRemoteMarker} from '../src/foreground-marker-cas-win32.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker={schema:'deadbyte.remote-session.v2',owner_pid:14445,guardian_pid:0,session_nonce:'a'.repeat(64)};
+
+async function fixture(run){
+  const root=await mkdtemp(path.join(os.tmpdir(),'r76-marker-cas-'));
+  const file=path.join(root,'remote-session.json');
+  try{return await run(file);}finally{await rm(root,{recursive:true,force:true});}
+}
+
+test('snapshot binds exact bytes and rejects untrusted marker shapes',async()=>fixture(async file=>{
+  assert.equal(await readRemoteMarkerSnapshot(file),null);
+  const raw=JSON.stringify(marker)+'\n';
+  await writeFile(file,raw);
+  const snapshot=await readRemoteMarkerSnapshot(file);
+  assert.deepEqual(snapshot.marker,marker);
+  assert.equal(snapshot.sha256,sha(Buffer.from(raw)));
+  await writeFile(file,'{malformed');
+  await assert.rejects(()=>readRemoteMarkerSnapshot(file),/marker JSON invalid/);
+}));
+
+test('native disposition never silently falls back to pathname removal',async()=>fixture(async file=>{
+  await writeFile(file,JSON.stringify(marker));
+  if(process.platform!=='win32'){
+    assert.throws(()=>deletePinnedRemoteMarker(file,'a'.repeat(64)),/Windows-only/);
+    assert.deepEqual(JSON.parse(await readFile(file,'utf8')),marker);
+  }
+}));
+
+const winTest=process.platform==='win32'?test:test.skip;
+
+winTest('Windows: pinned handle removes the exact marker, but not a missing marker',async()=>fixture(async file=>{
+  await writeFile(file,JSON.stringify(marker)+'\n');
+  const snapshot=await readRemoteMarkerSnapshot(file);
+  assert.equal(deletePinnedRemoteMarker(file,snapshot.sha256),'REMOVED');
+  await assert.rejects(readFile(file),{code:'ENOENT'});
+  assert.equal(deletePinnedRemoteMarker(file,snapshot.sha256),'MISSING');
+}));
+
+winTest('Windows: replacement between snapshot and disposition is never removed',async()=>fixture(async file=>{
+  await writeFile(file,JSON.stringify(marker));
+  const snapshot=await readRemoteMarkerSnapshot(file);
+  const replaced={...marker,session_nonce:'b'.repeat(64)};
+  await writeFile(file,JSON.stringify(replaced));
+  assert.equal(deletePinnedRemoteMarker(file,snapshot.sha256),'CHANGED');
+  assert.deepEqual(JSON.parse(await readFile(file,'utf8')),replaced);
+}));
+
+winTest('Windows: concurrent writable handle makes native deletion fail closed',async()=>fixture(async file=>{
+  await writeFile(file,JSON.stringify(marker));
+  const snapshot=await readRemoteMarkerSnapshot(file);
+  const writer=await open(file,'r+');
+  try{
+    assert.throws(()=>deletePinnedRemoteMarker(file,snapshot.sha256),/failed closed/);
+    assert.deepEqual(JSON.parse(await readFile(file,'utf8')),marker);
+  }finally{await writer.close();}
+  assert.equal(deletePinnedRemoteMarker(file,snapshot.sha256),'REMOVED');
+}));
+
+winTest('Windows: malformed or unreadable marker remains intact',async()=>fixture(async file=>{
+  await writeFile(file,'{bad json');
+  await assert.rejects(()=>readRemoteMarkerSnapshot(file),/marker JSON invalid/);
+  assert.equal(await readFile(file,'utf8'),'{bad json');
+}));
+
+// Cross-platform guard: node --check cannot detect undeclared names inside a function.
+// The Windows hard-kill guardian integration test separately proves runtime cleanup.
+test('guardian imports its pinned marker snapshot and native disposer explicitly',async()=>{
+  const guardian=await readFile(new URL('../src/remote-session-guardian.mjs',import.meta.url),'utf8');
+  assert.match(guardian,/import\s*\{\s*readRemoteMarkerSnapshot\s*,\s*deletePinnedRemoteMarker\s*\}\s*from\s*['"]\.\/foreground-marker-cas-win32\.mjs['"]/);
+});

package/test/r77-epoch-grant-cas.test.mjs

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {mkdtemp,open,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {deletePinnedRemoteMarker} from '../src/foreground-marker-cas-win32.mjs';
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+// Source contract: restore must use the same native CAS boundary as error cleanup.
+test('R77 restore never removes a previously examined grant by pathname',async()=>{
+  const current=await readFile(new URL('../src/activation-continuity-engine-r65.mjs',import.meta.url),'utf8');
+  assert.match(current,/const removed=await removeIfExact\(file,record\.grant_sha256\)/);
+  assert.match(current,/deletePinnedRemoteMarker\(file,expectedSha256\)/);
+  assert.doesNotMatch(current,/if\(sha\(existing\)!==record\.grant_sha256\)[\s\S]{0,100}await rm\(file/);
+});
+
+async function withGrantFixture(callback){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r77-epoch-cas-'));
+  const file=path.join(root,'coding-grant.json');
+  const old=Buffer.from(JSON.stringify({schema:'deadbyte.coding-grant.v2',instance_nonce:'1'.repeat(64)}));
+  try {await writeFile(file,old);await callback({file,old,root});}
+  finally {await rm(root,{recursive:true,force:true});}
+}
+
+test('Windows: grant file exact SHA disposition succeeds', {skip:process.platform!=='win32'},async()=>{
+  await withGrantFixture(async({file,old})=>{
+    assert.equal(deletePinnedRemoteMarker(file,sha(old)),'REMOVED');
+    await assert.rejects(readFile(file),{code:'ENOENT'});
+  });
+});
+
+test('Windows: replaced grant is not removed by stale SHA', {skip:process.platform!=='win32'},async()=>{
+  await withGrantFixture(async({file,old})=>{
+    const replacement=Buffer.from(JSON.stringify({schema:'deadbyte.coding-grant.v2',instance_nonce:'2'.repeat(64)}));
+    await writeFile(file,replacement);
+    assert.equal(deletePinnedRemoteMarker(file,sha(old)),'CHANGED');
+    assert.deepEqual(await readFile(file),replacement);
+  });
+});
+
+test('Windows: a concurrent writable grant handle blocks disposition', {skip:process.platform!=='win32'},async()=>{
+  await withGrantFixture(async({file,old})=>{
+    const live=await open(file,'r+');
+    try {assert.throws(()=>deletePinnedRemoteMarker(file,sha(old)),/failed closed/);}
+    finally {await live.close();}
+    assert.deepEqual(await readFile(file),old);
+  });
+});

package/test/r78-parent-junction-cas.test.mjs

@@ -0,0 +1,62 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,randomBytes} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,rm,symlink,unlink,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {deletePinnedRemoteMarker} from '../src/foreground-marker-cas-win32.mjs';
+
+const digest=bytes=>createHash('sha256').update(bytes).digest('hex');
+const winTest=process.platform==='win32'?test:test.skip;
+
+// Does not establish native protection alone; verifies the intended source contract.
+test('R78 source pins every ancestor handle and rejects reparse parents before leaf disposition',async()=>{
+  const source=await readFile(new URL('../src/foreground-marker-cas-win32.mjs',import.meta.url),'utf8');
+  assert.match(source,/static void PinAncestor\(/);
+  assert.match(source,/FILE_FLAG_BACKUP_SEMANTICS\|FILE_FLAG_OPEN_REPARSE_POINT/);
+  assert.match(source,/FILE_ATTRIBUTE_REPARSE_POINT/);
+  assert.match(source,/PinAncestor\(current,pins\)/);
+  assert.match(source,/for\(int i=pins\.Count-1;i>=0;i--\)pins\[i\]\.Dispose\(\)/);
+  assert.doesNotMatch(source,/await rm\(file/);
+});
+
+async function withFixture(cb){
+  const fixture=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r78-parent-cas-'));
+  const inside=path.join(fixture,'state','runtime');
+  const outside=path.join(fixture,'outside');
+  const bytes=Buffer.from(JSON.stringify({schema:'deadbyte.r78.fixture.v1',nonce:randomBytes(24).toString('hex')}));
+  await mkdir(inside,{recursive:true});await mkdir(outside,{recursive:true});
+  const sentinel=path.join(outside,'sentinel.json');
+  await writeFile(sentinel,bytes,{flag:'wx'});
+  let junction=null;
+  try{return await cb({fixture,inside,outside,sentinel,bytes,setJunction:v=>junction=v});}
+  finally{
+    // Remove the junction *first* so no recursive clean-up can walk outside.
+    if(junction){await unlink(junction);}
+    await rm(fixture,{recursive:true,force:true});
+  }
+}
+
+winTest('Windows: parent junction to outside cannot delete target fixture',async()=>withFixture(async({inside,outside,sentinel,bytes,setJunction})=>{
+  const link=path.join(inside,'escape');
+  await symlink(outside,link,'junction');setJunction(link);
+  assert.throws(()=>deletePinnedRemoteMarker(path.join(link,'sentinel.json'),digest(bytes)),/failed closed/);
+  assert.deepEqual(await readFile(sentinel),bytes);
+}));
+
+winTest('Windows: nested parent junction cannot delete outside target fixture',async()=>withFixture(async({inside,outside,sentinel,bytes,setJunction})=>{
+  const nested=path.join(inside,'a','b');
+  await mkdir(nested,{recursive:true});
+  const link=path.join(nested,'escape');
+  await symlink(outside,link,'junction');setJunction(link);
+  assert.throws(()=>deletePinnedRemoteMarker(path.join(link,'sentinel.json'),digest(bytes)),/failed closed/);
+  assert.deepEqual(await readFile(sentinel),bytes);
+}));
+
+winTest('Windows: ordinary parent path still permits exact-hash disposition',async()=>withFixture(async({inside,bytes})=>{
+  const file=path.join(inside,'normal.json');
+  await writeFile(file,bytes,{flag:'wx'});
+  assert.equal(deletePinnedRemoteMarker(file,digest(bytes)),'REMOVED');
+  await assert.rejects(readFile(file),{code:'ENOENT'});
+  assert.equal(deletePinnedRemoteMarker(file,digest(bytes)),'MISSING');
+}));

package/test/r79-orphan-revocation-reconcile.test.mjs

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash,generateKeyPairSync} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,readdir,writeFile,rm} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {createAuthorityEpochStore} from '../src/authority-continuity-r65.mjs';
+const hash=b=>createHash('sha256').update(b).digest('hex');
+const nonce=c=>c.repeat(64);
+const grant=c=>Buffer.from(JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:'a'.repeat(64),instance_nonce:nonce(c),root_ids:['core'],granted_at_utc:'2026-10-16T00:00:00.000Z'}));
+const bind=old=>({prior_grant_sha256:hash(old),prior_grant_instance_nonce:nonce('a'),predecessor_policy_envelope_sha256:nonce('1'),successor_policy_envelope_sha256:nonce('2'),candidate_manifest_sha256:nonce('3'),continuity_subject_sha256:nonce('4')});
+async function fixture(action,fn){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r79-explicit-recovery-'));
+  try{
+    const runtime=path.join(root,'runtime'),trust=path.join(root,'trust');
+    await mkdir(runtime);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 store=createAuthorityEpochStore({runtimeDir:runtime});
+    const old=grant('a'),next=grant('b');
+    const armed=await store.append({plane:'coding',action:'grant',grantBytes:old,grantInstanceNonce:nonce('a')});
+    let prior=armed;
+    if(action==='transaction_restore')prior=await store.append({plane:'coding',action:'transaction_revoke',grantBytes:old,grantInstanceNonce:nonce('a'),updateId:'r79-explicit',expectedHeadSha256:armed.event_sha256});
+    const headFile=path.join(runtime,'authority-epochs','coding','head.json');
+    const priorHeadBytes=await readFile(headFile);
+    let orphan;
+    if(action==='transaction_restore')orphan=await store.append({plane:'coding',action,grantBytes:next,grantInstanceNonce:nonce('b'),updateId:'r79-explicit',expectedHeadSha256:prior.event_sha256,restoreBinding:bind(old)});
+    else orphan=await store.append({plane:'coding',action,grantBytes:old,grantInstanceNonce:nonce('a'),updateId:action==='transaction_revoke'?'r79-explicit':null,...(action==='transaction_revoke'?{expectedHeadSha256:prior.event_sha256}:{})});
+    await writeFile(headFile,priorHeadBytes);
+    await fn({store,headFile,runtime,old,next,prior,orphan});
+  }finally{await rm(root,{recursive:true,force:true});}
+}
+test('R79 explicit signed orphan transaction revoke re-commits ONLY revocation, never standing grant',()=>fixture('transaction_revoke',async({store,headFile,old,prior,orphan})=>{
+  await assert.rejects(store.readHead({plane:'coding'}),/replay or incomplete write/);
+  assert.equal((await store.verifyGrant({plane:'coding',grantBytes:old,grantInstanceNonce:nonce('a')})).trusted,false);
+  const oldBytes=await readFile(headFile);
+  await assert.rejects(store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:orphan.event_sha256}),/explicit operator confirmation/);
+  assert.deepEqual(await readFile(headFile),oldBytes);
+  const result=await store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:orphan.event_sha256,operatorConfirmed:true});
+  assert.equal(result.status,'REVOKED_ONLY_RECONCILED');assert.equal(result.standing_grant_authorized,false);
+  assert.equal((await store.readHead({plane:'coding'})).event_sha256,orphan.event_sha256);
+  assert.equal((await store.verifyGrant({plane:'coding',grantBytes:old,grantInstanceNonce:nonce('a')})).trusted,false);
+  const user=await store.append({plane:'coding',action:'user_revoke',grantBytes:old,grantInstanceNonce:nonce('a')});
+  assert.equal((await store.readHead({plane:'coding'})).event_sha256,user.event_sha256);
+}));
+test('R79 explicit orphaned user revoke can be reconciled as disarmed without granting',()=>fixture('user_revoke',async({store,old,prior,orphan})=>{
+  const result=await store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:orphan.event_sha256,operatorConfirmed:true});
+  assert.equal(result.action,'user_revoke');
+  assert.equal((await store.verifyGrant({plane:'coding',grantBytes:old,grantInstanceNonce:nonce('a')})).trusted,false);
+}));
+test('R79 orphaned restore is NEVER auto-committed, even with explicit operator confirmation',()=>fixture('transaction_restore',async({store,headFile,prior,orphan,next})=>{
+  const before=await readFile(headFile);
+  await assert.rejects(store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:orphan.event_sha256,operatorConfirmed:true}),/revocation binding invalid/);
+  assert.deepEqual(await readFile(headFile),before);
+  assert.equal((await store.verifyGrant({plane:'coding',grantBytes:next,grantInstanceNonce:nonce('b')})).trusted,false);
+}));
+test('R79 mismatched expected head/orphan identities do not commit an orphan',()=>fixture('transaction_revoke',async({store,headFile,prior,orphan})=>{
+  const before=await readFile(headFile);
+  await assert.rejects(store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:'f'.repeat(64),expectedOrphanSha256:orphan.event_sha256,operatorConfirmed:true}),/previous head mismatch/);
+  await assert.rejects(store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:'f'.repeat(64),operatorConfirmed:true}),/orphan identity mismatch/);
+  assert.deepEqual(await readFile(headFile),before);
+}));
+test('R79 modified signed event bytes are refused and no head is committed',()=>fixture('transaction_revoke',async({store,headFile,runtime,prior,orphan})=>{
+  const before=await readFile(headFile);
+  const file=path.join(runtime,'authority-epochs','coding','events',orphan.event_file);
+  await writeFile(file,'{}');
+  await assert.rejects(store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:orphan.event_sha256,operatorConfirmed:true}),/orphan bytes mismatch/);
+  assert.deepEqual(await readFile(headFile),before);
+}));
+test('R79 competing/orphan extra event cannot be reconciled',()=>fixture('transaction_revoke',async({store,headFile,runtime,prior,orphan})=>{
+  const before=await readFile(headFile);
+  const events=path.join(runtime,'authority-epochs','coding','events');
+  const orphanFile=path.join(events,orphan.event_file);
+  await writeFile(path.join(events,`${String(orphan.seq).padStart(16,'0')}-${'f'.repeat(64)}.json`),await readFile(orphanFile));
+  await assert.rejects(store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:orphan.event_sha256,operatorConfirmed:true}),/exactly one orphan event/);
+  assert.deepEqual(await readFile(headFile),before);
+}));
+
+test('R79 stale PID lock is never unlinked by the new recovery operation',()=>fixture('transaction_revoke',async({store,headFile,runtime,prior,orphan})=>{
+  const before=await readFile(headFile);
+  const lock=path.join(runtime,'authority-epochs','coding','.lock');
+  const content=JSON.stringify({schema:'deadbyte.authority-epoch-lock.r65.v1',pid:2147483647,token:'another-owner',created_at_utc:'2026-10-16T00:00:00Z'});
+  await writeFile(lock,content,{flag:'wx'});
+  await assert.rejects(store.reconcileOrphanedRevocation({plane:'coding',expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:orphan.event_sha256,operatorConfirmed:true}),/mutation locked/);
+  assert.equal(await readFile(lock,'utf8'),content);
+  assert.deepEqual(await readFile(headFile),before);
+}));