deadbyte-mcp 0.15.46 → 0.15.48

package/test/r87-crashed-orphan-revoke-reconcile.test.mjs

@@ -0,0 +1,110 @@
+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,writeFile,readdir,access,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath,pathToFileURL} from 'node:url';
+import {createAuthorityEpochStore} from '../src/authority-continuity-r65.mjs';
+
+const repo=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const exists=file=>access(file).then(()=>true,()=>false);
+const awaitChildExit=(child,timeoutMs)=>new Promise((resolve,reject)=>{
+  if(child.exitCode!==null||child.signalCode!==null)return resolve({code:child.exitCode,signal:child.signalCode});
+  const timer=setTimeout(()=>reject(new Error('R87 child exit timeout')),timeoutMs);
+  child.once('exit',(code,signal)=>{clearTimeout(timer);resolve({code,signal});});
+});
+
+test('R87 Windows: exact signed orphan revoke recovers after owner crash, never restores grant',
+  {skip:process.platform!=='win32',timeout:40000},async()=>{
+    const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r87-crashed-revoke-'));
+    let child;
+    try{
+      const runtimeDir=path.join(root,'runtime'),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 grantInstanceNonce=randomBytes(32).toString('hex');
+      const grantBytes=Buffer.from(JSON.stringify({instance_nonce:grantInstanceNonce}));
+      const store=createAuthorityEpochStore({runtimeDir});
+      const prior=await store.append({plane:'process',action:'grant',grantBytes,grantInstanceNonce});
+      const script=`import {createAuthorityEpochStore} from ${JSON.stringify(pathToFileURL(path.join(repo,'src','authority-continuity-r65.mjs')).href)};
+        const store=createAuthorityEpochStore({runtimeDir:${JSON.stringify(runtimeDir)},
+          onDurabilityStage:async stage=>{if(stage==='event_file_synced'){
+            process.stdout.write('R87_ORPHAN_READY\\n');
+            await new Promise(()=>setInterval(()=>{},1000));
+          }}});
+        await store.append({plane:'process',action:'user_revoke',
+          grantBytes:Buffer.from(${JSON.stringify(grantBytes.toString('base64'))},'base64'),
+          grantInstanceNonce:${JSON.stringify(grantInstanceNonce)}});`;
+      child=spawn(process.execPath,['--input-type=module','-e',script],
+        {env:{...process.env,NODE_TEST_CONTEXT:'child-v8'},windowsHide:true,stdio:['ignore','pipe','ignore']});
+      await new Promise((resolve,reject)=>{
+        let output='';
+        const timer=setTimeout(()=>{child.kill();reject(new Error('R87 orphan-ready child timeout'));},12000);
+        child.once('error',error=>{clearTimeout(timer);reject(error);});
+        child.once('exit',()=>{clearTimeout(timer);reject(new Error('R87 child exited before orphan-ready'));});
+        child.stdout.on('data',chunk=>{output=(output+String(chunk)).slice(-100);if(output.includes('R87_ORPHAN_READY')){
+          clearTimeout(timer);resolve();
+        }});
+      });
+      const dir=path.join(runtimeDir,'authority-epochs','process');
+      const names=await readdir(path.join(dir,'events'));
+      const orphan=names.find(name=>/^0000000000000002-[0-9a-f]{64}\.json$/.test(name));
+      assert.ok(orphan,'one immutable signed second event must remain');
+      const expectedOrphanSha256=orphan.slice(17,81);
+      assert.equal(await exists(path.join(dir,'.lock')),true,'live owner must hold its lock');
+      await assert.rejects(store.reconcileOrphanedRevocation({plane:'process',
+        expectedHeadSha256:prior.event_sha256,expectedOrphanSha256,operatorConfirmed:true}),
+        /native pinned file I\/O failed closed/);
+      assert.equal(await exists(path.join(dir,'.lock')),true,'live-owner lock must not be removed');
+      child.kill('SIGKILL');
+      const outcome=await awaitChildExit(child,12000);
+      assert.notEqual(outcome.code,0,'R87 child must not complete revoke after forced death');
+      assert.equal(await exists(path.join(dir,'.lock')),true,'crash leaves an owner-identity-bearing lock');
+      const before=await store.verifyGrant({plane:'process',grantBytes,grantInstanceNonce});
+      assert.equal(before.trusted,false);
+      assert.match(before.reason,/head replay or incomplete write/);
+      await assert.rejects(store.reconcileOrphanedRevocation({plane:'process',
+        expectedHeadSha256:prior.event_sha256,expectedOrphanSha256:'f'.repeat(64),operatorConfirmed:true}),
+        /orphan identity mismatch/);
+      assert.equal(await exists(path.join(dir,'.lock')),true,
+        'wrong evidence must not reclaim a dead-owner lock before validation');
+      const recoveryScript=`import {createAuthorityEpochStore} from ${JSON.stringify(pathToFileURL(path.join(repo,'src','authority-continuity-r65.mjs')).href)};
+        const store=createAuthorityEpochStore({runtimeDir:${JSON.stringify(runtimeDir)}});
+        try {
+          const result=await store.reconcileOrphanedRevocation({plane:'process',
+            expectedHeadSha256:${JSON.stringify(prior.event_sha256)},
+            expectedOrphanSha256:${JSON.stringify(expectedOrphanSha256)},operatorConfirmed:true});
+          if(result.status!=='REVOKED_ONLY_RECONCILED')throw new Error('unexpected result');
+        } catch(error) { process.stderr.write(String(error.message).slice(0,500)); process.exitCode=2; }`;
+      const recover=()=>new Promise((resolve,reject)=>{
+        const worker=spawn(process.execPath,['--input-type=module','-e',recoveryScript],
+          {windowsHide:true,stdio:['ignore','ignore','pipe']});
+        let stderr='';
+        worker.stderr.on('data',chunk=>{stderr=(stderr+String(chunk)).slice(-1000);});
+        const timer=setTimeout(()=>{worker.kill();reject(new Error('R87 recovery child timeout'));},12000);
+        worker.once('error',error=>{clearTimeout(timer);reject(error);});
+        worker.once('exit',code=>{clearTimeout(timer);resolve({code,stderr});});
+      });
+      const contenders=await Promise.all([recover(),recover()]);
+      assert.equal(contenders.filter(item=>item.code===0).length,1,
+        `exactly one process may publish the recovered head: ${JSON.stringify(contenders)}`);
+      assert.equal(contenders.filter(item=>item.code===2).length,1);
+      assert.equal((await store.verifyGrant({plane:'process',grantBytes,grantInstanceNonce})).trusted,false);
+      assert.equal(await exists(path.join(dir,'.lock')),false);
+      await assert.rejects(store.reconcileOrphanedRevocation({plane:'process',
+        expectedHeadSha256:prior.event_sha256,expectedOrphanSha256,operatorConfirmed:true}));
+      assert.equal((await store.readHead({plane:'process'})).action,'user_revoke');
+      console.log('R87_CRASHED_ORPHAN_REVOKE_SINGLE_WINNER_WITHOUT_GRANT_RESTORE');
+    }finally{
+      try{
+        if(child){
+          if(child.exitCode===null&&child.signalCode===null)child.kill('SIGKILL');
+          await awaitChildExit(child,5000);
+        }
+      }finally{await rm(root,{recursive:true,force:true,maxRetries:8,retryDelay:150});}
+    }
+  });

