deadbyte-mcp 0.15.38 → 0.15.41

package/test/r62-doctor-transactions-reconcile.test.mjs

@@ -0,0 +1,208 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdir,mkdtemp,writeFile,readFile} from 'node:fs/promises';
+import {generateKeyPairSync,createHash,sign} from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import {inspectDoctorTransactions} from '../src/doctor-transactions-r58.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+ ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+const domain=Buffer.from('DEADBYTE-R27-SLOT-UPDATE-V1\0');
+
+function envelope(body,keys){
+ const bodyBytes=Buffer.from(canonicalJson(body),'utf8');
+ const unsigned={
+  body,
+  body_sha256:sha(bodyBytes),
+  attestation:{
+   algorithm:'ed25519',
+   domain:'DEADBYTE-R27-SLOT-UPDATE-V1',
+   key_id:sha(keys.publicKey.export({type:'spki',format:'der'})),
+   signature_base64:sign(null,Buffer.concat([domain,bodyBytes]),keys.privateKey).toString('base64')
+  }
+ };
+ return {...unsigned,receipt_sha256:sha(Buffer.from(canonicalJson(unsigned),'utf8'))};
+}
+
+test('R62 doctor reconciles signed terminal receipts instead of warning on stale nonterminal journal phases',async()=>{
+ const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r62-doctor-reconcile-'));
+ const trust=path.join(root,'trust');
+ const updates=path.join(root,'evidence','updates');
+ await mkdir(trust,{recursive:true});
+ await mkdir(updates,{recursive:true});
+ const keys=generateKeyPairSync('ed25519');
+ await writeFile(path.join(trust,'ed25519-public.pem'),keys.publicKey.export({type:'spki',format:'pem'}));
+
+ const writeTransaction=async(name,state,receiptName,receiptBody)=>{
+  const dir=path.join(updates,name);
+  await mkdir(dir);
+  const statePath=path.join(dir,'state.json');
+  const stateBytes=JSON.stringify(state);
+  await writeFile(statePath,stateBytes);
+  await writeFile(path.join(dir,receiptName),JSON.stringify(envelope(receiptBody,keys)));
+  return {statePath,stateBytes};
+ };
+
+ const success=await writeTransaction(
+  'success',
+  {schema:'deadbyte.r27-slot-update-state.v1',update_id:'success',phase:'pointer_committed'},
+  'receipt.json',
+  {schema:'deadbyte.r27-slot-update-receipt.v1',update_id:'success',rollback_performed:false}
+ );
+ const failure=await writeTransaction(
+  'failure',
+  {schema:'deadbyte.r27-slot-update-state.v1',update_id:'failure',phase:'candidate_prepared'},
+  'failure-receipt.json',
+  {schema:'deadbyte.r27-slot-update-failure.v1',update_id:'failure',failed_at_utc:'2026-10-04T00:00:00.000Z'}
+ );
+
+ const result=await inspectDoctorTransactions(root);
+ assert.equal(result.status,'PASS');
+ assert.equal(result.findings.some(f=>f.level==='WARN'),false);
+ const summary=result.findings.find(f=>f.evidence?.receipt_verification_performed===true);
+ assert.ok(summary,'doctor must report signed receipt verification');
+ assert.equal(summary.evidence.verified_terminal_receipts,2);
+ assert.equal(summary.evidence.unresolved_transactions,0);
+ assert.equal(await readFile(success.statePath,'utf8'),success.stateBytes);
+ assert.equal(await readFile(failure.statePath,'utf8'),failure.stateBytes);
+});
+
+
+test('R62 doctor default transaction budget covers more than the legacy 256-entry ceiling while remaining bounded',async()=>{
+ const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r62-doctor-budget-'));
+ const updates=path.join(root,'evidence','updates');
+ await mkdir(updates,{recursive:true});
+ for(let index=0;index<300;index++){
+  const dir=path.join(updates,`tx-${String(index).padStart(3,'0')}`);
+  await mkdir(dir);
+  await writeFile(path.join(dir,'state.json'),JSON.stringify({
+   schema:'deadbyte.r27-slot-update-state.v1',
+   update_id:`tx-${index}`,
+   phase:'superseded'
+  }));
+ }
+ const result=await inspectDoctorTransactions(root);
+ assert.equal(result.status,'PASS');
+ assert.equal(result.findings.some(f=>f.evidence?.inventory_complete===false),false);
+ const summary=result.findings.find(f=>f.evidence?.receipt_verification_performed===true);
+ assert.ok(summary);
+ assert.equal(summary.evidence.states_checked,300);
+ await assert.rejects(inspectDoctorTransactions(root,{maxEntries:1025}),/budget invalid/);
+});
+
+
+test('R62 doctor verifies signed receipts even when the journal already claims a terminal phase',async()=>{
+ const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r62-doctor-terminal-proof-'));
+ const trust=path.join(root,'trust');
+ const updates=path.join(root,'evidence','updates');
+ await mkdir(trust,{recursive:true});
+ await mkdir(updates,{recursive:true});
+ const keys=generateKeyPairSync('ed25519');
+ await writeFile(path.join(trust,'ed25519-public.pem'),keys.publicKey.export({type:'spki',format:'pem'}));
+
+ const provenDir=path.join(updates,'proven');
+ await mkdir(provenDir);
+ await writeFile(path.join(provenDir,'state.json'),JSON.stringify({
+  schema:'deadbyte.r27-slot-update-state.v1',
+  update_id:'proven',
+  phase:'completed'
+ }));
+ await writeFile(path.join(provenDir,'receipt.json'),JSON.stringify(envelope({
+  schema:'deadbyte.r27-slot-update-receipt.v1',
+  update_id:'proven',
+  rollback_performed:false
+ },keys)));
+
+ const proven=await inspectDoctorTransactions(root);
+ assert.equal(proven.status,'PASS');
+ const provenSummary=proven.findings.find(f=>f.evidence?.receipt_verification_performed===true);
+ assert.equal(provenSummary.evidence.verified_terminal_receipts,1);
+
+ const unprovenDir=path.join(updates,'unproven');
+ await mkdir(unprovenDir);
+ await writeFile(path.join(unprovenDir,'state.json'),JSON.stringify({
+  schema:'deadbyte.r27-slot-update-state.v1',
+  update_id:'unproven',
+  phase:'completed'
+ }));
+ const unproven=await inspectDoctorTransactions(root);
+ assert.equal(unproven.status,'WARN');
+ assert.ok(unproven.findings.some(f=>f.evidence?.recorded_phase==='completed'));
+});
+
+
+test('R62 doctor fails closed on tampered or missing claimed terminal receipts without mutating journals',async()=>{
+ const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r62-doctor-adversarial-'));
+ const trust=path.join(root,'trust');
+ const updates=path.join(root,'evidence','updates');
+ await mkdir(trust,{recursive:true});
+ await mkdir(updates,{recursive:true});
+ const keys=generateKeyPairSync('ed25519');
+ await writeFile(path.join(trust,'ed25519-public.pem'),keys.publicKey.export({type:'spki',format:'pem'}));
+
+ const tamperedDir=path.join(updates,'tampered');
+ await mkdir(tamperedDir);
+ const tamperedStatePath=path.join(tamperedDir,'state.json');
+ const tamperedState=JSON.stringify({
+  schema:'deadbyte.r27-slot-update-state.v1',
+  update_id:'tampered',
+  phase:'completed'
+ });
+ await writeFile(tamperedStatePath,tamperedState);
+ const good=envelope({
+  schema:'deadbyte.r27-slot-update-receipt.v1',
+  update_id:'tampered',
+  rollback_performed:false
+ },keys);
+ const bad={...good,attestation:{...good.attestation,signature_base64:Buffer.alloc(64).toString('base64')}};
+ await writeFile(path.join(tamperedDir,'receipt.json'),JSON.stringify(bad));
+
+ const missingDir=path.join(updates,'missing');
+ await mkdir(missingDir);
+ const missingStatePath=path.join(missingDir,'state.json');
+ const missingState=JSON.stringify({
+  schema:'deadbyte.r27-slot-update-state.v1',
+  update_id:'missing',
+  phase:'failed_receipted'
+ });
+ await writeFile(missingStatePath,missingState);
+
+ const result=await inspectDoctorTransactions(root);
+ assert.equal(result.status,'FAIL');
+ assert.ok(result.findings.some(f=>f.evidence?.check==='terminal_receipt_verification'));
+ assert.ok(result.findings.some(f=>f.evidence?.check==='missing_failure_receipt'));
+ assert.equal(await readFile(tamperedStatePath,'utf8'),tamperedState);
+ assert.equal(await readFile(missingStatePath,'utf8'),missingState);
+});
+
+
+test('R62 doctor reconciles a signed R31 rollback failure receipt by rollback_id',async()=>{
+ const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r62-r31-failure-proof-'));
+ const trust=path.join(root,'trust');
+ const dir=path.join(root,'evidence','updates','rollback-failure');
+ await mkdir(trust,{recursive:true});
+ await mkdir(dir,{recursive:true});
+ const keys=generateKeyPairSync('ed25519');
+ await writeFile(path.join(trust,'ed25519-public.pem'),keys.publicKey.export({type:'spki',format:'pem'}));
+ const rollbackId='r31-rollback-r62-fixture';
+ await writeFile(path.join(dir,'state.json'),JSON.stringify({
+  schema:'deadbyte.r31-slot-rollback-state.v1',
+  rollback_id:rollbackId,
+  phase:'failed'
+ }));
+ await writeFile(path.join(dir,'failure-receipt.json'),JSON.stringify(envelope({
+  schema:'deadbyte.r31-slot-rollback-failure.v1',
+  rollback_id:rollbackId,
+  failed_at_utc:'2026-10-04T00:00:00.000Z',
+  error:{name:'Error',message:'fixture'}
+ },keys)));
+ const result=await inspectDoctorTransactions(root);
+ assert.equal(result.status,'PASS');
+ const summary=result.findings.find(f=>f.evidence?.receipt_verification_performed===true);
+ assert.equal(summary.evidence.verified_terminal_receipts,1);
+ assert.equal(summary.evidence.verified_failure_receipts,1);
+ assert.equal(summary.evidence.unresolved_transactions,0);
+});

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

