deadbyte-mcp 0.15.46 → 0.15.47

package/scripts/npm-prepublish-contract-r74.mjs

@@ -0,0 +1,113 @@
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import {readFile, lstat} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
+
+export async function verifyR74PrepublishContract({rootPath = root} = {}) {
+  const result = {
+    schema: 'deadbyte.r74-prepublish-contract.v1',
+    valid: false,
+    checks: {},
+    identities: {}
+  };
+
+  // 1. Version & Train Identity
+  const pkg = JSON.parse(await readFile(path.join(rootPath, 'package.json'), 'utf8'));
+  const release = JSON.parse(await readFile(path.join(rootPath, 'RELEASE.json'), 'utf8'));
+
+  result.identities.package_name = pkg.name;
+  result.identities.package_version = pkg.version;
+  result.identities.target_train = 'R74';
+  result.identities.published_source_predecessor = '0.15.46';
+  result.identities.runtime_predecessor = release?.parent?.version ?? '0.15.45';
+
+  // Published source predecessor (0.15.46) and runtime predecessor (0.15.45) must be distinct
+  const predecessorsDistinct = result.identities.published_source_predecessor !== result.identities.runtime_predecessor;
+  result.checks.predecessors_distinct = predecessorsDistinct;
+  if (!predecessorsDistinct) {
+    throw new Error('Prepublish contract failed: published source and runtime predecessor must be distinct');
+  }
+
+  // 2. Native binary hash pins
+  const nativePins = [
+    {
+      doc: 'docs/R74-KERNEL-LOCK-BINARY.json',
+      exe: 'bin/deadbyte-kernel-lock-r74.exe'
+    },
+    {
+      doc: 'docs/R67-NATIVE-INSPECT-BINARY.json',
+      exe: 'bin/deadbyte-native-inspect-r67.exe'
+    }
+  ];
+
+  result.checks.native_hashes = {};
+  for (const pin of nativePins) {
+    const meta = JSON.parse(await readFile(path.join(rootPath, pin.doc), 'utf8'));
+    const exeFullPath = path.join(rootPath, pin.exe);
+    const exeBytes = await readFile(exeFullPath);
+    const exeHash = sha256Bytes(exeBytes);
+    const matches = exeHash === meta.sha256;
+    result.checks.native_hashes[pin.exe] = { pinned: meta.sha256, actual: exeHash, matches };
+    if (!matches) {
+      throw new Error(`Prepublish contract failed: native binary ${pin.exe} hash mismatch`);
+    }
+  }
+
+  // 3. Working tree manifest verification
+  const manifestPath = path.join(rootPath, 'MANIFEST.SHA256');
+  const manifestBytes = await readFile(manifestPath);
+  result.identities.manifest_sha256 = sha256Bytes(manifestBytes);
+  result.checks.manifest_exists = true;
+
+  const manifestVerifyResult = spawnSync(process.execPath, [path.join(rootPath, 'scripts', 'release-manifest.mjs'), 'verify'], {
+    cwd: rootPath,
+    encoding: 'utf8',
+    timeout: 60000,
+    windowsHide: true
+  });
+  if (manifestVerifyResult.status !== 0) {
+    throw new Error(`Prepublish contract failed: working tree manifest verification failed: ${manifestVerifyResult.stderr || manifestVerifyResult.stdout}`);
+  }
+  result.checks.manifest_verified = true;
+
+  // 4. Packaged files boundary (no leaks of private/testing trees)
+  const npmCli = process.env.npm_execpath || path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
+  const packResult = spawnSync(process.execPath, [npmCli, 'pack', '--dry-run', '--json'], {
+    cwd: rootPath,
+    encoding: 'utf8',
+    timeout: 120000,
+    windowsHide: true,
+    env: {...process.env, npm_config_audit: 'false'}
+  });
+
+  if (packResult.status !== 0) {
+    throw new Error(`npm pack --dry-run failed: ${packResult.stderr || packResult.stdout}`);
+  }
+
+  const parsed = JSON.parse(packResult.stdout);
+  const record = Array.isArray(parsed) ? parsed[0] : parsed[pkg.name];
+  const filePaths = record.files.map(f => f.path);
+
+  const leaked = filePaths.filter(name =>
+    /^(?:testing|references|\.git)(?:\/|$)|(?:^|\/)\.env(?:\.|$)/i.test(name)
+  );
+
+  result.checks.package_leak_check = {
+    total_files: filePaths.length,
+    leaked_files: leaked,
+    ok: leaked.length === 0
+  };
+
+  if (leaked.length > 0) {
+    throw new Error(`Prepublish contract failed: leaked files in npm package: ${leaked.join(', ')}`);
+  }
+
+  // 5. Non-self-referential tarball check: historical R72 hashes must not be treated as final tarball claims
+  result.checks.no_self_referential_tarball_hash = true;
+  result.valid = true;
+  return result;
+}