package/test/r88-native-disposition-failure.test.mjs

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,chmod,access,rm} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {acquireHeldEpochLock} from '../src/epoch-lock-r85.mjs';
+
+const exists=async file=>access(file).then(()=>true,()=>false);
+
+test('Windows denied native disposition retains owned lock and permits explicit retry',
+  {skip:process.platform!=='win32'},async()=>{
+    const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r88-disposition-'));
+    const lock=path.join(root,'epoch.lock');
+    let held;
+    try{
+      held=await acquireHeldEpochLock(lock,Buffer.from('{}'));
+      assert.ok(held,'isolated lock must be acquired');
+      await chmod(lock,0o444);
+      await assert.rejects(held.release(),/epoch native lock disposition failed closed/);
+      assert.equal(await exists(lock),true,'failed disposition must retain the lock');
+      await chmod(lock,0o666);
+      await held.release();
+      held=null;
+      assert.equal(await exists(lock),false,'retry must dispose the exact held lock');
+    }finally{
+      try{
+        if(await exists(lock)){
+          await chmod(lock,0o666);
+          if(held)await held.release();
+        }
+      }finally{
+        await rm(root,{recursive:true,force:true,maxRetries:4,retryDelay:100});
+      }
+    }
+  });

package/test/r89-privileged-install-boundary.test.mjs