@@ -0,0 +1,60 @@
+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.38',
+ release_id:'v0.15.38-917901b3fcb2a77f',
+ manifest_sha256:'917901b3fcb2a77f696fedc539bd97c567d9dc59345779906fc633d11ea4bcfb',
+ generation_manifest_sha256:'9d320a8af1ba8e9e6a23552f35263da2670c00af1355464820552d849d9033c6'
+};
+
+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'),
+  read('scripts/gate-windows-r62-prepublish.ps1')
+ ]);
+ assert.equal(pkg.version,'0.15.39');
+ 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\.39'/);
+ assert.equal(release.version,pkg.version);
+ assert.equal(release.train,'R62');
+ 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,'R62');
+ assert.equal(sbom.metadata.component.version,pkg.version);
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r62:0.15.39');
+ assert.equal(release.r62_transaction_reconciliation.public_surface_tool_count,43);
+ assert.equal(release.r62_transaction_reconciliation.new_authority_scopes,0);
+ assert.equal(release.r62_transaction_reconciliation.signed_terminal_receipt_reconciliation,true);
+ assert.equal(release.r62_transaction_reconciliation.r31_signed_failure_receipts,true);
+ assert.equal(release.r62_transaction_reconciliation.transaction_inventory_default_max_entries,1024);
+ assert.equal(release.r62_transaction_reconciliation.historical_unsigned_residue_preserved,true);
+ assert.equal(release.r62_transaction_reconciliation.stable_final_claim,false);
+ assert.match(pkg.scripts['r62:focused:test'],/r62-doctor-transactions-reconcile\.test\.mjs/);
+ assert.match(pkg.scripts['r62:focused:test'],/r62-rollback-failure-receipt\.test\.mjs/);
+ assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r62-prepublish.ps1');
+ assert.match(gate,/v0\.15\.38-917901b3fcb2a77f/);
+ assert.match(gate,/917901b3fcb2a77f696fedc539bd97c567d9dc59345779906fc633d11ea4bcfb/);
+ assert.match(gate,/9d320a8af1ba8e9e6a23552f35263da2670c00af1355464820552d849d9033c6/);
+ assert.match(gate,/r62:focused:test/);
+ assert.doesNotMatch(gate,/v0\.15\.37-1cfecd7889419da7/);
+});