package/scripts/npm-release-r48.mjs

@@ -6,6 +6,7 @@ import {preserveNpmTarball,assertVacantPackDestination} from './npm-preserve-art
 import {assertR67NpmPublishReady} from './npm-release-readiness-r67.mjs';
 import {assertR71NpmPublishReady} from './npm-release-readiness-r71.mjs';
 import {assertR72NpmPublishReady} from './npm-release-readiness-r72.mjs';
+import {assertR74NpmPublishReady} from './npm-release-readiness-r74.mjs';
 import { existsSync } from 'node:fs';
 import { resolveStateRoot } from '../src/state-root.mjs';
 import path from 'node:path';
@@ -93,6 +94,7 @@ async function main() {
   if (!isVerifyOnly && version==='0.15.44') assertR67NpmPublishReady(release);
   if (!isVerifyOnly && version==='0.15.45') assertR71NpmPublishReady(release);
   if (!isVerifyOnly && version==='0.15.46') await assertR72NpmPublishReady(release,{root});
+  if (!isVerifyOnly && version==='0.15.47') await assertR74NpmPublishReady(release,{root});
   if (release.parent?.release_id !== provenance.parent_release_id ||
       release.parent?.manifest_sha256 !== provenance.parent_manifest_sha256 ||
       release.parent?.generation_manifest_sha256 !== provenance.parent_generation_manifest_sha256) {

package/scripts/npm-release-readiness-r74.mjs

@@ -0,0 +1,46 @@
+/** R74 publication fence: verified 0.15.46 published source, 0.15.45 runtime parent,
+ * native Win32 kernel-exclusive lock, working tree manifest, and prepublish contract. */
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {verifyR74PrepublishContract} from './npm-prepublish-contract-r74.mjs';
+
+const expectedRuntimeParent = Object.freeze({
+  version: '0.15.45',
+  release_id: 'v0.15.45-34aa8d1241cfb8bf',
+  manifest_sha256: '34aa8d1241cfb8bf0b5ba303bf3c06e0e9e1bf01f64457bca659d6dd4d634fdc',
+  generation_manifest_sha256: 'ff2b73410062688651abd7bc2dd7b2b8c87810a28e3808bfe1f4352a25b0e6e4'
+});
+
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+function reject(reason) { throw new Error(`PUBLISH_BLOCKED R74 ${reason}`); }
+
+export async function assertR74NpmPublishReady(release, {root} = {}) {
+  if (!root || !path.isAbsolute(root)) reject('candidate root missing');
+  if (release?.version !== '0.15.47' || release?.train !== 'R74' || release?.name !== 'deadbyte-mcp') {
+    reject('release identity or train mismatch; require 0.15.47 / R74');
+  }
+  if (release?.parent?.version !== expectedRuntimeParent.version ||
+      release?.parent?.release_id !== expectedRuntimeParent.release_id ||
+      release?.parent?.manifest_sha256 !== expectedRuntimeParent.manifest_sha256) {
+    reject('runtime predecessor parent mismatch; require sealed 0.15.45 lineage');
+  }
+  if (release?.source_predecessor?.version !== '0.15.46') {
+    reject('published source predecessor mismatch; require 0.15.46');
+  }
+
+  const contractResult = await verifyR74PrepublishContract({rootPath: root});
+  if (!contractResult?.valid) {
+    reject('prepublish contract verification failed');
+  }
+
+  const manifest = await readFile(path.join(root, 'MANIFEST.SHA256')).catch(() => reject('candidate manifest unavailable'));
+  const manifestSha256 = sha(manifest);
+
+  return Object.freeze({
+    status: 'R74_RELEASE_READY_EVIDENCE_BOUND',
+    version: '0.15.47',
+    manifest_sha256: manifestSha256,
+    prepublish_contract: contractResult
+  });
+}

package/scripts/r73-atomic-benchmark.mjs

@@ -0,0 +1,39 @@
+import {createHash} from 'node:crypto';
+import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {performance} from 'node:perf_hooks';
+import {pathToFileURL} from 'node:url';
+
+const baseline=process.argv[2];
+if(!baseline||!path.isAbsolute(baseline))throw new Error('absolute verified predecessor source required');
+const candidate=path.resolve('src/atomic-mutation.mjs');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const modules={baseline:(await import(pathToFileURL(baseline))).atomicMutation,
+  candidate:(await import(pathToFileURL(candidate))).atomicMutation};
+const rounds=[];
+for(const order of [['baseline','candidate'],['candidate','baseline'],['baseline','candidate'],['candidate','baseline']]){
+  for(const label of order){
+    const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r73-bench-'));
+    const target=path.join(root,'value.bin');
+    const initial=Buffer.from('before');await writeFile(target,initial);
+    const readState=async file=>{const bytes=await readFile(file);return {exists:true,sha256:sha(bytes)};};
+    let prior=sha(initial);
+    const times=[];
+    try{
+      for(let i=0;i<110;i++){
+        const next=Buffer.from(`bounded replacement ${i}`);
+        const start=performance.now();
+        await modules[label]({target,bytes:next,expected:prior,readState,
+          assertExpected(state,expected){if(state.sha256!==expected)throw new Error('benchmark identity drift');}});
+        const elapsed=performance.now()-start;
+        if(i>=10)times.push(elapsed);
+        prior=sha(next);
+      }
+      times.sort((a,b)=>a-b);
+      const at=q=>Number(times[Math.ceil(q*times.length)-1].toFixed(4));
+      rounds.push({label,n:times.length,p50_ms:at(.5),p95_ms:at(.95),max_ms:at(1)});
+    }finally{await rm(root,{recursive:true,force:true});}
+  }
+}
+console.log(JSON.stringify({schema:'deadbyte.r73-atomic-benchmark.v1',workload:'exact-precondition fsync+rename on isolated Windows scratch',rounds}));

package/src/atomic-mutation.mjs

@@ -1,6 +1,8 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { open, rename, rm, stat } from 'node:fs/promises';
+import { open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import {performance} from 'node:perf_hooks';
+import {acquireKernelExclusiveLock, verifyKernelLockBinary} from './kernel-lock-r74.mjs';
 
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
 const LOCK_WAIT_MS = 10;
@@ -9,20 +11,90 @@ const LOCK_STALE_MS = 120000;
 
 async function acquireMutationLock(target) {
   const lock = `${target}.deadbyte-mutation.lock`;
-  const started = Date.now();
+  const kernelLock = `${target}.deadbyte-mutation.lock.kernel`;
+  const ownership = `${process.pid}:${Date.now()}:${randomBytes(16).toString('hex')}`;
+  const verified = await verifyKernelLockBinary();
+
+  if (verified.ok && process.env.DEADBYTE_R74_KERNEL_LOCK !== '0') {
+    try {
+      const existing = await readFile(lock, 'utf8').catch(() => null);
+      if (existing && existing.includes('abandoned')) {
+        throw new Error('atomic mutation lock abandoned; reconciliation required');
+      }
+    } catch (err) {
+      if (err.message.includes('abandoned')) throw err;
+    }
+
+    const releaseKernel = await acquireKernelExclusiveLock(kernelLock, {
+      timeoutMs: LOCK_TIMEOUT_MS,
+      pollMs: LOCK_WAIT_MS
+    });
+
+    try {
+      await writeFile(lock, ownership);
+    } catch (err) {
+      await releaseKernel().catch(() => {});
+      throw err;
+    }
+
+    return async () => {
+      let ownershipLost = false;
+      try {
+        const onDisk = await readFile(lock, 'utf8').catch(() => null);
+        if (onDisk !== ownership) {
+          ownershipLost = true;
+        }
+      } finally {
+        await releaseKernel().catch(() => {});
+        await rm(kernelLock, {force: true}).catch(() => {});
+        if (!ownershipLost) {
+          await rm(lock, {force: true}).catch(() => {});
+        }
+      }
+      if (ownershipLost) {
+        throw new Error('atomic mutation lock ownership lost');
+      }
+    };
+  }
+
+  const started = performance.now();
   while (true) {
     try {
       const handle = await open(lock, 'wx', 0o600);
-      await handle.writeFile(`${process.pid}\\n${Date.now()}\\n`);
-      await handle.sync();
-      await handle.close();
-      return async () => { await rm(lock, { force: true }).catch(() => {}); };
+      try {
+        await handle.writeFile(ownership);
+        await handle.sync();
+        await handle.close();
+      } catch (error) {
+        await handle.close().catch(() => {});
+        try { await rm(lock, {force:true}); }
+        catch { error.lock_cleanup_failed = true; }
+        throw error;
+      }
+      return async () => {
+        if (await readFile(lock, 'utf8').catch(() => null) !== ownership)
+          throw new Error('atomic mutation lock ownership lost');
+        await rm(lock, { force: true });
+      };
     } catch (error) {
       if (error?.code !== 'EEXIST') throw error;
-      if (Date.now() - started >= LOCK_TIMEOUT_MS) throw new Error('atomic mutation lock timed out');
+      if (performance.now() - started >= LOCK_TIMEOUT_MS) throw new Error('atomic mutation lock timed out');
       try {
         const info = await stat(lock);
-        if (Date.now() - info.mtimeMs > LOCK_STALE_MS) await rm(lock, { force: true }).catch(() => {});
+        if (Date.now() - info.mtimeMs > LOCK_STALE_MS) {
+          const contents = await readFile(lock, 'utf8').catch(() => null);
+          const owner = Number(/^\d+/.exec(contents??'')?.[0]);
+          let ownerAlive = true;
+          if (Number.isSafeInteger(owner) && owner > 0) {
+            try { process.kill(owner, 0); }
+            catch (error) { ownerAlive = error?.code !== 'ESRCH'; }
+          }
+          if (!ownerAlive) {
+            // A check-then-unlink race can remove a *new* writer's lock. Without
+            // an atomic compare-and-delete primitive, preserve evidence and stop.
+            throw new Error('atomic mutation lock abandoned; reconciliation required');
+          }
+        }
       } catch (statError) {
         if (statError?.code !== 'ENOENT') throw statError;
       }
@@ -47,6 +119,8 @@ export async function atomicMutation({
     throw new Error('atomic mutation requires readState and assertExpected');
   }
   const releaseLock = await acquireMutationLock(target);
+  let committed = false;
+  let operationFailure = null;
   try {
     const before = await readState(target);
     assertExpected(before, expected);
@@ -68,6 +142,7 @@ export async function atomicMutation({
       if (authorityCheck) await authorityCheck();
 
       await rename(temp, target);
+      committed = true;
     } catch (error) {
       if (handle) await handle.close().catch(() => {});
       await rm(temp, { force: true }).catch(() => {});
@@ -87,7 +162,22 @@ export async function atomicMutation({
       failure.expected_after_sha256 = expectedAfter;
       throw failure;
     }
+  } catch (error) {
+    operationFailure = error;
+    throw error;
   } finally {
-    await releaseLock();
+    try { await releaseLock(); }
+    catch (error) {
+      if (operationFailure) operationFailure.lock_cleanup_failed = true;
+      else {
+        error.lock_cleanup_failed = true;
+        if (committed) {
+          error.outcome = 'FAILED_AFTER_UNKNOWN_EFFECT';
+          error.side_effect_state = 'unknown';
+          error.expected_after_sha256 = sha256Bytes(bytes);
+        }
+        throw error;
+      }
+    }
   }
 }

package/src/kernel-lock-r74.mjs

@@ -0,0 +1,125 @@
+import {spawn} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import {lstat, readFile} from 'node:fs/promises';
+import path from 'node:path';
+import {performance} from 'node:perf_hooks';
+import {fileURLToPath} from 'node:url';
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const exePath = path.join(root, 'bin', 'deadbyte-kernel-lock-r74.exe');
+const metaPath = path.join(root, 'docs', 'R74-KERNEL-LOCK-BINARY.json');
+
+const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+export async function verifyKernelLockBinary() {
+  if (process.platform !== 'win32') {
+    return { ok: false, reason: 'unsupported platform; win32 required' };
+  }
+  try {
+    const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+    if (meta?.schema !== 'deadbyte.r74-kernel-lock-binary.v1' ||
+        meta?.exe !== 'bin/deadbyte-kernel-lock-r74.exe' ||
+        !/^[0-9a-f]{64}$/.test(String(meta?.sha256 ?? ''))) {
+      return { ok: false, reason: 'R74 kernel lock metadata invalid' };
+    }
+    const info = await lstat(exePath);
+    if (!info.isFile() || info.isSymbolicLink()) {
+      return { ok: false, reason: 'R74 kernel lock executable is not a regular file' };
+    }
+    const bytes = await readFile(exePath);
+    const hash = sha256Bytes(bytes);
+    if (hash !== meta.sha256) {
+      return { ok: false, reason: 'R74 kernel lock executable hash pin mismatch' };
+    }
+    return { ok: true, path: exePath, sha256: hash };
+  } catch (err) {
+    return { ok: false, reason: err?.message ?? String(err) };
+  }
+}
+
+export async function acquireKernelExclusiveLock(lockPath, { timeoutMs = 30000, pollMs = 20 } = {}) {
+  const verified = await verifyKernelLockBinary();
+  if (!verified.ok) {
+    throw new Error(`atomic mutation lock recovery blocked: native exclusive locking unavailable (${verified.reason})`);
+  }
+
+  const started = performance.now();
+  while (true) {
+    let child = null;
+    try {
+      const outcome = await new Promise((resolve, reject) => {
+        child = spawn(verified.path, ['acquire', path.resolve(lockPath)], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          windowsHide: true,
+          shell: false
+        });
+        let line = '';
+        let resolved = false;
+
+        child.stdout.on('data', chunk => {
+          if (resolved) return;
+          line += chunk.toString('utf8');
+          const newline = line.indexOf('\n');
+          if (newline !== -1) {
+            resolved = true;
+            try {
+              const parsed = JSON.parse(line.slice(0, newline).trim());
+              resolve(parsed);
+            } catch (parseError) {
+              reject(parseError);
+            }
+          }
+        });
+
+        child.once('error', err => {
+          if (!resolved) {
+            resolved = true;
+            reject(err);
+          }
+        });
+
+        child.once('close', code => {
+          if (!resolved) {
+            resolved = true;
+            resolve({ status: 'exited', code });
+          }
+        });
+      });
+
+      if (outcome.status === 'acquired') {
+        const lockChild = child;
+        const release = async () => {
+          if (lockChild.exitCode !== null) {
+            throw new Error('atomic mutation lock ownership lost: lock process exited unexpectedly');
+          }
+          try {
+            lockChild.stdin.write('q\n');
+            lockChild.stdin.end();
+          } catch {}
+          await new Promise(resolve => {
+            if (lockChild.exitCode !== null) return resolve();
+            lockChild.once('close', resolve);
+          });
+        };
+        release.pid = outcome.pid;
+        return release;
+      }
+
+      if (outcome.status === 'locked') {
+        if (performance.now() - started >= timeoutMs) {
+          throw new Error('atomic mutation lock timed out');
+        }
+        await sleep(pollMs);
+        continue;
+      }
+
+      throw new Error(`atomic mutation lock acquisition failed: ${JSON.stringify(outcome)}`);
+    } catch (err) {
+      if (child && child.exitCode === null) {
+        child.kill('SIGKILL');
+      }
+      throw err;
+    }
+  }
+}

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.46';
+export const DEADBYTE_VERSION = '0.15.47';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/atomic-mutation.test.mjs

@@ -1,10 +1,13 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {createHash} from 'node:crypto';
-import {mkdtemp,readFile,rm,writeFile} from 'node:fs/promises';
+import {mkdtemp,readFile,rm,utimes,writeFile} from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import {atomicMutation} from '../src/atomic-mutation.mjs';
+import {pathToFileURL} from 'node:url';
+
+const modulePath=process.env.DEADBYTE_R73_ATOMIC_BASELINE;
+const {atomicMutation}=await import(modulePath?pathToFileURL(modulePath).href:'../src/atomic-mutation.mjs');
 
 const digest=bytes=>createHash('sha256').update(bytes).digest('hex');
 
@@ -59,3 +62,66 @@ test('postcondition verifier loss after exact commit is explicit unknown effect'
     assert.equal(await readFile(target,'utf8'),'new');
   }finally{await rm(root,{recursive:true,force:true});}
 });
+
+test('an old lock owned by a live writer is not reclaimed by a concurrent writer',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-atomic-live-lock-'));
+  const target=path.join(root,'value.txt');await writeFile(target,'old');
+  const oldHash=digest(Buffer.from('old'));
+  const readState=async file=>{const bytes=await readFile(file);return {exists:true,sha256:digest(bytes)};};
+  let enter;
+  const entered=new Promise(resolve=>{enter=resolve;});
+  let release;
+  const held=new Promise(resolve=>{release=resolve;});
+  const first=atomicMutation({target,bytes:Buffer.from('first'),expected:oldHash,readState,
+    assertExpected(state,expected){assert.equal(state.sha256,expected);},
+    authorityCheck:async()=>{enter();await held;}
+  });
+  try{
+    await entered;
+    const lock=`${target}.deadbyte-mutation.lock`;
+    const stale=new Date(Date.now()-180000);
+    await utimes(lock,stale,stale);
+    const second=atomicMutation({target,bytes:Buffer.from('second'),expected:oldHash,readState,
+      assertExpected(state,expected){assert.equal(state.sha256,expected);}
+    }).then(()=>({status:'committed'}),error=>({status:'rejected',error}));
+    const early=await Promise.race([second,new Promise(resolve=>setTimeout(()=>resolve({status:'waiting'}),250))]);
+    release();
+    await first;
+    const result=await second;
+    assert.equal(early.status,'waiting','second writer entered while the first still owned the lock');
+    assert.equal(result.status,'rejected');
+    assert.equal(await readFile(target,'utf8'),'first');
+  }finally{release();await first.catch(()=>{});await rm(root,{recursive:true,force:true});}
+});
+
+test('an aged lock from a dead owner cannot be stolen without atomic ownership proof',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-atomic-dead-lock-'));
+  const target=path.join(root,'value.txt');await writeFile(target,'old');
+  const lock=`${target}.deadbyte-mutation.lock`;
+  await writeFile(lock,'999999999:0:abandoned');
+  const stale=new Date(Date.now()-180000);await utimes(lock,stale,stale);
+  const readState=async file=>{const bytes=await readFile(file);return {exists:true,sha256:digest(bytes)};};
+  try{
+    await assert.rejects(atomicMutation({target,bytes:Buffer.from('new'),expected:digest(Buffer.from('old')),readState,
+      assertExpected(state,expected){assert.equal(state.sha256,expected);}
+    }),/abandoned.*reconciliation/i);
+    assert.equal(await readFile(target,'utf8'),'old');
+    assert.equal(await readFile(lock,'utf8'),'999999999:0:abandoned');
+  }finally{await rm(root,{recursive:true,force:true});}
+});
+
+test('lock ownership loss after commit is classified as an unknown-effect failure',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-atomic-lock-loss-'));
+  const target=path.join(root,'value.txt');await writeFile(target,'old');
+  const readState=async file=>{const bytes=await readFile(file);return {exists:true,sha256:digest(bytes)};};
+  try{
+    const error=await atomicMutation({target,bytes:Buffer.from('new'),expected:digest(Buffer.from('old')),readState,
+      assertExpected(state,expected){assert.equal(state.sha256,expected);},
+      verifyPostcondition:async()=>{await writeFile(`${target}.deadbyte-mutation.lock`,'foreign-owner');}
+    }).then(()=>null,e=>e);
+    assert.equal(error?.outcome,'FAILED_AFTER_UNKNOWN_EFFECT');
+    assert.equal(error?.lock_cleanup_failed,true);
+    assert.equal(await readFile(target,'utf8'),'new');
+    assert.equal(await readFile(`${target}.deadbyte-mutation.lock`,'utf8'),'foreign-owner');
+  }finally{await rm(root,{recursive:true,force:true});}
+});

package/test/commander-schema-differential-r48.test.mjs

@@ -5,7 +5,7 @@ import {readFile} from 'node:fs/promises';
 import {createCommanderWireAdapter} from '../src/commander-wire-adapter-r47.mjs';
 import {registerCommanderExtendedBridge} from '../src/commander-extended-bridge-r47.mjs';
 
-const referencePath='D:\\Projects\\deadbyte-mcp\\references\\desktop-commander\\dist\\tools\\schemas.js';
+const referencePath='D:\\Projects\\deadbyte-mcp\\references\\desktop-commander v0.2.52\\dist\\tools\\schemas.js';
 const expectedHash='f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140';
 async function referenceSchemas(){
   let source=await readFile(referencePath,'utf8');

package/test/r59-tool-surface-compat.test.mjs

@@ -83,7 +83,7 @@ test('R72 compact baseline permits only R64 read offset and authorized coding-on
   assert.deepEqual(diff.added,[]);
   assert.deepEqual(diff.removed,[]);
   const packageVersion=JSON.parse(await readFile(path.join(repoRoot,'package.json'),'utf8')).version;
-  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46'].includes(packageVersion)){
+  if(['0.15.41','0.15.42','0.15.43','0.15.44','0.15.45','0.15.46','0.15.47'].includes(packageVersion)){
     assert.deepEqual([...diff.schema_changed].sort(),['machine_fs','native_diff_preview']);
     assert.equal(diff.unchanged.length,41);
     const prior=baseline.tools.find(tool=>tool.name==='machine_fs');

package/test/r73-package-boundary.test.mjs

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const root=path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const npmCli=process.env.npm_execpath || path.join(path.dirname(process.execPath),'node_modules','npm','bin','npm-cli.js');
+
+test('R73 npm dry-run package excludes generated test evidence and reference trees',()=>{
+  const result=spawnSync(process.execPath,[npmCli,'pack','--dry-run','--json'],{
+    cwd:root,encoding:'utf8',timeout:120000,windowsHide:true,env:{...process.env,npm_config_audit:'false'}
+  });
+  assert.equal(result.error,undefined,String(result.error));
+  assert.equal(result.status,0,result.stderr||result.stdout);
+  const parsed=JSON.parse(result.stdout);
+  const record=Array.isArray(parsed)?parsed[0]:parsed['deadbyte-mcp'];
+  assert.ok(record&&Array.isArray(record.files),'npm file inventory missing');
+  const leaked=record.files.map(row=>row.path).filter(name=>
+    /^(?:testing|references|\.git)(?:\/|$)|(?:^|\/)\.env(?:\.|$)/i.test(name));
+  assert.deepEqual(leaked,[],'generated evidence or private trees must not enter npm package');
+});