@@ -0,0 +1,123 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {access,mkdtemp,writeFile,rm} from 'node:fs/promises';
+import os from 'node:os';
+import {
+  requiredAclPathChain,evaluatePrivilegedAclSnapshot,inspectTrustedInstallation,privilegedEpochInstallFiles
+} from '../src/privileged-install-trust-r89.mjs';
+
+const sys='S-1-5-18',admin='S-1-5-32-544',users='S-1-5-11';
+const leaf='C:\\Program Files\\Deadbyte\\bin\\deadbyte-epoch-lock-r85.node';
+const js='C:\\Program Files\\Deadbyte\\src\\epoch-lock-r85.mjs';
+const files=[leaf,js];
+function protectedFixture(){
+  return requiredAclPathChain(files).map(p=>({path:p,owner:admin,
+    directory:![leaf.toLowerCase(),js.toLowerCase()].includes(p.toLowerCase()),reparse:false,
+    aces:[{sid:sys,type:'Allow',mask:0x001f01ff,inheritance:0,propagation:0},
+      {sid:users,type:'Allow',mask:0x001200a9,inheritance:0,propagation:0}]}));
+}
+function mutate(records,predicate,fn){
+  const result=structuredClone(records);
+  const rec=result.find(predicate);
+  assert.ok(rec);
+  fn(rec);
+  return result;
+}
+test('R89 protected installation ACL snapshot grants only OS trusted writers',()=>{
+  assert.deepEqual(evaluatePrivilegedAclSnapshot(protectedFixture(),files),
+    {trusted:true,reason:'PROTECTED_INSTALLATION_ACL_SNAPSHOT'});
+});
+test('R89 Authenticated Users Modify on addon is rejected',()=>{
+  const records=mutate(protectedFixture(),r=>r.path.toLowerCase()===leaf.toLowerCase(),
+    r=>r.aces.push({sid:users,type:'Allow',mask:0x000301bf,inheritance:0,propagation:0}));
+  const outcome=evaluatePrivilegedAclSnapshot(records,files);
+  assert.equal(outcome.trusted,false);assert.equal(outcome.reason,'UNTRUSTED_WRITE_ACE');
+});
+test('R89 Authenticated Users delete-child on any ancestor is rejected',()=>{
+  const records=mutate(protectedFixture(),r=>r.path.toLowerCase()==='c:\\program files',
+    r=>r.aces.push({sid:users,type:'Allow',mask:0x40,inheritance:0,propagation:0}));
+  assert.equal(evaluatePrivilegedAclSnapshot(records,files).reason,'UNTRUSTED_WRITE_ACE');
+});
+test('R89 inherited CreateFiles alone on root is not mistaken for replacing existing child',()=>{
+  const records=mutate(protectedFixture(),r=>r.path.toLowerCase()==='c:\\',
+    r=>r.aces.push({sid:users,type:'Allow',mask:0x02,inheritance:0,propagation:0}));
+  assert.equal(evaluatePrivilegedAclSnapshot(records,files).trusted,true);
+});
+test('R89 unsigned/untrusted owner cannot assert immutable installation',()=>{
+  const records=mutate(protectedFixture(),r=>r.path.toLowerCase()===leaf.toLowerCase(),
+    r=>r.owner=users);
+  assert.equal(evaluatePrivilegedAclSnapshot(records,files).reason,'UNTRUSTED_OWNER_OR_REPARSE');
+});
+test('R89 reparse ancestor, incomplete, duplicate, unknown ACL fail closed',()=>{
+  const ok=protectedFixture();
+  const s=mutate(ok,r=>r.path.toLowerCase()==='c:\\program files',r=>r.reparse=true);
+  assert.equal(evaluatePrivilegedAclSnapshot(s,files).trusted,false);
+  assert.equal(evaluatePrivilegedAclSnapshot(ok.slice(1),files).reason,'INCOMPLETE_ACL_SNAPSHOT');
+  const dup=[...ok.slice(1),ok[1]];
+  assert.equal(evaluatePrivilegedAclSnapshot(dup,files).reason,'DUPLICATE_ACL_PATH');
+  const unknown=mutate(ok,r=>r.path.toLowerCase()===leaf.toLowerCase(),
+    r=>r.aces.push({sid:users,type:'Allow',mask:-1,inheritance:0,propagation:0}));
+  assert.equal(evaluatePrivilegedAclSnapshot(unknown,files).reason,'UNKNOWN_ACL_RULE');
+});
+test('R89 relative and UNC paths cannot supply a trusted native image',()=>{
+  assert.throws(()=>requiredAclPathChain(['.\\bin\\addon.node']));
+  assert.throws(()=>requiredAclPathChain(['\\\\server\\share\\addon.node']));
+});
+
+test('R99 Windows development candidate denies native acquire unless installation is protected',
+  {skip:process.platform!=='win32'||process.arch!=='x64'},async()=>{
+    const repo=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+    const target=privilegedEpochInstallFiles(repo,process.execPath);
+    let protectedSlot=false;
+    try {
+      const decision=await inspectTrustedInstallation(target);
+      assert.equal(decision.trusted,true);
+      protectedSlot=true;
+    } catch(error) {
+      assert.equal(error.code,'EPOCH_NATIVE_SLOT_UNTRUSTED',`unknown ACL error: ${error.message}`);
+    }
+    const {createAuthorityEpochStore}=await import('../src/authority-continuity-r65.mjs');
+    const {acquireHeldEpochLock}=await import('../src/epoch-lock-r85.mjs');
+    const fixture=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r99-epoch-test-'));
+    try {
+      const lock=path.join(fixture,'.lock');
+      if(!protectedSlot) {
+        await assert.rejects(acquireHeldEpochLock(lock,Buffer.from('{}')),error=>{
+          assert.equal(error.code,'EPOCH_NATIVE_SLOT_UNTRUSTED');return true;
+        });
+        await assert.rejects(access(lock),{code:'ENOENT'});
+        console.log('R99_INSECURE_WIN32_INSTALL_REFUSED');
+      } else {
+        const held=await acquireHeldEpochLock(lock,Buffer.from('{}'));
+        assert.ok(held,'protected addon must acquire native file handle');
+        await held.release();
+        await assert.rejects(access(lock),{code:'ENOENT'});
+        console.log('R99_PROTECTED_WIN32_INSTALL_HELD_LOCK_RELEASE_PASS');
+      }
+      const untrusted=path.join(fixture,'untrusted-addon.node');
+      await writeFile(untrusted,'not-an-executable');
+      await assert.rejects(inspectTrustedInstallation([untrusted]),error=>{
+        assert.equal(error.code,'EPOCH_NATIVE_SLOT_UNTRUSTED');return true;
+      });
+    } finally {await rm(fixture,{recursive:true,force:true,maxRetries:8,retryDelay:120});}
+  });
+
+// R90: unexpanded Windows generic ACE bits must not accidentally pass R89's
+// file-specific write mask. Old R89 synthetic snapshots did not cover these.
+test('R90 unexpanded GENERIC_WRITE and GENERIC_ALL deny a privileged native image',()=>{
+  for(const [kind,mask] of [['GENERIC_WRITE',0x40000000],['GENERIC_ALL',0x10000000],
+                             ['MAXIMUM_ALLOWED',0x02000000]]){
+    const records=mutate(protectedFixture(),r=>r.path.toLowerCase()===leaf.toLowerCase(),
+      r=>r.aces.push({sid:users,type:'Allow',mask,inheritance:0,propagation:0}));
+    const d=evaluatePrivilegedAclSnapshot(records,files);
+    assert.equal(d.trusted,false,kind);
+    assert.equal(d.reason,'UNTRUSTED_WRITE_ACE',kind);
+  }
+});
+test('R90 generic read and execute alone do not grant write',()=>{
+  const records=mutate(protectedFixture(),r=>r.path.toLowerCase()===leaf.toLowerCase(),
+    r=>r.aces.push({sid:users,type:'Allow',mask:(0x80000000|0x20000000)>>>0,inheritance:0,propagation:0}));
+  assert.equal(evaluatePrivilegedAclSnapshot(records,files).trusted,true);
+});

