deadbyte-mcp 0.15.39 → 0.15.41

package/scripts/r64-read-benchmark.mjs

@@ -0,0 +1,84 @@
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,readFile,rm,writeFile} from 'node:fs/promises';
+import {performance} from 'node:perf_hooks';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+
+const [beforeRoot,afterRoot,scratchRoot,outputPath]=process.argv.slice(2);
+if([beforeRoot,afterRoot,scratchRoot,outputPath].some(value=>!value||!path.isAbsolute(value)))throw new Error('four absolute paths required: R63 R64 scratch output');
+const rounds=7,operations=400,concurrency=4;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const percentile=(values,p)=>[...values].sort((a,b)=>a-b)[Math.ceil(values.length*p)-1];
+await mkdir(scratchRoot,{recursive:true});
+const scratch=await mkdtemp(path.join(scratchRoot,'read-bench-'));
+try{
+  const project=path.join(scratch,'project');
+  await mkdir(project);
+  const file=path.join(project,'fixture.bin');
+  const content=Buffer.alloc(4*1024*1024+131072,0x52);
+  await writeFile(file,content);
+  const policyPath=path.join(scratch,'policy.json');
+  await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:path.join(scratch,'grant.json'),evidence_dir:path.join(scratch,'evidence'),
+    roots:{project:{path:project,read:true,write:false,exec:false,deny_paths:[]}},
+    commands:{},max_read_bytes:4*1024*1024,max_write_bytes:65536}));
+  const rows=[];
+  for(let round=0;round<rounds;round++){
+    for(const [label,root] of (round%2?[['after',afterRoot],['before',beforeRoot]]:[['before',beforeRoot],['after',afterRoot]])){
+      const url=name=>pathToFileURL(path.join(root,name)).href;
+      const [{loadCodingPolicy},{createMachineFsRuntime},{generateTrustKeypair},{createBridgeGovernor}]=await Promise.all([
+        import(url('src/coding-plane.mjs')),import(url('src/machine-fs.mjs')),
+        import(url('src/trust.mjs')),import(url('bridge/src/r40-governor.mjs'))
+      ]);
+      const keys=await generateTrustKeypair({privateKeyPath:path.join(scratch,`private-${label}-${round}.pem`),publicKeyPath:path.join(scratch,`public-${label}-${round}.pem`)});
+      const policy=await loadCodingPolicy(policyPath);
+      const runtime=createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+      const governor=createBridgeGovernor();
+      const latencies=[],control=[],errors=[];
+      let next=0,peakRss=process.memoryUsage().rss;
+      const started=performance.now();
+      async function bulkWorker(){
+        for(;;){
+          const index=next++;
+          if(index>=operations)return;
+          const mark=performance.now();
+          const ticket=await governor.acquire('machine_fs',{op:'read'});
+          try{
+            const result=await runtime.read({rootId:'project',relativePath:'fixture.bin',offset:(index%32)*65536,maxBytes:65536});
+            if(result.status!=='ok'||Buffer.from(result.data_base64,'base64').length!==65536)throw new Error('read oracle failed');
+          }catch(error){errors.push(String(error));}
+          finally{ticket.release();latencies.push(performance.now()-mark);peakRss=Math.max(peakRss,process.memoryUsage().rss);}
+        }
+      }
+      async function controlWorker(){
+        for(let index=0;index<operations;index++){
+          const mark=performance.now();
+          const ticket=await governor.acquire(index%2?'machine_status':'machine_ping');
+          try{if(index%2)await readFile(policyPath);else sha(Buffer.from(`ping-${index}`));}
+          finally{ticket.release();control.push(performance.now()-mark);}
+        }
+      }
+      await Promise.all([...Array.from({length:concurrency},()=>bulkWorker()),controlWorker()]);
+      const elapsed=performance.now()-started;
+      await governor.close();
+      const boundaryStart=performance.now();
+      let boundary={status:'unknown'};
+      try{
+        const first=await runtime.read({rootId:'project',relativePath:'fixture.bin',offset:65536,maxBytes:4*1024*1024});
+        const second=await runtime.read({rootId:'project',relativePath:'fixture.bin',offset:first.next_offset,maxBytes:65536});
+        if(first.next_offset<=4*1024*1024||second.eof!==true||Buffer.from(second.data_base64,'base64').length!==65536)throw new Error('cross-boundary oracle failed');
+        boundary={status:'pass',page_two_offset:first.next_offset,elapsed_ms:performance.now()-boundaryStart};
+      }catch(error){boundary={status:'rejected',reason:String(error?.message||error),elapsed_ms:performance.now()-boundaryStart};}
+      if(label==='before'&&boundary.status!=='rejected')errors.push('R63 unexpectedly accepted page two');
+      if(label==='after'&&boundary.status!=='pass')errors.push('R64 cross-boundary paging failed');
+      rows.push({round,label,source_sha256:sha(await readFile(path.join(root,'src/machine-fs.mjs'))),
+        ops:latencies.length,ops_per_second:operations*1000/elapsed,p50_ms:percentile(latencies,.5),p95_ms:percentile(latencies,.95),
+        control_p95_ms:percentile(control,.95),peak_rss_bytes:peakRss,boundary,errors});
+    }
+  }
+  const report={schema:'deadbyte.r64.read-benchmark.v1',node:process.version,rounds,operations_per_round:operations,concurrency,
+    source_roots:{before:beforeRoot,after:afterRoot},rows,
+    limitations:['same-host sequential alternating runs; OS scheduling noise remains','comparable throughput rows use inherited sub-4-MiB reads; boundary timings are separate because R63 cannot execute page two','control probe uses governor and local read/hash, not public MCP machine_ping or machine_status']};
+  await writeFile(outputPath,JSON.stringify(report,null,2)+'\n',{flag:'wx'});
+  console.log(JSON.stringify({output_path:outputPath,rows:rows.length,errors:rows.reduce((sum,row)=>sum+row.errors.length,0)}));
+}finally{await rm(scratch,{recursive:true,force:true});}

