deadbyte-mcp 0.15.46 → 0.15.48

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,11 @@ 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 (version==='0.15.48') {
+    const {assertR108NpmPublishReady} = await import('./npm-release-readiness-r108.mjs');
+    await assertR108NpmPublishReady(release,{root,provenance});
+  }
   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) {
@@ -107,6 +113,7 @@ async function main() {
 
   if (isAlreadyPublished) console.log(`Notice: deadbyte-mcp@${version} exists on registry (${existingText}); exact-byte reconciliation is required.`);
 
+  run(node, [path.join(root, 'scripts', 'r75-npm-bin-integrity-gate.mjs')]);
   console.log('[2/7] Pre-pack gates: verifying working tree manifest and doctor...');
   run(node, [path.join(root, 'scripts', 'release-manifest.mjs'), 'verify']);
   const doctorState=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r65-release-doctor-'));
@@ -133,7 +140,8 @@ async function main() {
   try {
     console.log('[4/7] Verifying packed artifact file surface against MANIFEST.SHA256 and packaging contract...');
     const manifestText = await readFile(path.join(root, 'MANIFEST.SHA256'), 'utf8');
-    const manifestSha256=createHash('sha256').update(manifestText).digest('hex');
+    const claimData = resuming ? JSON.parse(await readFile(path.join(publicationDir, 'claim.json'), 'utf8')) : null;
+    const manifestSha256 = resuming ? claimData.manifest_sha256 : createHash('sha256').update(manifestText).digest('hex');
     const manifestEntries = new Set();
     for (const line of manifestText.split(/\r?\n/)) {
       if (!line) continue;
@@ -221,12 +229,24 @@ async function main() {
       lookup:async()=>{
         try{
           const viewed=parseJson(runNpm(['view',`deadbyte-mcp@${version}`,'version','dist.integrity','dist.shasum','dist.tarball','--json'],{timeout:120000}));
-          return Array.isArray(viewed)?viewed[0]:viewed;
+          const item = Array.isArray(viewed)?viewed[0]:viewed;
+          if (item && !item.dist && item['dist.tarball']) {
+            item.dist = {
+              tarball: item['dist.tarball'],
+              shasum: item['dist.shasum'],
+              integrity: item['dist.integrity']
+            };
+          }
+          return item;
         }catch(error){if(/E404|404 Not Found/.test(String(error?.message)))return null;throw error;}
       },
-      tags:async()=>parseJson(runNpm(['view','deadbyte-mcp','dist-tags','--json'],{timeout:120000})),
+      tags:async()=>{
+        const parsed=parseJson(runNpm(['view','deadbyte-mcp','dist-tags','--json'],{timeout:120000}));
+        return Array.isArray(parsed)?parsed[0]:parsed;
+      },
       fetchTarball:async published=>{
-        const response=await fetch(published?.dist?.tarball,{signal:AbortSignal.timeout(120000)});
+        const url = published?.dist?.tarball ?? published?.['dist.tarball'];
+        const response=await fetch(url,{signal:AbortSignal.timeout(120000)});
         if(!response.ok)throw Object.assign(new Error(`registry tarball fetch failed status=${response.status}`),{status:response.status});
         return Buffer.from(await response.arrayBuffer());
       }});

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

@@ -0,0 +1,134 @@
+import { createHash } from 'node:crypto';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const defaultRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const sha256 = value => createHash('sha256').update(value).digest('hex');
+const evidenceName = 'r108-protected-publication-evidence.json';
+const norm = p => path.resolve(p).replace(/\\/g, '/').toLowerCase();
+const assert = (ok, message) => { if (!ok) throw new Error('R108_PUBLICATION_GATE: ' + message); };
+const json = async file => JSON.parse(await readFile(file, 'utf8'));
+
+function manifestEntries(input) {
+  const entries = new Map();
+  for (const line of input.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const match = /^([a-f0-9]{64})\s+\*?(.+)$/i.exec(line);
+    assert(match !== null, 'unrecognized manifest line format');
+    const rel = match[2].replace(/\\/g, '/');
+    assert(!entries.has(rel), 'duplicate manifest entry ' + rel);
+    entries.set(rel, match[1].toLowerCase());
+  }
+  return entries;
+}
+
+function testCounts(output) {
+  const values = {};
+  for (const line of output.split(/\r?\n/)) {
+    const match = /^\s*(?:ℹ|#)\s*(tests|pass|fail|skipped)\s+(\d+)\s*$/.exec(line);
+    if (match) values[match[1]] = Number(match[2]);
+  }
+  assert(['tests','pass','fail','skipped'].every(k => Number.isSafeInteger(values[k])), 'missing complete Node test-runner footer');
+  assert(values.tests === values.pass + values.fail + values.skipped, 'inconsistent test totals');
+  assert(values.fail === 0, 'fresh full regression reported failures');
+  assert(values.pass >= 1621, 'full regression below R107 established pass baseline');
+  assert(values.skipped <= 48, 'new unexplained skips relative to R107');
+  return values;
+}
+
+async function slotParity(root, protectedRoot, expectedRootSha, expectedSlotSha) {
+  assert(path.isAbsolute(protectedRoot), 'protected slot must be absolute');
+  assert(norm(root) !== norm(protectedRoot), 'protected test slot must differ from source');
+  if (process.platform === 'win32') {
+    assert(norm(protectedRoot).startsWith('c:/program files/'), 'protected slot must be under Program Files');
+  }
+  const sourceBytes = await readFile(path.join(root,'MANIFEST.SHA256'));
+  const slotBytes = await readFile(path.join(protectedRoot,'MANIFEST.SHA256'));
+  assert(sha256(sourceBytes) === expectedRootSha, 'R108 source manifest hash changed after test');
+  assert(sha256(slotBytes) === expectedSlotSha, 'protected test manifest hash changed after test');
+  const source = manifestEntries(sourceBytes.toString('utf8'));
+  const slot = manifestEntries(slotBytes.toString('utf8'));
+  assert(source.size === slot.size, 'source/protected manifest surface differs');
+  const allowed = 'controller/deadbyte-process-policy.json';
+  for (const [p,h] of source) {
+    assert(slot.has(p), 'protected fixture missing source entry ' + p);
+    if (p !== allowed) assert(slot.get(p) === h, 'protected fixture changes tested source bytes at ' + p);
+  }
+  assert(source.has(allowed) && slot.has(allowed), 'required policy fixture missing from manifest');
+  for (const [label,dir] of [['source',root],['protected',protectedRoot]]) {
+    const policy = await json(path.join(dir, 'controller', 'deadbyte-process-policy.json'));
+    assert(norm(policy?.roots?.core?.path ?? '.') === norm(dir), label + ' process policy core root not bound to its own checkout');
+    assert(norm(policy?.native_host?.path ?? '.') === norm(path.join(dir,'bin','deadbyte-process-host.exe')), label + ' native host not self-bound');
+    assert(norm(policy?.grant_file ?? '.') === norm(path.join(dir,'controller','runtime','process-grant.json')), label + ' grant path not self-bound');
+    assert(norm(policy?.state_dir ?? '.') === norm(path.join(dir,'controller','runtime','process-state')), label + ' state path not self-bound');
+  }
+  return { sourceFiles: source.size, protectedFiles: slot.size };
+}
+
+export async function assertR108NpmPublishReady(release, {root = defaultRoot,provenance = null} = {}) {
+  const rootPath = path.resolve(root);
+  const pkg = await json(path.join(rootPath,'package.json'));
+  const prov = provenance ?? await json(path.join(rootPath,'PROVENANCE.json'));
+  const lock = await json(path.join(rootPath,'package-lock.json'));
+  assert(pkg.name === 'deadbyte-mcp', 'package name mismatch');
+  assert([pkg.version,lock.version,lock.packages?.['']?.version,release.version,prov.version].every(v => v === '0.15.48'), 'package/release/provenance identity mismatch');
+  assert(release.train === 'R108', 'release train is not R108');
+  assert(release.r108_candidate?.status === 'CANDIDATE_UNSEALED', 'R108 pending-state metadata missing');
+  assert(release.source_predecessor?.version === '0.15.47' && prov.source_predecessor_version === '0.15.47', 'published source predecessor mismatch');
+  assert(release.parent?.version === '0.15.45' && release.runtime_predecessor?.version === '0.15.45', 'runtime predecessor mismatch');
+  for (const key of ['release_id','manifest_sha256','generation_manifest_sha256']) {
+    assert(release.parent?.[key] === prov['parent_'+key], 'sealed parent lineage mismatch at ' + key);
+    assert(release.runtime_predecessor?.[key] === release.parent?.[key], 'runtime predecessor drift at ' + key);
+    assert(prov.runtime_predecessor?.[key] === release.parent?.[key], 'provenance runtime predecessor drift at ' + key);
+  }
+  const proof = await json(path.join(rootPath,'testing',evidenceName));
+  assert(proof.schema === 'deadbyte.r108-protected-publication-evidence.v1', 'missing/fake R108 proof schema');
+  assert(proof.version === '0.15.48', 'proof version mismatch');
+  assert(norm(proof.candidate_root ?? '.') === norm(rootPath), 'proof candidate root changed');
+  assert(proof.test_exit_code === 0, 'test process did not finish with exit 0');
+  const testLog = await readFile(path.join(rootPath,'testing','r108-protected-full.tap'));
+  assert(sha256(testLog) === proof.test_log_sha256, 'test log bytes drifted');
+  const actualCounts = testCounts(testLog.toString('utf8'));
+  for (const key of ['tests','pass','fail','skipped']) assert(actualCounts[key] === proof.counts?.[key], 'proof disagrees with test log at '+key);
+  const parity = await slotParity(rootPath, proof.protected_root, proof.source_manifest_sha256, proof.protected_manifest_sha256);
+  assert(parity.sourceFiles >= 2339, 'manifest file count smaller than R107 baseline');
+  console.log('R108_PREPUBLISH_GATE_PASS '+JSON.stringify({version:'0.15.48',manifest_sha256:proof.source_manifest_sha256,test_log_sha256:proof.test_log_sha256,counts:actualCounts,source_files:parity.sourceFiles,protected_files:parity.protectedFiles}));
+  return true;
+}
+
+const invoked = process.argv[1] && norm(process.argv[1]) === norm(fileURLToPath(import.meta.url));
+if (invoked) {
+  try {
+    const command = process.argv[2] ?? 'verify';
+    if (command === 'record') {
+      const [rootArg,protectedArg,exitCodeArg] = process.argv.slice(3);
+      assert(rootArg && protectedArg && exitCodeArg !== undefined, 'usage: node scripts/npm-release-readiness-r108.mjs record ROOT PROTECTED_ROOT TEST_EXIT');
+      const root = path.resolve(rootArg), protectedRoot = path.resolve(protectedArg);
+      assert(Number(exitCodeArg) === 0, 'test exit code not zero');
+      const testLog = await readFile(path.join(root,'testing','r108-protected-full.tap'));
+      const counts = testCounts(testLog.toString('utf8'));
+      const sourceManifest = sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+      const protectedManifest = sha256(await readFile(path.join(protectedRoot,'MANIFEST.SHA256')));
+      await slotParity(root,protectedRoot,sourceManifest,protectedManifest);
+      const receipt = {
+        schema:'deadbyte.r108-protected-publication-evidence.v1',
+        version:'0.15.48',candidate_root:root,protected_root:protectedRoot,
+        source_manifest_sha256:sourceManifest,protected_manifest_sha256:protectedManifest,
+        test_log_sha256:sha256(testLog),test_exit_code:0,counts,
+        limitations:'Locally hashed regression and source/protected manifest parity; not a hardware attestation or independent signature.'
+      };
+      const proofPath=path.join(root,'testing',evidenceName);
+      await mkdir(path.dirname(proofPath),{recursive:true});
+      await writeFile(proofPath,JSON.stringify(receipt,null,2)+'\n',{flag:'wx'});
+      console.log('R108_PROOF_WRITTEN '+JSON.stringify({path:proofPath,...receipt}));
+    } else if (command === 'verify') {
+      const root = path.resolve(process.argv[3] ?? defaultRoot);
+      const release = await json(path.join(root,'RELEASE.json'));
+      await assertR108NpmPublishReady(release,{root});
+    } else throw new Error('unknown command '+command);
+  } catch(error) {
+    console.error(error?.stack || String(error));
+    process.exitCode=1;
+  }
+}

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/scripts/r75-npm-bin-integrity-gate.mjs

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const pkg = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8'));
+const bin = typeof pkg.bin === 'string' ? { [pkg.name]: pkg.bin } : pkg.bin;
+if (!bin || typeof bin !== 'object' || Array.isArray(bin) || !Object.keys(bin).length)
+  throw new Error('BIN_INTEGRITY: package.json.bin missing or invalid');
+const lines = readFileSync(path.join(root, 'MANIFEST.SHA256'), 'utf8').split(/\r?\n/).filter(Boolean);
+const entries = new Map();
+for (const line of lines) {
+  const m = /^([0-9a-f]{64})  (.+)$/.exec(line);
+  if (!m || entries.has(m[2])) throw new Error('BIN_INTEGRITY: invalid or duplicate manifest entry');
+  entries.set(m[2], m[1]);
+}
+for (const [name, relRaw] of Object.entries(bin)) {
+  if (typeof relRaw !== 'string' || !relRaw || relRaw.includes('\\'))
+    throw new Error(`BIN_INTEGRITY: invalid bin path for ${name}`);
+  const rel = relRaw.replace(/^\.\//, '');
+  const full = path.resolve(root, rel);
+  if (!full.startsWith(root + path.sep) || !entries.has(rel))
+    throw new Error(`BIN_INTEGRITY: unmanifested or escaping bin '${name}'`);
+  const bytes = readFileSync(full);
+  const firstLf = bytes.indexOf(0x0a);
+  if (firstLf < 2 || bytes[0] !== 0x23 || bytes[1] !== 0x21 || bytes[firstLf - 1] === 0x0d)
+    throw new Error(`BIN_INTEGRITY: bin '${name}' must begin with shebang LF (no CRLF)`);
+  const sha = createHash('sha256').update(bytes).digest('hex');
+  if (sha !== entries.get(rel))
+    throw new Error(`BIN_INTEGRITY: manifest and bin bytes differ for '${name}'`);
+  process.stdout.write(`BIN_INTEGRITY_PASS ${name} ${rel} ${sha}\n`);
+}

package/scripts/release-manifest.mjs

@@ -18,7 +18,7 @@ const requiredNativePayload = [
   'bin/bootstrap-kernel32.exe', 'bin/bootstrap-advapi32.exe',
   'bin/appcontainer-stage.exe', 'bin/bootstrap-exitcode.exe',
   'bin/child-control-stage.exe', 'bin/child-control-probe.exe',
-  'bin/deadbyte-exec.exe', 'bin/contained-transform-worker.exe',
+  'bin/deadbyte-exec.exe', 'bin/deadbyte-epoch-lock-r85.node', 'bin/contained-transform-worker.exe',
   'bin/contained-reverse-worker.exe', 'bin/deadbyte-tunnel-host.exe', 'bin/WORKER-REGISTRY.txt'
 ];
 const requiredBundledDependencyRoots = [

package/scripts/verify-r70-full-regression.ps1

@@ -1,6 +1,6 @@
 #requires -Version 5.1
 # R70 verifier artifact: runs the candidate test suite without altering release manifests.
-param([switch]$SelfTest)
+param([switch]$SelfTest,[string]$EvidenceRoot='')
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Continue'
 Set-Location -LiteralPath (Split-Path -Parent $PSScriptRoot)
@@ -36,7 +36,17 @@ $selected = @($lines | Where-Object {
 $summary = @($selected | Select-Object -Last 140 | ForEach-Object {
     if ($_.Length -gt 512) { $_.Substring(0, 512) } else { $_ }
 })
-$artifactDir = Join-Path (Get-Location).Path 'testing\r70-verifier'
+if ($EvidenceRoot -and -not $SelfTest) { throw 'EvidenceRoot override is self-test only' }
+$artifactDir = if ($EvidenceRoot) {
+    if (-not [System.IO.Path]::IsPathRooted($EvidenceRoot)) { throw 'EvidenceRoot must be absolute' }
+    $resolved = [System.IO.Path]::GetFullPath($EvidenceRoot)
+    $checkout = [System.IO.Path]::GetFullPath((Get-Location).Path).TrimEnd('\')
+    if ($resolved.TrimEnd('\').Equals($checkout,[System.StringComparison]::OrdinalIgnoreCase) -or
+        $resolved.StartsWith($checkout + '\',[System.StringComparison]::OrdinalIgnoreCase)) {
+        throw 'EvidenceRoot self-test override must be outside the checkout'
+    }
+    $resolved
+} else { Join-Path (Get-Location).Path 'testing\r70-verifier' }
 if (-not (Test-Path -LiteralPath $artifactDir -PathType Container)) {
     New-Item -ItemType Directory -Path $artifactDir -Force | Out-Null
 }

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

@@ -0,0 +1,67 @@
+import {createHash} from 'node:crypto';
+import {lstat,open,realpath} from 'node:fs/promises';
+import path from 'node:path';
+
+const FIELDS=Object.freeze({process:'grant_file',coding:'lease_file',autonomous:'lease_file',desktop:'grant_file',host:'arm_file'});
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const within=(root,target)=>{const relative=path.relative(root,target);return relative!==''&&!relative.startsWith('..'+path.sep)&&relative!=='..'&&!path.isAbsolute(relative);};
+const sameFile=(left,right)=>left.isFile()&&right.isFile()&&!left.isSymbolicLink()&&!right.isSymbolicLink()&&
+  left.dev===right.dev&&left.ino===right.ino&&left.size===right.size&&left.mtimeMs===right.mtimeMs&&
+  left.ctimeMs===right.ctimeMs&&left.birthtimeMs===right.birthtimeMs;
+async function readRegularPinned(file,label){
+  const before=await lstat(file);
+  if(!before.isFile()||before.isSymbolicLink())throw new Error(`${label} file type invalid`);
+  const handle=await open(file,'r');
+  try{
+    const opened=await handle.stat();
+    if(!sameFile(before,opened))throw new Error(`${label} identity changed before read`);
+    const bytes=await handle.readFile();
+    const after=await handle.stat(),pathAfter=await lstat(file);
+    if(!sameFile(opened,after)||!sameFile(after,pathAfter))throw new Error(`${label} identity changed during read`);
+    return bytes;
+  }finally{await handle.close();}
+}
+
+export async function observeAuthorityEvidence({stateRoot,policyPaths,policySha256,authority}){
+  const runtimeRoot=await realpath(path.join(stateRoot,'runtime'));
+  const result={};
+  for(const [plane,field] of Object.entries(FIELDS)){
+    const policyPath=policyPaths?.[plane],expectedHash=policySha256?.[plane],entry=authority?.[plane];
+    if(typeof policyPath!=='string'||!path.isAbsolute(policyPath)||!(/^[0-9a-f]{64}$/).test(expectedHash??''))
+      throw new Error(`${plane} policy identity incomplete`);
+    const policyBytes=await readRegularPinned(policyPath,`${plane} policy`);
+    if(sha(policyBytes)!==expectedHash)throw new Error(`${plane} policy digest changed during observation`);
+    let policy;
+    try{policy=JSON.parse(policyBytes.toString('utf8').replace(/^\uFEFF/,''));}
+    catch{throw new Error(`${plane} policy JSON invalid`);}
+    const schemaOk=plane==='host'?['deadbyte.host-policy.v1','deadbyte.host-policy.v2'].includes(policy?.schema):
+      policy?.schema===`deadbyte.${plane}-policy.v1`;
+    if(!schemaOk||policy.enabled!==true||
+        typeof policy[field]!=='string'||!path.isAbsolute(policy[field]))
+      throw new Error(`${plane} policy grant path invalid`);
+    const grantPath=path.resolve(policy[field]);
+    const parent=await realpath(path.dirname(grantPath));
+    if(!within(runtimeRoot,parent)&&parent!==runtimeRoot)throw new Error(`${plane} policy grant path outside runtime`);
+    const checkedPath=path.join(parent,path.basename(grantPath));
+    let grantInfo;
+    try{grantInfo=await lstat(checkedPath);}
+    catch(error){if(error?.code!=='ENOENT')throw error;}
+    const grantAbsent=grantInfo===undefined;
+    if(grantInfo&&(!grantInfo.isFile()||grantInfo.isSymbolicLink()))throw new Error(`${plane} grant file type invalid`);
+    const validEntry=entry&&entry.configured===true&&typeof entry.armed==='boolean';
+    const validDisarmed=validEntry&&!entry.armed&&grantAbsent&&
+      (entry.reason==='disarmed'||(plane==='autonomous'&&entry.reason==='coding-disarmed'));
+    const validArmed=validEntry&&entry.armed&&!grantAbsent&&entry.reason==='standing-grant'&&
+      Number.isSafeInteger(entry.epoch_seq)&&entry.epoch_seq>0&&/^[0-9a-f]{64}$/.test(entry.epoch_sha256??'');
+    const grantSha=grantInfo?sha(await readRegularPinned(checkedPath,`${plane} grant`)):null;
+    let grantFinal;
+    try{grantFinal=await lstat(checkedPath);}
+    catch(error){if(error?.code!=='ENOENT')throw error;}
+    if(grantAbsent?grantFinal!==undefined:!grantFinal||!sameFile(grantInfo,grantFinal))
+      throw new Error(`${plane} grant identity changed during observation`);
+    result[plane]=Object.freeze({state:validDisarmed?'VERIFIED_DISARMED':validArmed?'VERIFIED_ARMED':'UNVERIFIED',
+      policy_sha256:expectedHash,grant_absent:grantAbsent,
+      ...(grantSha?{grant_sha256:grantSha}:{})});
+  }
+  return Object.freeze(result);
+}

package/src/activation-continuity-engine-r65.mjs

@@ -3,6 +3,7 @@ import {open,readFile,rm} from 'node:fs/promises';
 import path from 'node:path';
 import {canonicalJson} from './canonical-json.mjs';
 import {decodeUtf8Strict} from './text-policy.mjs';
+import {deletePinnedRemoteMarker} from './foreground-marker-cas-win32.mjs';
 import {
   captureStandingGrant,compareSecurityEnvelopes,createAuthorityEpochStore,deriveSecurityEnvelope
 } from './authority-continuity-r65.mjs';
@@ -41,6 +42,17 @@ async function writeExclusive(file,bytes){
   finally{await handle.close();}
 }
 async function removeIfExact(file,expectedSha256){
+  // The Windows native disposition pins a single handle from read/hash through deletion.
+  // Never use a pathname removal after confirming only a previous snapshot.
+  if(process.platform==='win32'){
+    const verdict=deletePinnedRemoteMarker(file,expectedSha256);
+    if(verdict==='REMOVED')return {removed:true,reason:'matched'};
+    if(verdict==='MISSING')return {removed:false,reason:'absent'};
+    if(verdict==='CHANGED')return {removed:false,reason:'replacement'};
+    throw new Error('authority grant native deletion verdict invalid');
+  }
+  // Legacy non-Windows behavior is retained for source/test compatibility.
+  // It is NOT a cross-platform pinned-deletion security guarantee.
   const current=await readOptional(file);
   if(current===null)return {removed:false,reason:'absent'};
   if(sha(current)!==expectedSha256)return {removed:false,reason:'replacement'};
@@ -193,10 +205,11 @@ export function createEpochNativeContinuityEngine({stateRoot,predecessorPolicyPa
           if(conflict==='REVOKED_DURING_UPDATE')await removeIfExact(file,record.grant_sha256).catch(()=>{});
           outcomes[plane]=conflict;reauth.push(plane);continue;
         }
-        const existing=await readOptional(file);
-        if(existing===null){outcomes[plane]='REVOKED_DURING_UPDATE';reauth.push(plane);continue;}
-        if(sha(existing)!==record.grant_sha256){outcomes[plane]='REPLACED';reauth.push(plane);continue;}
-        await rm(file,{force:true});
+        const removed=await removeIfExact(file,record.grant_sha256);
+        if(!removed.removed){
+          outcomes[plane]=removed.reason==='absent'?'REVOKED_DURING_UPDATE':'REPLACED';
+          reauth.push(plane);continue;
+        }
         const prepared=buildSuccessorGrant({plane,record,successorPolicyBytes,successorPolicy});
         try{await writeExclusive(file,prepared.bytes);}
         catch(error){if(error?.code==='EEXIST'){outcomes[plane]='REPLACED';reauth.push(plane);continue;}throw error;}

package/src/activation-preflight-r65.mjs

@@ -47,6 +47,19 @@ export function classifyActivationPreflight({pointer,expectedParent,candidate,ex
   if(PLANES.some(plane=>typeof authority[plane]!=='boolean'))return Object.freeze({state:'UNKNOWN',safe_to_activate:false,reason:'authority observation incomplete'});
   const subject={pointer,expectedParent,candidate,expectedCandidate,observation};
   const bound={subject_sha256:digest(subject),authority:Object.freeze(authority)};
+  for(const plane of PLANES){
+    const entry=observation?.authority?.[plane],proof=observation?.authority_proof?.[plane];
+    if(entry&&typeof entry==='object'){
+      const knownReason=entry.armed?entry.reason==='standing-grant':entry.reason==='disarmed'||entry.reason==='coding-disarmed';
+      if(!knownReason)return Object.freeze({state:'AUTHORITY_UNVERIFIED',safe_to_activate:false,reason:`${plane} authority reason unverified`,...bound});
+    }
+    if(!proof)
+      return Object.freeze({state:'AUTHORITY_UNVERIFIED',safe_to_activate:false,reason:`${plane} authority proof missing`,...bound});
+    if(proof&&(proof.policy_sha256!==observation?.policy_sha256?.[plane]||
+        proof.state!==(authority[plane]?'VERIFIED_ARMED':'VERIFIED_DISARMED')||
+        (!authority[plane]&&proof.grant_absent!==true)))
+      return Object.freeze({state:'AUTHORITY_UNVERIFIED',safe_to_activate:false,reason:`${plane} authority proof unverified`,...bound});
+  }
   if(PLANES.some(plane=>!HEX64.test(String(observation?.policy_sha256?.[plane]))))
     return Object.freeze({state:'UNKNOWN',safe_to_activate:false,reason:'policy hash observation incomplete',...bound});
   if(pointer.release_id!==expectedParent.release_id||pointer.version!==expectedParent.version||