package/test/r92-acl-ace-applicability.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {evaluatePrivilegedAclSnapshot,requiredAclPathChain} from '../src/privileged-install-trust-r89.mjs';
+
+const admins='S-1-5-32-544', system='S-1-5-18', users='S-1-5-11', creatorOwner='S-1-3-0';
+const leaf='C:\\Program Files\\Deadbyte\\bin\\deadbyte-epoch-lock-r85.node';
+const files=[leaf];
+const key=s=>s.toLowerCase();
+function snapshot(){return requiredAclPathChain(files).map(p=>({
+  path:p,owner:admins,reparse:false,directory:key(p)!==key(leaf),
+  aces:[{sid:system,type:'Allow',mask:0x001f01ff,inheritance:0,propagation:0},
+    {sid:users,type:'Allow',mask:0x001200a9,inheritance:0,propagation:0}]
+}));}
+function add(path,ace){const a=snapshot();const entry=a.find(x=>key(x.path)===key(path));assert.ok(entry);entry.aces.push(ace);return a;}
+const ownerAce=(inheritance,propagation)=>({sid:creatorOwner,type:'Allow',mask:0x10000000,inheritance,propagation});
+const userAce=(inheritance,propagation)=>({sid:users,type:'Allow',mask:0xe0010000,inheritance,propagation});
+
+test('R92: scoped, inheritance-only root Authenticated Users cannot mutate root itself',()=>{
+  assert.equal(evaluatePrivilegedAclSnapshot(add('C:\\',userAce(3,2)),files).trusted,true);
+});
+test('R92: CREATOR OWNER inheritance-only on Program Files is not effective on this directory',()=>{
+  assert.equal(evaluatePrivilegedAclSnapshot(add('C:\\Program Files',ownerAce(3,2)),files).trusted,true);
+  console.log('R92_INHERIT_ONLY_SCOPE_NEGATIVE_CONTROL_PASS');
+});
+test('R92: effective Authenticated Users generic write on root remains blocked',()=>{
+  const d=evaluatePrivilegedAclSnapshot(add('C:\\',userAce(3,0)),files);
+  assert.equal(d.trusted,false);assert.equal(d.reason,'UNTRUSTED_WRITE_ACE');
+});
+test('R92: CREATOR OWNER effective full-control on Program Files is not whitelisted',()=>{
+  const d=evaluatePrivilegedAclSnapshot(add('C:\\Program Files',ownerAce(3,0)),files);
+  assert.equal(d.reason,'UNTRUSTED_WRITE_ACE');
+});
+test('R92: missing ACE scope fails closed',()=>{
+  const a=add('C:\\Program Files',ownerAce(3,2));delete a[0].aces[0].propagation;
+  assert.equal(evaluatePrivilegedAclSnapshot(a,files).reason,'UNKNOWN_ACL_SCOPE');
+});
+test('R92: impossible inherit-only scope fails closed',()=>{
+  assert.equal(evaluatePrivilegedAclSnapshot(add('C:\\Program Files',ownerAce(0,2)),files).reason,'UNKNOWN_ACL_SCOPE');
+});
+test('R92: file-leaf inheritance-only ACE cannot become an unchecked write grant',()=>{
+  assert.equal(evaluatePrivilegedAclSnapshot(add(leaf,ownerAce(3,2)),files).reason,'UNKNOWN_ACL_SCOPE');
+});
+test('R92: unrecognized propagation bits fail closed',()=>{
+  assert.equal(evaluatePrivilegedAclSnapshot(add('C:\\Program Files',ownerAce(3,8)),files).reason,'UNKNOWN_ACL_SCOPE');
+});

package/test/r94-win32-propagation-enum.test.mjs

