deadbyte-mcp 0.15.74 → 0.15.75

package/test/r193-release-identity.test.mjs

@@ -7,40 +7,41 @@ import path from 'node:path';
 const root=fileURLToPath(new URL('..',import.meta.url));
 const json=async file=>JSON.parse(await readFile(path.join(root,file),'utf8'));
 const parent={
- version:'0.15.72',
- release_id:'v0.15.72-0a5d9436e06e2d9e',
- manifest_sha256:'0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90',
- generation_manifest_sha256:'aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0'
+ version:'0.15.74',
+ release_id:'v0.15.74-e84bf4eed16e9443',
+ manifest_sha256:'e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47',
+ generation_manifest_sha256:'598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7'
 };
-const parentTarball='15ab5d9808cbca342aee3f64c6d1123e8fbb72964674eab460e355c8675bf84d';
+const parentTarball='5da436a3f8068107e74caf6da58ff1e211d4a62f94266853136b601762f36f0c';
 
-test('R193 package identity binds exact active and published 0.15.72 predecessor',async()=>{
+test('R206 package identity preserves the R193 owner boundary and separates R205 source from active R194 runtime',async()=>{
  const [pkg,bridge,release,provenance,matrix,sbom,versionSource]=await Promise.all([
   json('package.json'),json('bridge/package.json'),json('RELEASE.json'),json('PROVENANCE.json'),
   json('TEST-MATRIX.json'),json('SBOM.cdx.json'),readFile(path.join(root,'src','version.mjs'),'utf8')]);
- assert.equal(pkg.version,'0.15.74');
- assert.equal(bridge.version,'0.15.74');
- assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.74'/);
- assert.equal(release.version,'0.15.74');
- assert.equal(release.train,'R194');
+ assert.equal(pkg.version,'0.15.75');
+ assert.equal(bridge.version,'0.15.75');
+ assert.match(versionSource,/DEADBYTE_VERSION = '0\.15\.75'/);
+ assert.equal(release.version,'0.15.75');
+ assert.equal(release.train,'R206');
  for(const key of Object.keys(parent)){
   assert.equal(release.parent[key],parent[key]);
   assert.equal(release.runtime_predecessor[key],parent[key]);
  }
- assert.equal(release.source_predecessor.version,'0.15.73');
- assert.equal(release.source_predecessor.train,'R193');
- assert.equal(release.source_predecessor.manifest_sha256,'e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd');
- assert.equal(release.source_predecessor.tarball_sha256,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
- assert.equal(provenance.version,'0.15.74');
+ assert.equal(release.source_predecessor.version,'0.15.75');
+ assert.equal(release.source_predecessor.train,'R205');
+ assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+ assert.equal(release.source_predecessor.tarball_sha256,null);
+ assert.equal(provenance.version,'0.15.75');
  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(provenance.source_predecessor_version,'0.15.73');
- assert.equal(provenance.source_predecessor_tarball_sha256,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
- assert.equal(matrix.version,'0.15.74');
- assert.equal(matrix.train,'R194');
- assert.equal(sbom.metadata.component.version,'0.15.74');
- assert.match(sbom.serialNumber,/r194:0\.15\.74$/);
+ assert.equal(provenance.source_predecessor_version,'0.15.75');
+ assert.equal(provenance.source_predecessor_train,'R205');
+ assert.equal(provenance.source_predecessor_tarball_sha256,null);
+ assert.equal(matrix.version,'0.15.75');
+ assert.equal(matrix.train,'R206');
+ assert.equal(sbom.metadata.component.version,'0.15.75');
+ assert.match(sbom.serialNumber,/r206:0\.15\.75$/);
 });
 
 test('R193 manifest binds every protected owner-boundary implementation file',async()=>{
@@ -50,6 +51,7 @@ test('R193 manifest binds every protected owner-boundary implementation file',as
   'scripts/r193-migrate-runtime-limited.ps1','scripts/r193-owner-keygen.mjs',
   'scripts/r193-owner-request-live.mjs','scripts/r193-owner-uac-approve.ps1',
   'scripts/r193-owner-uac-broker.mjs','scripts/r193-owner-uac-enroll-and-approve.ps1',
+  'src/r195-canonical-owner-observation.mjs',
   'src/r193-live-owner-subject.mjs','src/r193-owner-secret-acl.mjs',
   'src/r193-owner-uac-broker.mjs','test/r193-release-identity.test.mjs'
  ]) assert.match(manifest,new RegExp('  '+file.replaceAll('.','\\.')+'(?:\\r?\\n|$)'));

package/test/r193-release-readiness.test.mjs

@@ -77,11 +77,11 @@ test('R193 publisher refuses a repacked artifact that differs from closure bytes
     observedSha256:'c'.repeat(64),observedIntegrity:'sha512-other',observedShasum:'d'.repeat(40)}),/PUBLISH_BLOCKED R193.*repacked tarball/);
 });
 
-test('canonical npm release entrypoint enforces R193 closure before registry or pack work',async()=>{
+test('canonical npm release entrypoint enforces current R195 closure before registry or pack work',async()=>{
   const root=fileURLToPath(new URL('..',import.meta.url));
   const env={...process.env};delete env.DEADBYTE_R193_CLOSURE_ROOT;
   const result=spawnSync(process.execPath,[path.join(root,'scripts','npm-release-r48.mjs'),'--publish-only'],{cwd:root,env,encoding:'utf8',windowsHide:true});
   assert.notEqual(result.status,0);
-  assert.match(`${result.stdout}\n${result.stderr}`,/PUBLISH_BLOCKED R194.*closure root absent/);
+  assert.match(`${result.stdout}\n${result.stderr}`,/PUBLISH_BLOCKED R206.*closure root absent/);
   assert.doesNotMatch(`${result.stdout}\n${result.stderr}`,/npm publish|Packing artifact/);
 });

package/test/r193-windows-gate.test.mjs

@@ -6,17 +6,17 @@ import path from 'node:path';
 
 const root=fileURLToPath(new URL('..',import.meta.url));
 
-test('R194 Windows gate is the canonical exact-identity prepublication gate',async()=>{
+test('R206 Windows gate is the canonical exact-identity prepublication gate',async()=>{
  const [pkg,gate]=await Promise.all([
   readFile(path.join(root,'package.json'),'utf8').then(JSON.parse),
-  readFile(path.join(root,'scripts','gate-windows-r194.ps1'),'utf8')
+  readFile(path.join(root,'scripts','gate-windows-r206.ps1'),'utf8')
  ]);
- assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r194.ps1 -Stage all');
- assert.match(gate,/0\.15\.74/);
- assert.match(gate,/R194/);
- assert.match(gate,/v0\.15\.72-0a5d9436e06e2d9e/);
- assert.match(gate,/0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90/);
- assert.match(gate,/aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0/);
+ assert.equal(pkg.scripts['gate:windows'],'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r206.ps1 -Stage all');
+ assert.match(gate,/0\.15\.75/);
+ assert.match(gate,/R206/);
+ assert.match(gate,/v0\.15\.74-e84bf4eed16e9443/);
+ assert.match(gate,/e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47/);
+ assert.match(gate,/598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7/);
  assert.match(gate,/test\/r193-release-identity\.test\.mjs/);
  assert.match(gate,/test\/r193-release-readiness\.test\.mjs/);
  assert.match(gate,/test\/r193-owner-uac-broker\.test\.mjs/);

package/test/r194-release-identity.test.mjs

@@ -5,28 +5,28 @@ import{fileURLToPath}from'node:url';
 import path from'node:path';
 const root=fileURLToPath(new URL('..',import.meta.url));
 const json=async n=>JSON.parse(await readFile(path.join(root,n),'utf8'));
-test('R194 exact release version and predecessor bind active R192 but frozen local R193 source',async()=>{
+test('R206 exact release identity binds R205 source separately from active R194 runtime',async()=>{
  const [pkg,bridge,release,provenance,matrix,sbom,lock,ver]=await Promise.all([
  json('package.json'),json('bridge/package.json'),json('RELEASE.json'),json('PROVENANCE.json'),
  json('TEST-MATRIX.json'),json('SBOM.cdx.json'),json('docs/R184-package-lock.json'),
  readFile(path.join(root,'src','version.mjs'),'utf8')]);
  for(const v of [pkg.version,bridge.version,release.version,provenance.version,matrix.version,
- sbom.metadata.component.version,lock.version,lock.packages[''].version])assert.equal(v,'0.15.74');
- assert.match(ver,/DEADBYTE_VERSION = '0\.15\.74'/);
- assert.equal(release.train,'R194');assert.equal(matrix.train,'R194');
- assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r194:0.15.74');
- assert.equal(release.parent.release_id,'v0.15.72-0a5d9436e06e2d9e');
+ sbom.metadata.component.version,lock.version,lock.packages[''].version])assert.equal(v,'0.15.75');
+ assert.match(ver,/DEADBYTE_VERSION = '0\.15\.75'/);
+ assert.equal(release.train,'R206');assert.equal(matrix.train,'R206');
+ assert.equal(sbom.serialNumber,'urn:cdx:deadbyte-mcp:r206:0.15.75');
+ assert.equal(release.parent.release_id,'v0.15.74-e84bf4eed16e9443');
  assert.equal(release.runtime_predecessor.release_id,release.parent.release_id);
- assert.equal(release.source_predecessor.version,'0.15.73');
- assert.equal(release.source_predecessor.train,'R193');
- assert.equal(release.source_predecessor.release_status,'FROZEN_R193_RELEASE_READY_NOT_PUBLISHED');
- assert.equal(release.source_predecessor.manifest_sha256,'e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd');
- assert.equal(release.source_predecessor.tarball_sha256,'13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534');
- assert.equal(provenance.source_predecessor_version,'0.15.73');
+ assert.equal(release.source_predecessor.version,'0.15.75');
+ assert.equal(release.source_predecessor.train,'R205');
+ assert.equal(release.source_predecessor.release_status,'DEVELOPMENT_VERIFIED_RELEASE_BLOCKED');
+ assert.equal(release.source_predecessor.manifest_sha256,'166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92');
+ assert.equal(release.source_predecessor.tarball_sha256,null);
+ assert.equal(provenance.source_predecessor_version,'0.15.75');
  assert.equal(provenance.source_predecessor_tarball_sha256,release.source_predecessor.tarball_sha256);
- assert.equal(release.r194.scope,'NPM_AUTH_RECOVERY_AND_OWNER_AUTHORIZATION');
- assert.equal(release.r194.npm_publish,'NOT_RUN');
- assert.equal(release.r194.production_activation,'NOT_RUN');
+ assert.equal(release.r195.scope,'CANONICAL_PROTECTED_OWNER_OBSERVATION');
+ assert.equal(release.r195.npm_publish,'NOT_RUN');
+ assert.equal(release.r195.production_activation,'NOT_RUN');
 });
 test('R194 canonical publisher binds R194 readiness before registry/pack effects',async()=>{
  const [entry,readiness]=await Promise.all([
@@ -34,6 +34,10 @@ test('R194 canonical publisher binds R194 readiness before registry/pack effects
  readFile(path.join(root,'scripts/npm-release-readiness-r194.mjs'),'utf8')]);
  assert.match(entry,/assertR194NpmPublishReady/);
  assert.match(entry,/if\(r194Readiness\)assertR194PackedIdentity/);
+ assert.match(entry,/assertR195NpmPublishReady/);
+ assert.match(entry,/if\(r195Readiness\)assertR195PackedIdentity/);
+ assert.match(entry,/assertR206NpmPublishReady/);
+ assert.match(entry,/if\(r206Readiness\)assertR206PackedIdentity/);
  assert.match(entry,/authorizePublish:ownerAuth,authorizeAuthRetry:ownerAuth/);
  assert.match(entry,/version==='0\.15\.74'/);
  assert.match(entry,/if \(!publishOnly\)/);

package/test/r194-release-readiness.test.mjs

@@ -77,11 +77,11 @@ test('R194 publisher refuses a repacked artifact that differs from closure bytes
     observedSha256:'c'.repeat(64),observedIntegrity:'sha512-other',observedShasum:'d'.repeat(40)}),/PUBLISH_BLOCKED R194.*repacked tarball/);
 });
 
-test('canonical npm release entrypoint enforces R194 closure before registry or pack work',async()=>{
+test('canonical npm release entrypoint enforces current R195 closure before registry or pack work',async()=>{
   const root=fileURLToPath(new URL('..',import.meta.url));
   const env={...process.env};delete env.DEADBYTE_R194_CLOSURE_ROOT;
   const result=spawnSync(process.execPath,[path.join(root,'scripts','npm-release-r48.mjs'),'--publish-only'],{cwd:root,env,encoding:'utf8',windowsHide:true});
   assert.notEqual(result.status,0);
-  assert.match(`${result.stdout}\n${result.stderr}`,/PUBLISH_BLOCKED R194.*closure root absent/);
+  assert.match(`${result.stdout}\n${result.stderr}`,/PUBLISH_BLOCKED R206.*closure root absent/);
   assert.doesNotMatch(`${result.stdout}\n${result.stderr}`,/npm publish|Packing artifact/);
 });

package/test/r194-windows-gate.test.mjs

@@ -4,17 +4,18 @@ import {readFile} from 'node:fs/promises';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 const root=fileURLToPath(new URL('..',import.meta.url));
-test('R194 prepublication Windows gate keeps parent pinned and current R194 identity',async()=>{
+test('R206 prepublication Windows gate keeps active R194 runtime parent pinned',async()=>{
  const [pkg,gate]=await Promise.all([
   readFile(path.join(root,'package.json'),'utf8').then(JSON.parse),
-  readFile(path.join(root,'scripts/gate-windows-r194.ps1'),'utf8')]);
+  readFile(path.join(root,'scripts/gate-windows-r206.ps1'),'utf8')]);
  assert.equal(pkg.scripts['gate:windows'],
- 'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r194.ps1 -Stage all');
- assert.match(gate,/0\.15\.74/);assert.match(gate,/R194/);
- assert.match(gate,/v0\.15\.72-0a5d9436e06e2d9e/);
- assert.match(gate,/aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0/);
+ 'powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r206.ps1 -Stage all');
+ assert.match(gate,/0\.15\.75/);assert.match(gate,/R206/);
+ assert.match(gate,/v0\.15\.74-e84bf4eed16e9443/);
+ assert.match(gate,/598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7/);
  assert.match(gate,/test\/r194-release-identity\.test\.mjs/);
  assert.match(gate,/test\/r194-npm-auth-recovery\.test\.mjs/);
+ assert.match(gate,/test\/r195-canonical-owner-observation\.test\.mjs/);
  assert.match(gate,/test\/r193-owner-uac-broker\.test\.mjs/);
  assert.doesNotMatch(gate,/arm(process|coding|autonomous|desktop|host)/i);
  assert.doesNotMatch(gate,/deploy|activate|npm publish/i);

package/test/r195-canonical-owner-observation.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {observeCanonicalController} from '../src/r195-canonical-owner-observation.mjs';
+
+test('R195 protected owner flow observes the active controller through the canonical launcher',async()=>{
+  const calls=[];
+  const result=await observeCanonicalController({
+    stateRoot:'C:\\Users\\DEADBYTE\\.deadbyte-mcp',
+    powershell:'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe',
+    env:{PATH:'fixture'},
+    execFileAsync:async(file,args,options)=>{
+      calls.push({file,args,options});
+      return {stdout:'{"state":"ONLINE","supervisor":{"running":true}}\n'};
+    }
+  });
+  assert.deepEqual(result,{state:'ONLINE',supervisor:{running:true}});
+  assert.equal(calls.length,1);
+  assert.equal(calls[0].file,'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe');
+  assert.deepEqual(calls[0].args,[
+    '-NoLogo','-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-File',
+    'C:\\Users\\DEADBYTE\\.deadbyte-mcp\\bin\\DEADBYTE-MCP.ps1','status','-Json'
+  ]);
+  assert.equal(calls[0].options.shell,false);
+  assert.equal(calls[0].options.windowsHide,true);
+});
+
+test('R195 canonical owner observation rejects caller-selected relative state roots',async()=>{
+  await assert.rejects(()=>observeCanonicalController({
+    stateRoot:'.\\state',powershell:'powershell.exe',env:{},
+    execFileAsync:async()=>({stdout:'{}'})
+  }),/absolute state root/);
+});

package/test/r195-release-readiness.test.mjs

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {assertR195NpmPublishReady,assertR195PackedIdentity} from '../scripts/npm-release-readiness-r195.mjs';
+
+const release={
+  version:'0.15.75',train:'R195',
+  parent:{version:'0.15.74',release_id:'v0.15.74-e84bf4eed16e9443',
+    manifest_sha256:'e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47',
+    generation_manifest_sha256:'598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7'},
+  r195:{scope:'CANONICAL_PROTECTED_OWNER_OBSERVATION',public_tool_delta:0,authority_scope_delta:0}
+};
+
+test('R195 publication refuses an absent exact-byte closure before pack or registry effects',async()=>{
+  await assert.rejects(assertR195NpmPublishReady(release,{root:'D:\\candidate'}),/PUBLISH_BLOCKED R195.*closure root absent/);
+});
+
+test('R195 packed identity refuses any artifact differing from the protected closure',()=>{
+  assert.throws(()=>assertR195PackedIdentity({
+    tarball_sha256:'a'.repeat(64),tarball_integrity:'sha512-expected',tarball_shasum:'b'.repeat(40),
+    observedSha256:'c'.repeat(64),observedIntegrity:'sha512-other',observedShasum:'d'.repeat(40)
+  }),/PUBLISH_BLOCKED R195.*repacked tarball/);
+});

package/test/r196-desktop-postcondition.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {evaluateDesktopPostcondition,validateDesktopPostconditionExpectation} from '../src/desktop-postcondition-r196.mjs';
+
+const H=x=>createHash('sha256').update(String(x)).digest('hex');
+const frame=(id,img)=>Object.freeze({frame_id:H('frame-'+id),image_sha256:H(img)});
+const before=frame(1,'initial');
+const after=frame(2,'changed');
+
+test('R196 input delivery or changed pixels cannot silently confirm application effect',()=>{
+ const value=evaluateDesktopPostcondition({beforeFrame:before,afterFrame:after});
+ assert.equal(value.status,'unknown');
+ assert.equal(value.reason,'no_explicit_expectation');
+ assert.equal(value.kind,null);
+});
+
+test('R196 explicit fresh expected image can satisfy an observable postcondition',()=>{
+ const expectation={kind:'frame_image_sha256',expected_sha256:after.image_sha256};
+ const result=evaluateDesktopPostcondition({beforeFrame:before,afterFrame:after,expectation});
+ assert.equal(result.status,'satisfied');
+ assert.equal(result.reason,'exact_post_image_observed');
+ assert.equal(result.expected_sha256,after.image_sha256);
+ assert.equal(result.after_frame_id,after.frame_id);
+});
+
+test('R196 desired postcondition absent after input is unsatisfied',()=>{
+ const expected=frame(3,'desired').image_sha256;
+ const result=evaluateDesktopPostcondition({beforeFrame:before,afterFrame:after,
+  expectation:{kind:'frame_image_sha256',expected_sha256:expected}});
+ assert.equal(result.status,'unsatisfied');
+ assert.equal(result.reason,'post_image_differs_from_expected');
+});
+
+test('R196 pre-existing expected state cannot prove input caused an effect',()=>{
+ const result=evaluateDesktopPostcondition({beforeFrame:before,afterFrame:after,
+  expectation:{kind:'frame_image_sha256',expected_sha256:before.image_sha256}});
+ assert.equal(result.status,'unknown');
+ assert.equal(result.reason,'expected_state_already_present_before_action');
+});
+
+test('R196 forged or unsupported postcondition must be rejected before injection',()=>{
+ for(const value of [
+  {},{kind:'file_sha256',expected_sha256:H('anything')},
+  {kind:'frame_image_sha256',expected_sha256:'bogus'},
+  {kind:'frame_image_sha256',expected_sha256:H('valid'),_internal:true}
+ ])assert.throws(()=>validateDesktopPostconditionExpectation(value),/unsupported/);
+});
+
+test('R196 invalid frames never produce a satisfied or unknown false evidence result',()=>{
+ assert.throws(()=>evaluateDesktopPostcondition({beforeFrame:{},afterFrame:after,
+  expectation:{kind:'frame_image_sha256',expected_sha256:after.image_sha256}}),/frames invalid/);
+});

package/test/r196-handle-bound-read.test.mjs

@@ -0,0 +1,99 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import {createHash} from 'node:crypto';
+import {mkdtemp,mkdir,writeFile,rm,open,rename,lstat} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {syncBuiltinESMExports} from 'node:module';
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import {loadCodingPolicy} from '../src/coding-plane.mjs';
+import {createMachineFsRuntime} from '../src/machine-fs.mjs';
+import {readRangeFromHandle} from '../src/machine-fs-handle-read-r196.mjs';
+import {generateTrustKeypair} from '../src/trust.mjs';
+
+const sha=b=>createHash('sha256').update(b).digest('hex');
+async function fixture(t){
+ const root=await mkdtemp(path.join(tmpdir(),'deadbyte-r196-fd-'));
+ 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,'grant.json'),evidence_dir:path.join(root,'evidence'),
+  roots:{project:{path:project,read:true,write:false,exec:false,deny_paths:[]}},
+  commands:{},max_read_bytes:4194304,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,runtime:createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
+}
+
+test('R196 read hash must not reopen path after reading different bytes',async t=>{
+ const f=await fixture(t),a=Buffer.from('original-fd-a'),b=Buffer.from('alternate-path-b');
+ await writeFile(path.join(f.project,'source.bin'),a);
+ await writeFile(path.join(f.project,'alternate.bin'),b);
+ const original=fs.createReadStream;
+ let calls=0;
+ fs.createReadStream=(_p,opts)=>{calls++;return original(path.join(f.project,'alternate.bin'),opts)};
+ syncBuiltinESMExports();
+ try{
+  const r=await f.runtime.read({rootId:'project',relativePath:'source.bin',offset:0,maxBytes:64,hashFile:true});
+  assert.deepEqual(Buffer.from(r.data_base64,'base64'),a,'range reads source bytes');
+  assert.equal(r.file_sha256,sha(a),'digest must belong to the same file object as returned data');
+  assert.equal(calls,0,'hash must not reopen a pathname through createReadStream');
+ }finally{
+  fs.createReadStream=original;syncBuiltinESMExports();
+ }
+});
+
+test('R196 standalone worker returns digest and bytes from source file',async t=>{
+ const f=await fixture(t),a=Buffer.from('worker-fd-identity\0\x01');
+ const p=path.join(f.project,'worker.bin');await writeFile(p,a);
+ const script=fileURLToPath(new URL('../src/machine-fs-read-worker.mjs',import.meta.url));
+ const run=spawnSync(process.execPath,[script,p,'0','32','1'],{encoding:'utf8',windowsHide:true,timeout:10000,shell:false});
+ assert.equal(run.status,0,run.stderr);
+ const v=JSON.parse(run.stdout);
+ assert.equal(v.schema,'deadbyte.machine-fs-read-worker.v1');
+ assert.deepEqual(Buffer.from(v.data_base64,'base64'),a);
+ assert.equal(v.file_sha256,sha(a));
+});
+
+test('R196 retained FileHandle survives same-size pathname replacement',async t=>{
+ const f=await fixture(t);
+ const name=path.join(f.project,'mutable.bin'),oldName=path.join(f.project,'old.bin'),replacement=path.join(f.project,'replacement.bin');
+ const a=Buffer.from('AAAAAAAA-ORIGINAL'),b=Buffer.from('BBBBBBBB-REPLACED');
+ assert.equal(a.length,b.length);
+ await writeFile(name,a);await writeFile(replacement,b);
+ const handle=await open(name,'r');
+ try{
+  const opened=await handle.stat({bigint:true});
+  await rename(name,oldName);
+  await rename(replacement,name);
+  const current=await lstat(name,{bigint:true});
+  assert.notEqual(opened.ino,current.ino,'test fixture did not replace the file object');
+  const v=await readRangeFromHandle(handle,{offset:0,length:32,hashFile:true});
+  assert.deepEqual(Buffer.from(v.data_base64,'base64'),a);
+  assert.equal(v.file_sha256,sha(a));
+  assert.equal(v.file_ino,String(opened.ino));
+ }finally{await handle.close()}
+});
+
+test('R196 in-place mutation between range and hash refuses mixed file epoch',async t=>{
+ const f=await fixture(t);
+ const file=path.join(f.project,'inplace.bin');
+ await writeFile(file,Buffer.from('old'));
+ const handle=await open(file,'r');
+ const proto=Object.getPrototypeOf(handle),original=proto.createReadStream;
+ let attempted=false;
+ proto.createReadStream=function(options){
+  attempted=true;
+  fs.writeFileSync(file,Buffer.from('new-bytes-with-different-size'));
+  return original.call(this,options);
+ };
+ try{
+  await assert.rejects(()=>readRangeFromHandle(handle,{offset:0,length:3,hashFile:true}),/opened file changed during read\/hash/);
+  assert.equal(attempted,true);
+ }finally{proto.createReadStream=original;await handle.close()}
+});

package/test/r196-remote-outcome.test.mjs

@@ -0,0 +1,94 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {generateKeyPairSync,createHash} from 'node:crypto';
+import {mkdtemp,rm} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {createRemoteDevicePlaneR44} from '../src/remote-device-r44.mjs';
+
+const hash=b=>createHash('sha256').update(b).digest('hex');
+function key(){
+ const {publicKey}=generateKeyPairSync('ed25519');
+ const der=Buffer.from(publicKey.export({type:'spki',format:'der'}));
+ return {id:hash(der),spki:der.toString('base64')};
+}
+async function fixture(t,relay,{timeoutMs=2000}={}){
+ const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r196-remote-'));
+ t.after(()=>rm(dir,{recursive:true,force:true}));
+ const owner=key();
+ const factory=()=>createRemoteDevicePlaneR44({stateDir:dir,relay,authorizeCapability:async()=>true,
+  relayTimeoutMs:timeoutMs,probeRetries:0,reachableTtlMs:5000});
+ const plane=await factory();
+ await plane.pair({publicKeySpkiBase64:owner.spki,displayName:'R196'});
+ await plane.reportOnline({deviceId:owner.id,epoch:1,connectionId:'r196-disarmed'});
+ await plane.probe({deviceId:owner.id,epoch:1});
+ return {owner,plane,factory};
+}
+const req=(owner,id)=>({deviceId:owner.id,epoch:1,capabilityId:'machine.fs.write',payload:{file:'safe.txt',content:'one'},requestId:id.repeat(64)});
+
+test('R196 concurrent identical request ID has only one relay side effect',async t=>{
+ let release,started;
+ const entered=new Promise(resolve=>started=resolve);
+ const gate=new Promise(resolve=>release=resolve);
+ let effects=0;
+ const relay={
+  async probe(x){return {device_id:x.device_id,epoch:x.epoch,nonce:x.nonce,ready:true};},
+  async request(x){effects++;started();await gate;return {ack:'accepted',request_id:x.request_id,terminal:{status:'completed',result_sha256:'a'.repeat(64)}};}
+ };
+ const {owner,plane}=await fixture(t,relay);
+ const one=plane.dispatch(req(owner,'1'));
+ const two=plane.dispatch(req(owner,'1'));
+ await entered;
+ await new Promise(resolve=>setTimeout(resolve,20));
+ release();
+ const [first,replay]=await Promise.all([one,two]);
+ assert.equal(effects,1,'duplicate side effect for concurrent same-ID dispatch');
+ assert.equal(first.state,'completed');
+ assert.equal(first.effect_state,'confirmed');
+ assert.equal(first.transport_state,'terminal_received');
+ assert.equal(replay.replay,true);
+ assert.equal(replay.request_sha256,first.request_sha256);
+});
+
+test('R196 lost reply after committed remote effect is UNKNOWN not a confirmed operation failure',async t=>{
+ let effects=0;
+ const relay={
+  async probe(x){return {device_id:x.device_id,epoch:x.epoch,nonce:x.nonce,ready:true};},
+  async request(){effects++;return await new Promise(()=>{});}
+ };
+ const {owner,plane,factory}=await fixture(t,relay,{timeoutMs:100});
+ const args=req(owner,'2');
+ const result=await plane.dispatch(args);
+ assert.equal(result.state,'failed','legacy transport failure label remains for compatibility');
+ assert.equal(result.error_code,'transport_error');
+ assert.equal(result.transport_state,'timed_out');
+ assert.equal(result.effect_state,'unknown','transport timeout cannot prove no remote mutation');
+ assert.equal(effects,1);
+ const restarted=await factory();
+ const second=await restarted.dispatch(args);
+ assert.equal(second.replay,true);
+ assert.equal(second.effect_state,'unknown');
+ assert.equal(effects,1,'restart must never reexecute accepted unknown-outcome mutation');
+});
+
+test('R196 explicit missing ACK and terminal ACK preserve independent transport/effect facts',async t=>{
+ const relay={
+  async probe(x){return {device_id:x.device_id,epoch:x.epoch,nonce:x.nonce,ready:true};},
+  async request(){return null;}
+ };
+ const {owner,plane}=await fixture(t,relay);
+ const noAck=await plane.dispatch(req(owner,'3'));
+ assert.equal(noAck.error_code,'transport_no_ack');
+ assert.equal(noAck.transport_state,'ack_missing');
+ assert.equal(noAck.effect_state,'unknown');
+ relay.request=async x=>({ack:'accepted',request_id:x.request_id});
+ const noTerminal=await plane.dispatch(req(owner,'4'));
+ assert.equal(noTerminal.error_code,'transport_no_terminal');
+ assert.equal(noTerminal.transport_state,'acknowledged');
+ assert.equal(noTerminal.effect_state,'unknown');
+ relay.request=async x=>({ack:'accepted',request_id:x.request_id,terminal:{status:'completed',result_sha256:'b'.repeat(64)}});
+ const complete=await plane.dispatch(req(owner,'5'));
+ assert.equal(complete.transport_state,'terminal_received');
+ assert.equal(complete.effect_state,'confirmed');
+ assert.equal(complete.state,'completed');
+});

package/test/r197-namespace-race.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,mkdir,writeFile,readFile,rm,lstat} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {loadCodingPolicy} from '../src/coding-plane.mjs';
+import {createMachineFsRuntime} from '../src/machine-fs.mjs';
+import {generateTrustKeypair} from '../src/trust.mjs';
+
+test('R197 legacy injectable pathname worker demonstrates escaped open but parent rejects data',async t=>{
+ if(process.platform!=='win32')return t.skip('native Windows reparse fixture');
+ const scratch=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r197-namespace-'));
+ t.after(()=>rm(scratch,{recursive:true,force:true}));
+ const project=path.join(scratch,'project'),external=path.join(scratch,'external');
+ await mkdir(project);await mkdir(external);await mkdir(path.join(project,'mutable'));
+ await writeFile(path.join(project,'mutable','sample.bin'),'INSIDE-1234');
+ await writeFile(path.join(external,'sample.bin'),'OUTSIDE-123');
+ const policyFile=path.join(scratch,'policy.json');
+ await writeFile(policyFile,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:65536,max_write_bytes:65536
+ }));
+ const policy=await loadCodingPolicy(policyFile);
+ const keys=await generateTrustKeypair({privateKeyPath:path.join(scratch,'private.pem'),publicKeyPath:path.join(scratch,'public.pem')});
+ const worker=fileURLToPath(new URL('./fixtures/r197-junction-swap-worker.mjs',import.meta.url));
+ const runtime=createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,
+  verifyKeyPath:keys.publicKeyPath,readWorkerPath:worker});
+ let outcome;
+ try{outcome=await runtime.read({rootId:'project',relativePath:'mutable/sample.bin',offset:0,maxBytes:32,hashFile:true,timeoutMs:5000});}
+ catch(e){outcome={error:String(e?.message??e)}}
+ const marker=path.join(scratch,'r197-worker-entered.marker');
+ await lstat(marker); // Proves an actual post-precheck execution point was reached.
+ const escaped=path.join(scratch,'r197-escaped-open.marker');
+ const observed=await lstat(escaped).then(()=>true,()=>false);
+ // This deliberately characterizes the old injected-worker path. It is NOT a secure reader proof.
+ assert.equal(observed,true,'R197 diagnostic fixture must demonstrate the legacy escaped open');
+ assert.equal(outcome.error!==undefined,true,'raced request must fail closed');
+});

package/test/r197-native-dispatch-race.test.mjs

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import cp from 'node:child_process';
+import fs from 'node:fs';
+import {mkdtemp,mkdir,writeFile,rm,realpath} 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';
+
+test('R197 default native read refuses a junction swapped after validation but before kernel open',async t=>{
+ if(process.platform!=='win32')return t.skip('Windows native test only');
+ const scratch=await mkdtemp(path.join(tmpdir(),'deadbyte-r197-native-race-'));
+ t.after(()=>rm(scratch,{recursive:true,force:true}));
+ const root=path.join(scratch,'project'),external=path.join(scratch,'external');
+ await mkdir(root);await mkdir(external);await mkdir(path.join(root,'mutable'));
+ await writeFile(path.join(root,'mutable','sample.bin'),'INSIDE-1234');
+ await writeFile(path.join(external,'sample.bin'),'OUTSIDE-123');
+ const file=path.join(scratch,'policy.json');
+ await writeFile(file,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:root,read:true,write:false,exec:false,deny_paths:[]}},
+  commands:{},max_read_bytes:65536,max_write_bytes:65536
+ }));
+ const policy=await loadCodingPolicy(file);
+ const keys=await generateTrustKeypair({privateKeyPath:path.join(scratch,'private.pem'),publicKeyPath:path.join(scratch,'public.pem')});
+ const runtime=createMachineFsRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
+ const original=cp.spawn;
+ let intercepted=0;
+ cp.spawn=(command,args,options)=>{
+  if(path.basename(String(command)).toLowerCase()==='deadbyte-fs-read-r198.exe'){
+   intercepted++;
+   fs.renameSync(path.join(root,'mutable'),path.join(root,'mutable-original'));
+   fs.symlinkSync(external,path.join(root,'mutable'),'junction');
+  }
+  return original(command,args,options);
+ };
+ syncBuiltinESMExports();
+ try{
+  await assert.rejects(runtime.read({rootId:'project',relativePath:'mutable/sample.bin',
+   offset:0,maxBytes:32,hashFile:true,timeoutMs:5000}),/native root-relative read refused/);
+ }finally{cp.spawn=original;syncBuiltinESMExports();}
+ assert.equal(intercepted,1,'native operation was not reached after path precheck');
+ assert.equal((await realpath(path.join(root,'mutable','sample.bin'))).toLowerCase(),
+  path.join(external,'sample.bin').toLowerCase(),'fixture did not redirect the pathname outside root');
+});