package/test/r62-rollback-failure-receipt.test.mjs

@@ -0,0 +1,19 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+
+test('R62 R31 rollback failures emit a signed subject-bound failure receipt before returning failure',async()=>{
+ const source=await readFile(new URL('../src/runtime-update.mjs',import.meta.url),'utf8');
+ assert.match(source,/const ROLLBACK_FAILURE_SCHEMA='deadbyte\.r31-slot-rollback-failure\.v1'/);
+ const start=source.indexOf('export async function performSlotRollback');
+ const end=source.indexOf('export async function runSlotUpdateCli',start);
+ assert.ok(start>=0&&end>start);
+ const perform=source.slice(start,end);
+ assert.match(perform,/failurePath=path\.join\(evidenceDir,'failure-receipt\.json'\)/);
+ assert.match(perform,/schema:ROLLBACK_FAILURE_SCHEMA/);
+ assert.match(perform,/rollback_id:rollbackId/);
+ assert.match(perform,/activation_receipt_sha256:activationEnvelope\.receipt_sha256/);
+ assert.match(perform,/await writeEnvelope\(failurePath,failure,key\)/);
+ assert.match(perform,/writeState\(statePath,journal,'failed_receipted'/);
+ assert.match(perform,/wrapped\.failureReceiptPath=failureReceipt\?failurePath:null/);
+});

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});}
 });