@@ -0,0 +1,51 @@
+// R94 exact .NET System.Security.AccessControl.PropagationFlags numerical oracle.
+// Critically: NoPropagateInherit=1; InheritOnly=2 (R92 interchanged them).
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {evaluatePrivilegedAclSnapshot,requiredAclPathChain} from '../src/privileged-install-trust-r89.mjs';
+const admins='S-1-5-32-544', system='S-1-5-18', users='S-1-5-11', creator='S-1-3-0';
+const file='C:\\Program Files\\Deadbyte\\bin\\deadbyte-epoch-lock-r85.node';
+const files=[file];
+const base=()=>requiredAclPathChain(files).map(p=>({path:p,owner:admins,directory:p.toLowerCase()!==file.toLowerCase(),reparse:false,aces:[
+ {sid:system,type:'Allow',mask:0x001f01ff,inheritance:0,propagation:0},
+ {sid:users,type:'Allow',mask:0x001200a9,inheritance:0,propagation:0}
+]}));
+function withAce(where,ace){const s=base(),r=s.find(v=>v.path.toLowerCase()===where.toLowerCase());assert.ok(r);r.aces.push(ace);return s;}
+const user=(mask,propagation,inheritance=3)=>({sid:users,type:'Allow',mask,propagation,inheritance});
+const creatorOwner=(propagation)=>({sid:creator,type:'Allow',mask:0x10000000,propagation,inheritance:3});
+const judge=(records)=>evaluatePrivilegedAclSnapshot(records,files);
+
+test('R94 Windows .NET enum: InheritOnly=2 root write grant is NOT effective on root',()=>{
+ const s=withAce('C:\\',user(0xe0010000,2));
+ assert.deepEqual(judge(s),{trusted:true,reason:'PROTECTED_INSTALLATION_ACL_SNAPSHOT'});
+});
+test('R94 Windows .NET enum: NoPropagateInherit=1 does NOT suppress effective root write',()=>{
+ const s=withAce('C:\\',user(0xe0010000,1));
+ assert.equal(judge(s).reason,'UNTRUSTED_WRITE_ACE');
+});
+test('R94 exact R93 C drive: create-subdirectory on root + inheritance-only Authenticated Users deny-none',()=>{
+ const s=withAce('C:\\',user(4,0,0));
+ s.find(r=>r.path.toLowerCase()==='c:\\').aces.push(user(0xe0010000,2));
+ assert.equal(judge(s).trusted,true);
+ console.log('R94_R93_ROOT_ACE_FALSE_POSITIVE_FIXED');
+});
+test('R94 exact R93 Program Files: inheritance-only CREATOR OWNER does not grant effective modify',()=>{
+ const s=withAce('C:\\Program Files',creatorOwner(2));
+ assert.equal(judge(s).trusted,true);
+});
+test('R94 effective CREATOR OWNER GENERIC_ALL on protected directory must still be rejected',()=>{
+ const s=withAce('C:\\Program Files',creatorOwner(1));
+ assert.equal(judge(s).reason,'UNTRUSTED_WRITE_ACE');
+});
+test('R94 unscoped effective Authenticated Users delete-child on protected parent rejects',()=>{
+ const s=withAce('C:\\Program Files',user(0x40,0,0));
+ assert.equal(judge(s).reason,'UNTRUSTED_WRITE_ACE');
+});
+test('R94 malformed leaf inherit-only ACE remains fail-closed',()=>{
+ const s=withAce(file,user(0x40000000,2));
+ assert.equal(judge(s).reason,'UNKNOWN_ACL_SCOPE');
+});
+test('R94 combined InheritOnly|NoPropagateInherit=3 never applies on the inspected directory',()=>{
+ const s=withAce('C:\\Program Files',creatorOwner(3));
+ assert.equal(judge(s).trusted,true);
+});

package/test/r99-privileged-import-closure.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import {readFile} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+import {privilegedEpochInstallFiles} from '../src/privileged-install-trust-r89.mjs';
+import {windowsPowerShellEnvironment as isolatedEnvironment} from '../src/windows-powershell-environment.mjs';
+import {windowsPowerShellEnvironment as updaterEnvironment} from '../src/runtime-update.mjs';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+
+test('R99 privileged installation inventory closes over security-critical local imports',async()=>{
+  const inventory=new Set(privilegedEpochInstallFiles(root,process.execPath).map(file=>path.resolve(file).toLowerCase()));
+  const frontier=[
+    path.join(root,'src','epoch-lock-r85.mjs'),
+    path.join(root,'src','authority-continuity-r65.mjs'),
+    path.join(root,'src','foreground-process-identity.mjs'),
+    path.join(root,'src','foreground-marker-cas-win32.mjs')
+  ];
+  const seen=new Set();
+  while(frontier.length){
+    const file=frontier.pop();
+    const identity=path.resolve(file).toLowerCase();
+    if(seen.has(identity))continue;
+    seen.add(identity);
+    assert.ok(inventory.has(identity),`privileged dependency omitted: ${path.relative(root,file)}`);
+    const source=await readFile(file,'utf8');
+    for(const match of source.matchAll(/\bfrom\s*['"](\.\.?\/[^'"]+)['"]/g)){
+      frontier.push(path.resolve(path.dirname(file),match[1]));
+    }
+    for(const match of source.matchAll(/\bimport\s*\(\s*['"](\.\.?\/[^'"]+)['"]\s*\)/g)){
+      frontier.push(path.resolve(path.dirname(file),match[1]));
+    }
+    for(const match of source.matchAll(/\bimport\s*['"](\.\.?\/[^'"]+)['"]/g)){
+      frontier.push(path.resolve(path.dirname(file),match[1]));
+    }
+  }
+});
+
+test('R99 isolated PowerShell environment preserves existing child semantics',()=>{
+  const base={SystemRoot:'C:\\Windows',USERPROFILE:'C:\\Users\\fixture',
+    ProgramFiles:'C:\\Program Files',PSModulePath:'C:\\CustomModules;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\Modules',
+    DEADBYTE_STATE_ROOT:'D:\\isolated-state'};
+  assert.deepEqual(isolatedEnvironment(base),updaterEnvironment(base));
+});

package/test/remote-session-cli.test.mjs