package/src/compact-gateway-mcp-tools.mjs

@@ -28,7 +28,7 @@ export const codingInspectInputSchema=z.discriminatedUnion('op',[
 export const machineFsGatewayInputSchema=z.discriminatedUnion('op',[
   z.strictObject({op:z.literal('stat'),root_id:id,path:rel.default('.'),hash:z.boolean().default(false)}),
   z.strictObject({op:z.literal('list'),root_id:id,path:rel.default('.'),cursor,limit:z.number().int().min(1).max(1000).default(100),hash_files:z.boolean().default(false)}),
-  z.strictObject({op:z.literal('read'),root_id:id,path:rel,offset:z.number().int().min(-4*1024*1024).max(4*1024*1024).default(0),max_bytes:z.number().int().min(1).max(4*1024*1024).default(65536),hash_file:z.boolean().default(false),timeout_ms:z.number().int().min(100).max(180000).default(30000)}),
+  z.strictObject({op:z.literal('read'),root_id:id,path:rel,offset:z.number().int().min(-4*1024*1024).max(Number.MAX_SAFE_INTEGER).default(0),max_bytes:z.number().int().min(1).max(4*1024*1024).default(65536),hash_file:z.boolean().default(false),timeout_ms:z.number().int().min(100).max(180000).default(30000)}),
   z.strictObject({op:z.literal('write'),root_id:id,path:rel,content:z.string().max(12*1024*1024),encoding:z.enum(['utf8','base64']).default('utf8'),expected_sha256:z.string().regex(/^(?:absent|[0-9a-f]{64})$/)}),
   z.strictObject({op:z.literal('edit_exact'),root_id:id,path:rel,expected_sha256:hex64,old_string:z.string().min(1).max(262144),new_string:z.string().max(524288),expected_replacements:z.number().int().min(1).max(64).default(1)}),
   z.strictObject({op:z.literal('mkdir'),root_id:id,path:rel}),

package/src/deadbyte-cli.mjs

@@ -20,7 +20,7 @@ import { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
 import {foregroundIdentityMatches,queryForegroundIdentity,validForegroundIdentity} from './foreground-process-identity.mjs';
 import {acquireForegroundSessionLock} from './foreground-session-lock.mjs';
-import { AUTHORITY_PLANES, authorityVector, parseAuthorityObservation, assertAuthorityVector, assertRuntimeReadyObservation, authorityBanner } from './remote-authority.mjs';
+import { AUTHORITY_PLANES, authorityVector, authorityRestorePlan, parseAuthorityObservation, assertAuthorityVector, assertRuntimeReadyObservation, authorityBanner } from './remote-authority.mjs';
 import { decodeRemoteLogBytes, boundedRemoteDiagnostic, safeRemoteLogPrefixLength } from './remote-log-decode-r60.mjs';
 
 const REMOTE_COMMANDS=new Set([
@@ -137,6 +137,20 @@ async function synchronizeForegroundRuntime(ctx,{displayMode='unicode'}={}){
     }
   });
 }
+async function synchronizeOneShotRuntime(ctx,{displayMode='ascii'}={}){
+  const active=await readActiveRuntimeBinding(ctx.root);
+  if(!active||active.version===DEADBYTE_VERSION) return synchronizeForegroundRuntime(ctx,{displayMode});
+  const before=observedAuthority(ctx);
+  const expected=Object.fromEntries(AUTHORITY_PLANES.map(plane=>[plane,before.authority[plane].armed]));
+  const result=await synchronizeForegroundRuntime(ctx,{displayMode});
+  if(result.status!=='upgraded') return result;
+  for(const command of authorityRestorePlan(before)){
+    const restored=invokeController(ctx,command,{capture:true,allowFailure:true,echoCaptured:false,timeoutMs:REMOTE_STATUS_TIMEOUT_MS});
+    if(restored.status!==0) throw new Error(`runtime coherence authority restore '${command}' failed exit=${restored.status}`);
+  }
+  assertAuthorityVector(observedAuthority(ctx),expected);
+  return result;
+}
 async function readControllerStartFailure(root,command,{maxChars=2048}={}){
   const file=path.join(root,'runtime','controller-start-failure.json');
   let raw;
@@ -629,7 +643,7 @@ async function runRemote(args){
   if(positional.length>1) throw new Error('remote accepts one controller command');
   const command=positional[0];if(!REMOTE_COMMANDS.has(command)) throw new Error(`unsupported remote command '${command}'`);
   const ctx=await remoteContext();
-  await reportVersionCoherence(ctx.root,{displayMode:'ascii'});
+  await synchronizeOneShotRuntime(ctx,{displayMode:'ascii'});
   const result=invokeController(ctx,command,{allowFailure:true});
   process.exitCode=result.status;
 }

package/src/machine-fs-mcp-tools.mjs

@@ -38,7 +38,7 @@ export function registerMachineFsTools(server, { runtime }) {
   });
   server.registerTool('machine_fs_read', {
     description:'Read one bounded byte range from a root-relative regular file.',
-    inputSchema:z.strictObject({ root_id:id, path:rel, offset:z.number().int().min(-4*1024*1024).max(4*1024*1024).default(0), max_bytes:z.number().int().min(1).max(4*1024*1024).default(65536), hash_file:z.boolean().default(false), timeout_ms:z.number().int().min(100).max(180000).default(30000) }),
+    inputSchema:z.strictObject({ root_id:id, path:rel, offset:z.number().int().min(-4*1024*1024).max(Number.MAX_SAFE_INTEGER).default(0), max_bytes:z.number().int().min(1).max(4*1024*1024).default(65536), hash_file:z.boolean().default(false), timeout_ms:z.number().int().min(100).max(180000).default(30000) }),
     outputSchema:machineFsReadOutputSchema
   }, async ({root_id,path,offset,max_bytes,hash_file,timeout_ms}) => {
     try { return ok(machineFsReadOutputSchema, await runtime.read({rootId:root_id,relativePath:path,offset,maxBytes:max_bytes,hashFile:hash_file,timeoutMs:timeout_ms})); }

package/src/machine-fs.mjs

@@ -21,10 +21,10 @@ const MAX_DIRECTORY_IDENTITY_ENTRIES = 4096;
 const sha256Bytes = bytes => createHash('sha256').update(bytes).digest('hex');
 const sha256Object = value => sha256Bytes(Buffer.from(canonicalJson(value), 'utf8'));
 const nowUtc = () => new Date().toISOString();
-async function sha256File(file) {
+async function sha256File(file, signal = undefined) {
   const hash = createHash('sha256');
   await new Promise((resolve, reject) => {
-    const stream = createReadStream(file);
+    const stream = createReadStream(file, { signal });
     stream.on('data', chunk => hash.update(chunk));
     stream.once('error', reject);
     stream.once('end', resolve);
@@ -35,11 +35,13 @@ async function sha256File(file) {
 const machineFsReadWorkerPath = fileURLToPath(new URL('./machine-fs-read-worker.mjs', import.meta.url));
 async function boundedReadInProcess({ file, offset, length, hashFile, timeoutMs }) {
   const handle = await open(file, 'r');
+  const abortController = new AbortController();
   let timer;
   let settled = false;
   const abort = new Promise((_, reject) => {
     timer = setTimeout(() => {
       settled = true;
+      abortController.abort();
       void handle.close().catch(() => {});
       reject(new Error(`machine fs read timed out after ${timeoutMs}ms`));
     }, timeoutMs);
@@ -50,7 +52,7 @@ async function boundedReadInProcess({ file, offset, length, hashFile, timeoutMs
       const buffer = Buffer.alloc(length);
       const result = length ? await handle.read(buffer, 0, length, offset) : { bytesRead: 0 };
       let fileSha256 = null;
-      if (hashFile) fileSha256 = await sha256File(file);
+      if (hashFile) fileSha256 = await sha256File(file, abortController.signal);
       return { schema: 'deadbyte.machine-fs-read-worker.v1', bytes_read: result.bytesRead,
         data_base64: buffer.subarray(0, result.bytesRead).toString('base64'), file_sha256: fileSha256 };
     })();
@@ -408,13 +410,14 @@ export function createMachineFsRuntime({ policy, signingKeyPath, verifyKeyPath,
     return { status: 'ok', root_id: rootId, path: found.relative, entries, next_cursor: nextCursor };
   }
   async function readRange({ rootId, relativePath, offset = 0, maxBytes = 65536, hashFile = false, timeoutMs = 30000 }) {
-    if (!Number.isInteger(offset) || offset < -policy.max_read_bytes || offset > policy.max_read_bytes) throw new Error(`machine fs read offset must be in [-${policy.max_read_bytes}, ${policy.max_read_bytes}]`);
+    if (!Number.isSafeInteger(offset) || offset < -policy.max_read_bytes) throw new Error(`machine fs read offset must be a safe integer >= -${policy.max_read_bytes}`);
     if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > policy.max_read_bytes) throw new Error(`machine fs max_bytes must be in [1, ${policy.max_read_bytes}]`);
     if (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 180000) throw new Error('machine fs read timeout_ms must be in [100, 180000]');
     const grant = await assertCodingReadAllowed(policy, rootId);
     const found = await resolveExisting(policy, grant, rootId, relativePath, 'read', false);
     const info = await lstat(found.resolved);
     if (!info.isFile()) throw new Error('machine fs read target must be a regular file');
+    if (!Number.isSafeInteger(info.size)) throw new Error('machine fs read file size exceeds safe integer range');
     const effectiveOffset = offset < 0 ? Math.max(0, info.size + offset) : offset;
     if (effectiveOffset > info.size) throw new Error('machine fs read offset exceeds file size');
     const length = Math.min(maxBytes, info.size - effectiveOffset);

package/src/remote-authority.mjs

@@ -11,6 +11,16 @@ export function authorityVector(mode='default'){
   });
 }
 
+export function authorityRestorePlan(snapshot){
+  const disarm=[],arm=[];
+  for(const plane of AUTHORITY_PLANES){
+    const entry=snapshot?.authority?.[plane];
+    if(!entry||typeof entry.armed!=='boolean') throw new Error(`authority ${plane} observation invalid`);
+    (entry.armed?arm:disarm).push(`${entry.armed?'arm':'disarm'}${plane}`);
+  }
+  return Object.freeze([...disarm,...arm]);
+}
+
 export function parseAuthorityObservation(raw){
   let value;
   try{value=typeof raw==='string'?JSON.parse(raw.replace(/^\uFEFF/,'')):raw;}

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.39';
+export const DEADBYTE_VERSION = '0.15.41';
 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/r59-tool-surface-compat.test.mjs

@@ -71,7 +71,7 @@ async function captureCurrentSurface(){
   }
 }
 
-test('R59 compact client-visible tool names and schemas match sealed 0.15.35 baseline',async()=>{
+test('R59 compact baseline changes only at the explicitly authorized R64 read-offset bound',async()=>{
   const raw=JSON.parse(await readFile(fixturePath,'utf8'));
   assert.equal(raw.schema,'deadbyte.tool-surface-baseline.v1');
   assert.equal(raw.release_id,'v0.15.35-1b5715b276facbc0');
@@ -82,9 +82,19 @@ test('R59 compact client-visible tool names and schemas match sealed 0.15.35 bas
   const diff=diffToolSurface(baseline,current);
   assert.deepEqual(diff.added,[]);
   assert.deepEqual(diff.removed,[]);
-  assert.deepEqual(diff.schema_changed,[]);
-  assert.equal(diff.unchanged.length,43);
-  assert.equal(current.surface_sha256,baseline.surface_sha256);
+  const packageVersion=JSON.parse(await readFile(path.join(repoRoot,'package.json'),'utf8')).version;
+  if(packageVersion==='0.15.41'){
+    assert.deepEqual(diff.schema_changed,['machine_fs']);
+    assert.equal(diff.unchanged.length,42);
+    const prior=baseline.tools.find(tool=>tool.name==='machine_fs');
+    const present=current.tools.find(tool=>tool.name==='machine_fs');
+    assert.equal(present.output_sha256,prior.output_sha256,'output contract must remain unchanged');
+    assert.notEqual(present.input_sha256,prior.input_sha256,'R64 must expose the widened read offset');
+  }else{
+    assert.deepEqual(diff.schema_changed,[]);
+    assert.equal(diff.unchanged.length,43);
+    assert.equal(current.surface_sha256,baseline.surface_sha256);
+  }
   console.log(JSON.stringify({baseline_release:raw.release_id,surface_sha256:current.surface_sha256,
     unchanged:diff.unchanged.length,added:diff.added,removed:diff.removed,schema_changed:diff.schema_changed}));
 });

package/test/r62-release-contract.test.mjs

@@ -4,6 +4,7 @@ import {readFile} from 'node:fs/promises';
 
 const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
 const json=rel=>read(rel).then(raw=>JSON.parse(raw.replace(/^\uFEFF/,'')));
+const currentPackage=await json('package.json');
 const PARENT={
  version:'0.15.38',
  release_id:'v0.15.38-917901b3fcb2a77f',
@@ -11,7 +12,7 @@ const PARENT={
  generation_manifest_sha256:'9d320a8af1ba8e9e6a23552f35263da2670c00af1355464820552d849d9033c6'
 };
 
-test('R62 identity binds exact sealed 0.15.38 parent and transaction reconciliation scope',async()=>{
+test('R62 identity binds exact sealed 0.15.38 parent and transaction reconciliation scope',{skip:currentPackage.version!=='0.15.39'},async()=>{
  const [pkg,lock,bridge,release,provenance,matrix,sbom,version,gate]=await Promise.all([
   json('package.json'),json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
   json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs'),

package/test/r63-one-shot-coherence.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
+const authority=await import('../src/remote-authority.mjs');
+
+test('R63 one-shot upgrade restore plan reproduces the exact pre-upgrade authority vector',()=>{
+  assert.equal(typeof authority.authorityRestorePlan,'function','authorityRestorePlan must exist');
+  const snapshot={
+    authority:{
+      process:{configured:true,armed:true,reason:'standing-grant'},
+      coding:{configured:true,armed:true,reason:'standing-grant'},
+      autonomous:{configured:true,armed:true,reason:'standing-grant'},
+      desktop:{configured:true,armed:false,reason:'disarmed'},
+      host:{configured:true,armed:true,reason:'standing-grant'}
+    }
+  };
+  assert.deepEqual(authority.authorityRestorePlan(snapshot),[
+    'disarmdesktop',
+    'armprocess','armcoding','armautonomous','armhost'
+  ]);
+});
+
+test('R63 explicit remote command synchronizes runtime before dispatch instead of warn-only skew reporting',async()=>{
+  const source=await readFile(path.join(root,'src','deadbyte-cli.mjs'),'utf8');
+  const start=source.indexOf('async function runRemote(args){');
+  const end=source.indexOf('\nasync function runSupervisor(',start);
+  assert.ok(start>=0&&end>start,'runRemote source boundary missing');
+  const body=source.slice(start,end);
+  const sync=body.indexOf("await synchronizeOneShotRuntime(ctx,{displayMode:'ascii'});");
+  const dispatch=body.indexOf('invokeController(ctx,command,{allowFailure:true})');
+  assert.ok(sync>=0,'one-shot remote command must synchronize the active runtime');
+  assert.ok(dispatch>sync,'runtime synchronization must complete before controller dispatch');
+  assert.doesNotMatch(body,/reportVersionCoherence/,'warn-only skew path must not remain in one-shot dispatch');
+});

package/test/r63-release-contract.test.mjs

@@ -0,0 +1,59 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+const json=rel=>read(rel).then(raw=>JSON.parse(raw.replace(/^\uFEFF/,'')));
+const currentPackage=await json('package.json');
+const PARENT={
+ version:'0.15.39',
+ release_id:'v0.15.39-3cda3b1c65b7b7c5',
+ manifest_sha256:'3cda3b1c65b7b7c561c5a8617156ab87d69cf162f447f3e99a4cb4a76471b3de',
+ generation_manifest_sha256:'f47cb96083679e764725df1bde6eda53169a39f55772c173ab22f89a1dfaa7ab'
+};
+
+test('R63 identity binds exact active 0.15.39 parent and one-shot runtime coherence repair',{skip:currentPackage.version!=='0.15.40'},async()=>{
+ const pkg=await json('package.json');
+ assert.equal(pkg.version,'0.15.40');
+ assert.match(pkg.scripts['r63:focused:test'],/r63-one-shot-coherence\.test\.mjs/);
+ assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r63-prepublish.ps1');
+
+ const [lock,bridge,release,provenance,matrix,sbom,version,gate]=await Promise.all([
+  json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),json('PROVENANCE.json'),
+  json('TEST-MATRIX.json'),json('SBOM.cdx.json'),read('src/version.mjs'),read('scripts/gate-windows-r63-prepublish.ps1')
+ ]);
+ assert.equal(lock.version,pkg.version);
+ assert.equal(lock.packages[''].version,pkg.version);
+ assert.equal(bridge.version,pkg.version);
+ assert.match(version,/DEADBYTE_VERSION = '0\.15\.40'/);
+ assert.equal(release.version,pkg.version);
+ assert.equal(release.train,'R63');
+ assert.equal(release.parent.version,PARENT.version);
+ assert.equal(release.parent.release_id,PARENT.release_id);
+ assert.equal(release.parent.manifest_sha256,PARENT.manifest_sha256);
+ assert.equal(release.parent.generation_manifest_sha256,PARENT.generation_manifest_sha256);
+ assert.deepEqual(release.runtime_predecessor,{
+  release_id:PARENT.release_id,
+  manifest_sha256:PARENT.manifest_sha256,
+  generation_manifest_sha256:PARENT.generation_manifest_sha256
+ });
+ assert.equal(provenance.version,pkg.version);
+ assert.equal(provenance.parent_release_id,PARENT.release_id);
+ assert.equal(provenance.parent_manifest_sha256,PARENT.manifest_sha256);
+ assert.equal(provenance.parent_generation_manifest_sha256,PARENT.generation_manifest_sha256);
+ assert.equal(matrix.version,pkg.version);
+ assert.equal(matrix.train,'R63');
+ assert.equal(sbom.metadata.component.version,pkg.version);
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r63:0.15.40');
+ assert.equal(release.r63_one_shot_runtime_coherence.public_surface_tool_count,43);
+ assert.equal(release.r63_one_shot_runtime_coherence.new_authority_scopes,0);
+ assert.equal(release.r63_one_shot_runtime_coherence.one_shot_auto_coherence,true);
+ assert.equal(release.r63_one_shot_runtime_coherence.pre_upgrade_authority_snapshot,true);
+ assert.equal(release.r63_one_shot_runtime_coherence.exact_authority_restore_verified,true);
+ assert.equal(release.r63_one_shot_runtime_coherence.warn_only_skew_path_removed,true);
+ assert.equal(release.r63_one_shot_runtime_coherence.stable_final_claim,false);
+ assert.match(gate,/v0\.15\.39-3cda3b1c65b7b7c5/);
+ assert.match(gate,/3cda3b1c65b7b7c561c5a8617156ab87d69cf162f447f3e99a4cb4a76471b3de/);
+ assert.match(gate,/f47cb96083679e764725df1bde6eda53169a39f55772c173ab22f89a1dfaa7ab/);
+ assert.match(gate,/r63:focused:test/);
+});

package/test/r64-machine-fs-large-read.test.mjs

@@ -0,0 +1,136 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import fs from 'node:fs';
+import {EventEmitter} from 'node:events';
+import {mkdtemp, mkdir, readFile, writeFile, rm} from 'node:fs/promises';
+import {syncBuiltinESMExports} from 'node:module';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {loadCodingPolicy} from '../src/coding-plane.mjs';
+import {createMachineFsRuntime} from '../src/machine-fs.mjs';
+import {generateTrustKeypair} from '../src/trust.mjs';
+import {machineFsGatewayInputSchema} from '../src/compact-gateway-mcp-tools.mjs';
+import {registerMachineFsTools} from '../src/machine-fs-mcp-tools.mjs';
+
+const PAGE=4*1024*1024;
+
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+async function fixture(t,{read=true}={}){
+  const root=await mkdtemp(path.join(tmpdir(),'deadbyte-r64-read-'));
+  t.after(()=>rm(root,{recursive:true,force:true}));
+  const project=path.join(root,'project');
+  await mkdir(project);
+  const policyPath=path.join(root,'policy.json');
+  await writeFile(policyPath,JSON.stringify({
+    schema:'deadbyte.coding-policy.v1',enabled:true,
+    lease_file:path.join(root,'coding-grant.json'),evidence_dir:path.join(root,'evidence'),
+    roots:{project:{path:project,read,write:false,exec:false,deny_paths:[]}},
+    commands:{},max_read_bytes:PAGE,max_write_bytes:65536
+  }));
+  const policy=await loadCodingPolicy(policyPath);
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(root,'private.pem'),publicKeyPath:path.join(root,'public.pem')});
+  return {root,project,policy,keys,runtime:createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
+}
+
+test('R64 full and compact read schemas accept next_offset beyond one-page bound',()=>{
+  const server={registerTool(name,definition){if(name==='machine_fs_read')this.read=definition;}};
+  registerMachineFsTools(server,{runtime:{}});
+  const args={root_id:'project',path:'large.bin',offset:PAGE+2,max_bytes:64,hash_file:false,timeout_ms:30000};
+  assert.equal(server.read.inputSchema.safeParse(args).success,true,'full tool rejects a valid next_offset');
+  assert.equal(machineFsGatewayInputSchema.safeParse({op:'read',...args}).success,true,'compact tool rejects a valid next_offset');
+  assert.equal(server.read.inputSchema.safeParse({...args,max_bytes:PAGE+1}).success,false,'per-call byte cap must remain');
+  assert.equal(machineFsGatewayInputSchema.safeParse({op:'read',...args,max_bytes:PAGE+1}).success,false);
+  assert.equal(server.read.inputSchema.safeParse({...args,offset:Number.MAX_SAFE_INTEGER+1}).success,false);
+  assert.equal(machineFsGatewayInputSchema.safeParse({op:'read',...args,offset:Number.MAX_SAFE_INTEGER+1}).success,false);
+});
+
+test('R64 reads page two using next_offset beyond 4 MiB',async t=>{
+  const f=await fixture(t);
+  const bytes=Buffer.alloc(PAGE+32,0x61);
+  bytes[0]=0x5a;
+  bytes[1]=0x5b;
+  bytes[PAGE+2]=0x7f;
+  await writeFile(path.join(f.project,'large.bin'),bytes);
+  const first=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:2,maxBytes:PAGE});
+  assert.equal(first.next_offset,PAGE+2);
+  assert.equal(first.eof,false);
+  const second=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:first.next_offset,maxBytes:64});
+  assert.equal(second.offset,PAGE+2);
+  assert.equal(Buffer.from(second.data_base64,'base64')[0],0x7f);
+  assert.equal(second.eof,true);
+  assert.equal(second.next_offset,bytes.length);
+  const atEof=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:bytes.length,maxBytes:1});
+  assert.equal(atEof.eof,true);
+  assert.equal(Buffer.from(atEof.data_base64,'base64').length,0);
+  assert.equal(atEof.next_offset,bytes.length);
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:bytes.length+1,maxBytes:1}),/exceeds file size/);
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:Number.MAX_SAFE_INTEGER+1,maxBytes:1}),/safe integer/);
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:0,maxBytes:PAGE+1}),/max_bytes/);
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:-PAGE-1,maxBytes:1}),/offset/);
+});
+
+test('R64 pages are independent observations and hash_file reveals replacement between calls',async t=>{
+  const f=await fixture(t);
+  const file=path.join(f.project,'large.bin');
+  const before=Buffer.alloc(PAGE+32,0x61);
+  const after=Buffer.alloc(PAGE+32,0x62);
+  await writeFile(file,before);
+  const first=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:2,maxBytes:PAGE,hashFile:true});
+  assert.equal(first.file_sha256,sha(before));
+  await writeFile(file,after);
+  const second=await f.runtime.read({rootId:'project',relativePath:'large.bin',offset:first.next_offset,maxBytes:64,hashFile:true});
+  assert.equal(second.file_sha256,sha(after));
+  assert.notEqual(second.file_sha256,first.file_sha256,'the caller must not treat these pages as one snapshot');
+});
+
+test('R64 a denied read root remains denied at a large offset',async t=>{
+  const f=await fixture(t,{read:false});
+  await writeFile(path.join(f.project,'large.bin'),Buffer.alloc(PAGE+16));
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:PAGE+1,maxBytes:1}),/does not allow read/);
+});
+
+test('R64 large offset does not bypass root containment',async t=>{
+  const f=await fixture(t);
+  await writeFile(path.join(f.root,'outside.bin'),Buffer.alloc(PAGE+16));
+  await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'../outside.bin',offset:PAGE+1,maxBytes:1}),/relative|traversal|path|outside/i);
+});
+
+test('R64 large-offset read retains bounded worker cancellation',async t=>{
+  const f=await fixture(t);
+  await writeFile(path.join(f.project,'large.bin'),Buffer.alloc(PAGE+16));
+  const worker=path.join(f.root,'slow-read-worker.mjs');
+  await writeFile(worker,'setTimeout(() => process.stdout.write("{}"), 30000);\n');
+  const runtime=createMachineFsRuntime({policy:f.policy,signingKeyPath:f.keys.privateKeyPath,verifyKeyPath:f.keys.publicKeyPath,readWorkerPath:worker});
+  await assert.rejects(()=>runtime.read({rootId:'project',relativePath:'large.bin',offset:PAGE+1,maxBytes:1,timeoutMs:100}),/timed out after 100ms/);
+});
+
+test('R64 default hash stream is abort-bound to read timeout',async()=>{
+  const source=await readFile(new URL('../src/machine-fs.mjs',import.meta.url),'utf8');
+  assert.ok(/createReadStream\(file,\s*\{\s*signal\s*\}\)/.test(source),'hash stream must receive the read abort signal');
+  assert.ok(/abortController\.abort\(\)/.test(source),'read timeout must abort its hash stream');
+});
+
+test('R64 timed-out default hash stream receives abort and stops',async t=>{
+  const f=await fixture(t);
+  await writeFile(path.join(f.project,'large.bin'),Buffer.alloc(PAGE+16));
+  const original=fs.createReadStream;
+  let observedAbort=false;
+  fs.createReadStream=(_file,options={})=>{
+    const stream=new EventEmitter();
+    options.signal?.addEventListener('abort',()=>{
+      observedAbort=true;
+      queueMicrotask(()=>stream.emit('error',new Error('aborted')));
+    },{once:true});
+    return stream;
+  };
+  syncBuiltinESMExports();
+  try{
+    await assert.rejects(()=>f.runtime.read({rootId:'project',relativePath:'large.bin',offset:PAGE+1,maxBytes:1,hashFile:true,timeoutMs:100}),/timed out after 100ms/);
+    assert.equal(observedAbort,true,'default hash stream continued after timeout');
+  }finally{
+    fs.createReadStream=original;
+    syncBuiltinESMExports();
+  }
+});

package/test/r64-release-contract.test.mjs

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+const read=rel=>readFile(new URL('../'+rel,import.meta.url),'utf8');
+const json=async rel=>JSON.parse((await read(rel)).replace(/^\uFEFF/,''));
+const sourceSha='d6f75feada9ad0ae2c248b3a833ac9cf0e04150d2430ddaa70b3dfb64a0b0a86';
+const runtime={
+  release_id:'v0.15.39-3cda3b1c65b7b7c5',
+  manifest_sha256:'3cda3b1c65b7b7c561c5a8617156ab87d69cf162f447f3e99a4cb4a76471b3de',
+  generation_manifest_sha256:'f47cb96083679e764725df1bde6eda53169a39f55772c173ab22f89a1dfaa7ab'
+};
+
+test('R64 release identity distinguishes unsealed source predecessor from active runtime predecessor',async()=>{
+  const [pkg,lock,bridge,release,provenance,matrix,sbom,scope,gaps,version,gate]=await Promise.all([
+    json('package.json'),json('package-lock.json'),json('bridge/package.json'),json('RELEASE.json'),
+    json('PROVENANCE.json'),json('TEST-MATRIX.json'),json('SBOM.cdx.json'),json('docs/R64-SCOPE.json'),
+    json('docs/R64-REFERENCE-GAP-MATRIX.json'),read('src/version.mjs'),read('scripts/gate-windows-r64-prepublish.ps1')
+  ]);
+  assert.equal(pkg.version,'0.15.41');
+  assert.equal(lock.version,pkg.version);
+  assert.equal(lock.packages[''].version,pkg.version);
+  assert.equal(bridge.version,pkg.version);
+  assert.match(version,/DEADBYTE_VERSION = '0\.15\.41'/);
+  assert.equal(release.version,pkg.version);
+  assert.equal(release.train,'R64');
+  assert.equal(provenance.version,pkg.version);
+  assert.equal(matrix.version,pkg.version);
+  assert.equal(matrix.train,'R64');
+  assert.equal(sbom.metadata.component.version,pkg.version);
+  assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r64:0.15.41');
+  assert.deepEqual(release.runtime_predecessor,runtime);
+  assert.deepEqual(provenance.runtime_predecessor,runtime);
+  assert.equal(release.source_predecessor.version,'0.15.40');
+  assert.equal(release.source_predecessor.manifest_file_sha256,sourceSha);
+  assert.equal(release.source_predecessor.release_status,'NOT_PROVEN_RELEASED');
+  assert.equal(provenance.source_predecessor_manifest_file_sha256,sourceSha);
+  assert.equal(scope.source_predecessor.manifest_sha256,sourceSha);
+  assert.deepEqual(scope.runtime_predecessor,runtime);
+  assert.equal(release.r64_bounded_large_file_read.new_public_tools,0);
+  assert.equal(release.r64_bounded_large_file_read.new_authority_scopes,0);
+  assert.equal(release.r64_bounded_large_file_read.cross_page_atomic_snapshot_claim,false);
+  assert.equal(matrix.r64.prepublish_only,true);
+  assert.equal(gaps.references.length,7);
+  assert.equal(gaps.references.filter(row=>row.proposed_action.startsWith('ADAPT')).length,1);
+  assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r64-prepublish.ps1');
+  assert.match(pkg.scripts['r64:focused:test'],/r64-machine-fs-large-read\.test\.mjs/);
+  assert.match(gate,/d6f75feada9ad0ae2c248b3a833ac9cf0e04150d2430ddaa70b3dfb64a0b0a86/);
+  assert.match(gate,/v0\.15\.39-3cda3b1c65b7b7c5/);
+  assert.doesNotMatch(gate,/npm\.cmd publish|--publish-only/);
+});

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