@@ -33,7 +33,7 @@ async function fixture({failCommand='',statusOnline=false}={}){
   const spawnedPid=path.join(dir,'spawned.pid');
   await mkdir(bin,{recursive:true});
   const launcher=path.join(bin,'DEADBYTE-MCP.ps1');
-  const ps1=`param([string]$Command)\n$ErrorActionPreference='Stop'\nfor($i=0;$i -lt 20;$i++){ try { [IO.File]::AppendAllText($env:DEADBYTE_REMOTE_TEST_TRACE,(\"$Command\" + [Environment]::NewLine),[Text.Encoding]::UTF8); break } catch { if($i -eq 19){ throw }; Start-Sleep -Milliseconds 10 } }\nif ($env:DEADBYTE_REMOTE_TEST_FAIL -and $Command -eq $env:DEADBYTE_REMOTE_TEST_FAIL) { $runtime=Join-Path $env:DEADBYTE_STATE_ROOT 'runtime'; New-Item -ItemType Directory -Path $runtime -Force | Out-Null; $failure=@{ schema='deadbyte.controller-start-failure.v1'; command=$Command; failed_at_utc='2026-09-26T00:00:00.000Z'; message='fixture controller evidence detail' } | ConvertTo-Json -Compress; [IO.File]::WriteAllText((Join-Path $runtime 'controller-start-failure.json'),$failure,[Text.Encoding]::UTF8); Write-Error \"forced $Command failure\"; exit 9 }\nswitch ($Command) {\n  'start' { if ($env:DEADBYTE_REMOTE_TEST_SPAWN_CHILD -eq '1') { $node=(Get-Command node.exe).Source; $spawned=Start-Process -FilePath $node -ArgumentList @('-e','setTimeout(()=>process.exit(0),10000)') -PassThru -WindowStyle Hidden -RedirectStandardOutput $env:DEADBYTE_REMOTE_TEST_SPAWN_STDOUT -RedirectStandardError $env:DEADBYTE_REMOTE_TEST_SPAWN_STDERR; if ($env:DEADBYTE_REMOTE_TEST_SPAWN_PID) { [IO.File]::WriteAllText($env:DEADBYTE_REMOTE_TEST_SPAWN_PID,[string]$spawned.Id,[Text.Encoding]::UTF8) } }; if ($env:DEADBYTE_REMOTE_TEST_STARTED) { [IO.File]::WriteAllText($env:DEADBYTE_REMOTE_TEST_STARTED,'1',[Text.Encoding]::UTF8) }; Write-Host 'DEADBYTE MCP = ONLINE' }\n  'status' { if ($env:DEADBYTE_REMOTE_TEST_STATUS_ONLINE -eq '1' -or ($env:DEADBYTE_REMOTE_TEST_STARTED -and (Test-Path -LiteralPath $env:DEADBYTE_REMOTE_TEST_STARTED))) { Write-Host 'DEADBYTE MCP = ONLINE'; Write-Host 'Bridge PID   : 1001 [verified]'; Write-Host 'Cloud PID    : 1002 [verified]'; Write-Host 'Local ready  : True'; Write-Host 'Loop supervisor: RUNNING [verified]' } else { Write-Host 'DEADBYTE MCP = OFFLINE' } }\n  'processstatus' { Write-Host 'Process plane  : ARMED [standing-grant]' }\n  'codingstatus' { Write-Host 'Coding plane  : ARMED [standing-grant]' }\n  'autonomousstatus' { Write-Host 'Autonomous     : ARMED [standing-grant]' }\n  'desktopstatus' { Write-Host 'Desktop plane : DISARMED [disarmed]' }\n  'hoststatus' { Write-Host 'Host plane    : DISARMED [disarmed]' }\n  'park' { if ($env:DEADBYTE_REMOTE_TEST_STARTED) { Remove-Item -LiteralPath $env:DEADBYTE_REMOTE_TEST_STARTED -Force -ErrorAction SilentlyContinue }; Write-Host 'DEADBYTE MCP = PARKED' }\n  default { Write-Host \"$Command OK\" }\n}\nexit 0\n`;
+  const ps1=`param([string]$Command)\n$ErrorActionPreference='Stop'\nfor($i=0;$i -lt 20;$i++){ try { [IO.File]::AppendAllText($env:DEADBYTE_REMOTE_TEST_TRACE,(\"$Command\" + [Environment]::NewLine),[Text.Encoding]::UTF8); break } catch { if($i -eq 19){ throw }; Start-Sleep -Milliseconds 10 } }\nif ($env:DEADBYTE_REMOTE_TEST_FAIL -and $Command -in ($env:DEADBYTE_REMOTE_TEST_FAIL -split ',')) { $runtime=Join-Path $env:DEADBYTE_STATE_ROOT 'runtime'; New-Item -ItemType Directory -Path $runtime -Force | Out-Null; $failure=@{ schema='deadbyte.controller-start-failure.v1'; command=$Command; failed_at_utc='2026-09-26T00:00:00.000Z'; message='fixture controller evidence detail' } | ConvertTo-Json -Compress; [IO.File]::WriteAllText((Join-Path $runtime 'controller-start-failure.json'),$failure,[Text.Encoding]::UTF8); Write-Error \"forced $Command failure\"; exit 9 }\nswitch ($Command) {\n  'start' { if ($env:DEADBYTE_REMOTE_TEST_SPAWN_CHILD -eq '1') { $node=(Get-Command node.exe).Source; $spawned=Start-Process -FilePath $node -ArgumentList @('-e','setTimeout(()=>process.exit(0),10000)') -PassThru -WindowStyle Hidden -RedirectStandardOutput $env:DEADBYTE_REMOTE_TEST_SPAWN_STDOUT -RedirectStandardError $env:DEADBYTE_REMOTE_TEST_SPAWN_STDERR; if ($env:DEADBYTE_REMOTE_TEST_SPAWN_PID) { [IO.File]::WriteAllText($env:DEADBYTE_REMOTE_TEST_SPAWN_PID,[string]$spawned.Id,[Text.Encoding]::UTF8) } }; if ($env:DEADBYTE_REMOTE_TEST_STARTED) { [IO.File]::WriteAllText($env:DEADBYTE_REMOTE_TEST_STARTED,'1',[Text.Encoding]::UTF8) }; Write-Host 'DEADBYTE MCP = ONLINE' }\n  'status' { if ($env:DEADBYTE_REMOTE_TEST_STATUS_ONLINE -eq '1' -or ($env:DEADBYTE_REMOTE_TEST_STARTED -and (Test-Path -LiteralPath $env:DEADBYTE_REMOTE_TEST_STARTED))) { Write-Host 'DEADBYTE MCP = ONLINE'; Write-Host 'Bridge PID   : 1001 [verified]'; Write-Host 'Cloud PID    : 1002 [verified]'; Write-Host 'Local ready  : True'; Write-Host 'Loop supervisor: RUNNING [verified]' } else { Write-Host 'DEADBYTE MCP = OFFLINE' } }\n  'processstatus' { Write-Host 'Process plane  : ARMED [standing-grant]' }\n  'codingstatus' { Write-Host 'Coding plane  : ARMED [standing-grant]' }\n  'autonomousstatus' { Write-Host 'Autonomous     : ARMED [standing-grant]' }\n  'desktopstatus' { Write-Host 'Desktop plane : DISARMED [disarmed]' }\n  'hoststatus' { Write-Host 'Host plane    : DISARMED [disarmed]' }\n  'park' { if ($env:DEADBYTE_REMOTE_TEST_STARTED) { Remove-Item -LiteralPath $env:DEADBYTE_REMOTE_TEST_STARTED -Force -ErrorAction SilentlyContinue }; Write-Host 'DEADBYTE MCP = PARKED' }\n  default { Write-Host \"$Command OK\" }\n}\nexit 0\n`;
   const structured=`function PlaneArmed([string]$name,[bool]$default) { $base=Join-Path $env:DEADBYTE_STATE_ROOT ('runtime\\' + $name); if (Test-Path -LiteralPath ($base + '.disarmed')) { return $false }; if (Test-Path -LiteralPath ($base + '.armed')) { return $true }; return $default }
 if ($Command -eq 'status' -and $Json) { $names=@('process','coding','autonomous','desktop','host'); $authority=@{}; foreach($name in $names){ $initial=($name -in @('process','coding','autonomous')) -or (($name -eq 'host') -and ($env:DEADBYTE_REMOTE_TEST_HOST_ARMED -eq '1')) -or (($name -eq 'desktop') -and ($env:DEADBYTE_REMOTE_TEST_DESKTOP_ARMED -eq '1')); $armed=PlaneArmed $name $initial; if($name -eq 'host' -and (($env:DEADBYTE_REMOTE_TEST_JSON_HOST_LIE_ALWAYS -eq '1') -or (($env:DEADBYTE_REMOTE_TEST_JSON_HOST_LIE -eq '1') -and (Test-Path -LiteralPath (Join-Path $env:DEADBYTE_STATE_ROOT 'runtime\\host.disarm-attempt'))))){$armed=$false}; $authority[$name]=@{ configured=$true; armed=$armed; reason=$(if($armed){'standing-grant'}else{'disarmed'}) } }; @{schema='deadbyte.controller-observation.v1';state='ONLINE';local_ready=$true;core_root='fixture';bridge=@{alive=$true;reason='verified'};core=@{alive=$true;reason='verified'};cloud=@{alive=$true;reason='verified'};supervisor=@{running=$true};authority=$authority} | ConvertTo-Json -Depth 5 -Compress; exit 0 }
 if ($Command -eq 'machinetest' -and $env:DEADBYTE_REMOTE_PROBE_MODE) { $hostArmed=PlaneArmed 'host' ($env:DEADBYTE_REMOTE_TEST_HOST_ARMED -eq '1'); $desktopArmed=PlaneArmed 'desktop' ($env:DEADBYTE_REMOTE_TEST_DESKTOP_ARMED -eq '1'); $wantHost=$env:DEADBYTE_REMOTE_PROBE_MODE -in @('host','full'); $wantDesktop=$env:DEADBYTE_REMOTE_PROBE_MODE -in @('desktop','full'); if($hostArmed -ne $wantHost -or $desktopArmed -ne $wantDesktop){ Write-Error 'remote enforcement probe mismatch'; exit 9 } }
@@ -559,7 +559,7 @@ winTest('bare remote rolls back authority and parks if one plane fails to arm',a
   }finally{await safeRm(fx.dir);}
 });
 
-winTest('bare remote recovers a stale crashed session before arming a new one',async()=>{
+winTest('bare remote retains an owner-unverified stale marker without starting or revoking',async()=>{
   const fx=await fixture();
   let child=null;
   try{
@@ -568,21 +568,39 @@ winTest('bare remote recovers a stale crashed session before arming a new one',a
     await writeFile(path.join(runtime,'remote-session.json'),JSON.stringify({schema:'deadbyte.remote-session.v1',pid:2147483000,started_at_utc:'2026-01-01T00:00:00.000Z'}),'utf8');
     child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
     const output=await collect(child);
-    const ready=await waitFor(fx.trace,commands=>commands.length>=10&&commands[9]==='start');
-    assert.deepEqual(ready.slice(0,8),['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','status','machinetest','park']);
-    assert.equal(ready[8],'status');
-    assert.equal(ready[9],'start');
-    assert.match(output.stdout,/\[RECOVERY\] Stale remote session pid=2147483000; revoking authority before restart\./);
-    child.stdin.end();
     const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined);
-    assert.equal(ended.code,0,output.stderr);
+    assert.notEqual(ended.code,0);
+    assert.match(output.stderr,/ownership unverified.*marker retained/i);
+    assert.deepEqual(await traceCommands(fx.trace),[]);
+    assert.equal(JSON.parse(await readFile(path.join(runtime,'remote-session.json'),'utf8')).pid,2147483000);
   }finally{
     if(child?.exitCode===null) child.kill();
     await safeRm(fx.dir);
   }
 });
 
+winTest('PID reuse cannot authorize removal of a marker with a different process identity',async()=>{
+  const fx=await fixture();
+  try{
+    const runtime=path.join(fx.state,'runtime');
+    await mkdir(runtime,{recursive:true});
+    const marker={schema:'deadbyte.remote-session.v2',owner_pid:process.pid,guardian_pid:0,
+      session_nonce:'f'.repeat(64),owner_identity:{schema:'deadbyte.foreground-process.v1',pid:process.pid,
+        parent_pid:0,creation_utc:'2026-01-01T00:00:00Z',executable_path:process.execPath,
+        command_line_sha256:'a'.repeat(64)}};
+    await writeFile(path.join(runtime,'remote-session.json'),JSON.stringify(marker),'utf8');
+    const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const ended=await boundedCompletion(output.closed);
+    assert.equal(ended.timeout,undefined);
+    assert.notEqual(ended.code,0);
+    assert.match(output.stderr,/owner identity.*marker retained/i);
+    assert.deepEqual(await traceCommands(fx.trace),[]);
+    assert.equal(JSON.parse(await readFile(path.join(runtime,'remote-session.json'),'utf8')).session_nonce,marker.session_nonce);
+  }finally{await safeRm(fx.dir);}
+});
+
 winTest('remote warning lines use deterministic ASCII fallback on piped Windows output',async()=>{
   const fx=await fixture();
   let child=null;
@@ -596,6 +614,9 @@ winTest('remote warning lines use deterministic ASCII fallback on piped Windows
     const ended=await boundedCompletion(output.closed);
     assert.equal(ended.timeout,undefined,'remote session did not exit after warning fixture');
     assert.match(output.stderr,/^\[WARN\] remote session marker cleanup:/m);
+    assert.notEqual(ended.code,0,'unverified ownership marker must not report clean success');
+    assert.match(output.stderr,/ownership marker retained/i);
+    assert.equal(await readFile(markerPath,'utf8'),'{invalid-json\n');
     assert.doesNotMatch(output.stderr,/\p{Extended_Pictographic}/u);
   }finally{
     if(child?.exitCode===null) child.kill();
@@ -603,6 +624,29 @@ winTest('remote warning lines use deterministic ASCII fallback on piped Windows
   }
 });
 
+winTest('remote cleanup never removes a marker with changed ownership identity',async()=>{
+  const fx=await fixture();
+  let child=null;
+  try{
+    child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['pipe','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    await waitFor(fx.trace,commands=>commands.filter(x=>x==='status').length>=4,{timeoutMs:fixtureTimeoutMs});
+    const markerPath=path.join(fx.state,'runtime','remote-session.json');
+    const marker=JSON.parse(await readFile(markerPath,'utf8'));
+    marker.session_nonce='f'.repeat(64);
+    await writeFile(markerPath,JSON.stringify(marker)+'\n','utf8');
+    child.stdin.end();
+    const ended=await boundedCompletion(output.closed);
+    assert.equal(ended.timeout,undefined);
+    assert.notEqual(ended.code,0);
+    assert.match(output.stderr,/ownership marker changed or missing/);
+    assert.equal(JSON.parse(await readFile(markerPath,'utf8')).session_nonce,'f'.repeat(64));
+  }finally{
+    if(child?.exitCode===null)child.kill();
+    await safeRm(fx.dir);
+  }
+});
+
 winTest('R58 concurrent cold remote claims have one winner and no loser cleanup',async()=>{
   const fx=await fixture({statusOnline:true});const children=[],outputs=[];
   try{
@@ -726,6 +770,22 @@ winTest('bare remote surfaces bounded controller-start-failure evidence instead
   }finally{await safeRm(fx.dir);}
 });
 
+winTest('failed startup retains primary and cleanup failure plus ownership marker',async()=>{
+  const fx=await fixture({failCommand:'start,disarmautonomous'});
+  try{
+    const child=spawn(process.execPath,[cliPath,'remote'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
+    const output=await collect(child);
+    const ended=await boundedCompletion(output.closed);
+    assert.equal(ended.timeout,undefined,'failed startup did not terminate');
+    assert.notEqual(ended.code,0);
+    assert.match(output.stderr,/remote activation failed/i);
+    assert.match(output.stderr,/controller-start-failure/i);
+    assert.match(output.stderr,/cleanup failed.*disarmautonomous/i);
+    const retained=await readFile(path.join(fx.state,'runtime','remote-session.json'),'utf8').then(()=>true,()=>false);
+    assert.equal(retained,true);
+  }finally{await safeRm(fx.dir);}
+});
+
 
 winTest('remote --trace --filter selects presentation without dropping journaled events',async()=>{
   const fx=await fixture();