@@ -1,5 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
 import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -645,13 +646,14 @@ winTest('explicit remote status remains a one-shot controller command',async()=>
   }finally{await rm(fx.dir,{recursive:true,force:true});}
 });
 
-winTest('explicit remote status reports CLI package and active runtime VERSION SKEW',async()=>{
+winTest('explicit remote status keeps the coherent runtime one-shot and silent',async()=>{
   const fx=await fixture({statusOnline:true});
   try{
-    const manifest='1'.repeat(64),generation='2'.repeat(64),launcher='3'.repeat(64);
+    const manifest=createHash('sha256').update(await readFile(path.join(root,'MANIFEST.SHA256'))).digest('hex');
+    const generation='2'.repeat(64),launcher='3'.repeat(64);
     await writeFile(path.join(fx.state,'active-release.json'),JSON.stringify({
-      schema:'deadbyte.active-release.v1',release_id:`v0.15.16-${manifest.slice(0,16)}`,version:'0.15.16',manifest_sha256:manifest,
-      release_root:'C:/deadbyte/releases/0.15.16',generation_root:'C:/deadbyte/generations/0.15.16',generation_manifest_sha256:generation,
+      schema:'deadbyte.active-release.v1',release_id:`v${DEADBYTE_VERSION}-${manifest.slice(0,16)}`,version:DEADBYTE_VERSION,manifest_sha256:manifest,
+      release_root:'C:/deadbyte/releases/current',generation_root:'C:/deadbyte/generations/current',generation_manifest_sha256:generation,
       launcher_sha256:launcher,config_path:'C:/deadbyte/config.psd1'
     }),'utf8');
     const child=spawn(process.execPath,[cliPath,'remote','status'],{env:fx.env,stdio:['ignore','pipe','pipe'],windowsHide:true});
@@ -659,7 +661,7 @@ winTest('explicit remote status reports CLI package and active runtime VERSION S
     const ended=await Promise.race([output.closed,sleep(6000).then(()=>({timeout:true}))]);
     assert.equal(ended.timeout,undefined);
     assert.equal(ended.code,0,output.stderr);
-    assert.ok(output.stderr.includes(`VERSION SKEW: CLI package ${DEADBYTE_VERSION}; active runtime 0.15.16`),output.stderr);
+    assert.doesNotMatch(output.stderr,/VERSION SKEW/);
     assert.deepEqual(await traceCommands(fx.trace),['status']);
   }finally{await rm(fx.dir,{recursive:true,force:true});}
 });