deadbyte-mcp 0.15.39 → 0.15.42

package/test/commander-real-parity-r47.test.mjs

@@ -10,6 +10,7 @@ import { createMachineFsRuntime, verifyMachineFsReceiptFile } from '../src/machi
 import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
 import { createProcessRuntime } from '../src/process-runtime.mjs';
 import { createCommanderWireAdapter } from '../src/commander-wire-adapter-r47.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha=b=>createHash('sha256').update(b).digest('hex');
 const sleep=ms=>new Promise(r=>setTimeout(r,ms));
@@ -17,13 +18,13 @@ const sleep=ms=>new Promise(r=>setTimeout(r,ms));
 async function fsFixture(){
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-commander-real-fs-'));
   const project=path.join(root,'project'); await mkdir(project);
-  const policyPath=path.join(root,'policy.json'), grantPath=path.join(root,'grant.json');
+  const policyPath=path.join(root,'policy.json'), grantPath=path.join(root,'runtime','grant.json');
   const policy=await (async()=>{await writeFile(policyPath,JSON.stringify({
     schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:grantPath,evidence_dir:path.join(root,'evidence'),
     roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:['blocked']}},
     commands:{},max_read_bytes:65536,max_write_bytes:65536
   })); return loadCodingPolicy(policyPath)})();
-  await writeFile(grantPath,JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:policy.policy_sha256,instance_nonce:'b'.repeat(64),root_ids:['project'],granted_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('coding', grantPath, {schema:'deadbyte.coding-grant.v2',policy_sha256:policy.policy_sha256,instance_nonce:'b'.repeat(64),root_ids:['project'],granted_at_utc:new Date().toISOString()});
   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})};
 }
@@ -34,7 +35,7 @@ async function processFixture(){
   const host=path.resolve('bin/deadbyte-process-host.exe'), exe='C:\\Windows\\System32\\cmd.exe';
   const powershell='C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
   const h=sha(await readFile(host)), e=sha(await readFile(exe)),ps=sha(await readFile(powershell));
-  const grantFile=path.join(root,'grant.json'), stateDir=path.join(root,'state'), policyPath=path.join(root,'policy.json');
+  const grantFile=path.join(root,'runtime','grant.json'), stateDir=path.join(root,'state'), policyPath=path.join(root,'policy.json');
   await writeFile(policyPath,JSON.stringify({schema:PROCESS_POLICY_SCHEMA,enabled:true,grant_file:grantFile,state_dir:stateDir,
     native_host:{path:host,sha256:h},roots:{core:{path:project,deny_paths:[]}},profiles:{
       echo:{executable:exe,executable_sha256:e,root_ids:['core'],prefix_args:['/d','/c'],max_args:4,max_arg_bytes:256,max_sessions:2,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}},
@@ -42,7 +43,7 @@ async function processFixture(){
       powershell_repl:{executable:powershell,executable_sha256:ps,root_ids:['core'],transport:'pipe',prefix_args:['-NoLogo','-NoProfile','-NonInteractive','-Command','-'],allow_raw_input:true,max_args:0,max_arg_bytes:256,max_sessions:2,max_input_bytes:8192,max_retained_output_bytes:2*1024*1024,env_allow:['PATH','TEMP','TMP'],input_actions:{}}
     }}));
   const policy=await loadProcessPolicy(policyPath);
-  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'a'.repeat(64),profile_ids:['echo','hold','powershell_repl'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('process', grantFile, {schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'a'.repeat(64),profile_ids:['echo','hold','powershell_repl'],root_ids:['core'],granted_at_utc:new Date().toISOString()});
   const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
   return {root,policy,keys,runtime:createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
 }

package/test/commander-torture-r47.test.mjs

@@ -9,6 +9,7 @@ import { createMachineFsRuntime } from '../src/machine-fs.mjs';
 import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
 import { createProcessRuntime } from '../src/process-runtime.mjs';
 import { createHash } from 'node:crypto';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha=b=>createHash('sha256').update(b).digest('hex');
 const sleep=ms=>new Promise(r=>setTimeout(r,ms));
@@ -16,10 +17,10 @@ const sleep=ms=>new Promise(r=>setTimeout(r,ms));
 async function fsFixture(){
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-torture-fs-')), project=path.join(root,'project');
   await mkdir(project);
-  const policyPath=path.join(root,'policy.json'), grantPath=path.join(root,'grant.json');
+  const policyPath=path.join(root,'policy.json'), grantPath=path.join(root,'runtime','grant.json');
   await writeFile(policyPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,lease_file:grantPath,evidence_dir:path.join(root,'evidence'),roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:['blocked']}},commands:{},max_read_bytes:65536,max_write_bytes:65536}));
   const policy=await loadCodingPolicy(policyPath);
-  await writeFile(grantPath,JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:policy.policy_sha256,instance_nonce:'c'.repeat(64),root_ids:['project'],granted_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('coding', grantPath, {schema:'deadbyte.coding-grant.v2',policy_sha256:policy.policy_sha256,instance_nonce:'c'.repeat(64),root_ids:['project'],granted_at_utc:new Date().toISOString()});
   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})};
 }
@@ -28,13 +29,13 @@ async function processFixture(){
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-torture-proc-')), project=path.join(root,'project'),trust=path.join(root,'trust');
   await mkdir(project); await mkdir(trust);
   const host=path.resolve('bin/deadbyte-process-host.exe'), exe='C:\\Windows\\System32\\cmd.exe';
-  const grantFile=path.join(root,'grant.json'), stateDir=path.join(root,'state'), policyPath=path.join(root,'policy.json');
+  const grantFile=path.join(root,'runtime','grant.json'), stateDir=path.join(root,'state'), policyPath=path.join(root,'policy.json');
   await writeFile(policyPath,JSON.stringify({schema:PROCESS_POLICY_SCHEMA,enabled:true,grant_file:grantFile,state_dir:stateDir,native_host:{path:host,sha256:sha(await readFile(host))},roots:{core:{path:project,deny_paths:[]}},profiles:{
     echo:{executable:exe,executable_sha256:sha(await readFile(exe)),root_ids:['core'],prefix_args:['/d','/c'],max_args:4,max_arg_bytes:256,max_sessions:8,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}},
     hold:{executable:exe,executable_sha256:sha(await readFile(exe)),root_ids:['core'],transport:'pipe',prefix_args:['/d','/q'],max_args:0,max_arg_bytes:256,max_sessions:8,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}
   }}));
   const policy=await loadProcessPolicy(policyPath);
-  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'d'.repeat(64),profile_ids:['echo','hold'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('process', grantFile, {schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'d'.repeat(64),profile_ids:['echo','hold'],root_ids:['core'],granted_at_utc:new Date().toISOString()});
   const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
   return {root,runtime:createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath})};
 }

package/test/desktop-policy-r40.test.mjs

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtemp,writeFile } from 'node:fs/promises';
+import { mkdtemp,mkdir,writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
@@ -8,12 +8,14 @@ import {
   DESKTOP_POLICY_SCHEMA,DESKTOP_GRANT_SCHEMA,DESKTOP_ACTION_KINDS,
   loadDesktopPolicy,desktopSessionStatus,assertDesktopArmed
 } from '../src/desktop-policy-r40.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const H=value=>createHash('sha256').update(String(value)).digest('hex');
 
 async function fixture(){
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r40-desktop-policy-'));
-  const grant=path.join(root,'desktop-grant.json');
+  await mkdir(path.join(root,'runtime'));
+  const grant=path.join(root,'runtime','desktop-grant.json');
   const evidence=path.join(root,'evidence');
   const observer=path.join(root,'observer.exe');
   const input=path.join(root,'input.exe');
@@ -57,10 +59,10 @@ test('desktop plane is fail-closed when no grant exists',async()=>{
 
 test('desktop standing grant is policy-hash-bound and action-scoped',async()=>{
   const {policy,grant}=await fixture();
-  await writeFile(grant,JSON.stringify({
+  await writeBoundStandingGrant('desktop', grant, {
     schema:DESKTOP_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:H('nonce'),
     action_kinds:['pointer_move','click_primary']
-  }));
+  });
   const status=await desktopSessionStatus(policy);
   assert.equal(status.armed,true);
   assert.equal(status.reason,'standing-grant');

package/test/desktop-runtime-r40.test.mjs

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { createDesktopFrame } from '../src/desktop-contract.mjs';
 import { DESKTOP_POLICY_SCHEMA,DESKTOP_GRANT_SCHEMA } from '../src/desktop-policy-r40.mjs';
 import { createDesktopRuntime,verifyDesktopReceiptObject } from '../src/desktop-runtime-r40.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const H=value=>createHash('sha256').update(String(value)).digest('hex');
 const EPOCH=H('epoch');
@@ -21,7 +22,7 @@ function F(at,image=H('same'),window=WIN){
 }
 async function fixture({grantActions=['click_primary','text_input'],captureFrames=null,times=null,inputProvider=null,grounderProvider=null,clockMs=null,sleeper=null}={}){
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r40-desktop-runtime-'));
-  const grant=path.join(root,'grant.json'),evidence=path.join(root,'evidence');
+  const grant=path.join(root,'runtime','grant.json'),evidence=path.join(root,'evidence');
   const policy={
     schema:DESKTOP_POLICY_SCHEMA,enabled:true,policy_path:path.join(root,'policy.json'),
     policy_sha256:H('policy'),grant_file:grant,evidence_dir:evidence,
@@ -31,9 +32,13 @@ async function fixture({grantActions=['click_primary','text_input'],captureFrame
     allowed_actions:['pointer_move','click_primary','click_secondary','double_click_primary','scroll','key_chord','text_input'],
     limits:{max_frame_age_ms:2000,max_frame_bytes:8*1024*1024,capture_timeout_ms:5000,input_timeout_ms:2000,post_observe_timeout_ms:5000,max_preview_bytes:512*1024,max_text_bytes:4096}
   };
-  await writeFile(grant,JSON.stringify({
+  const {policy_path:policyPath,policy_sha256:_unusedSha,...rawPolicy}=policy;
+  const policyBytes=Buffer.from(JSON.stringify(rawPolicy));
+  await writeFile(policyPath,policyBytes);
+  policy.policy_sha256=createHash('sha256').update(policyBytes).digest('hex');
+  await writeBoundStandingGrant('desktop', grant, {
     schema:DESKTOP_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:H('grant-nonce'),action_kinds:grantActions
-  }));
+  });
   const expected=F('2026-09-19T02:00:00.000Z');
   const frames=captureFrames??[
     {frame:F('2026-09-19T02:00:00.700Z'),backend:'fake',byte_length:4},

package/test/host-inline-r45.test.mjs

@@ -7,13 +7,14 @@ import path from 'node:path';
 import {
   HOST_GRANT_SCHEMA, HOST_POLICY_SCHEMA_V2, hostExecInline, hostExecNative, loadHostPolicy
 } from '../src/host-plane.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
 
 async function fixture(){
   const dir=await mkdtemp(path.join(os.tmpdir(),'deadbyte-host-inline-r45-'));
   const root=path.join(dir,'root');await mkdir(root);
-  const arm=path.join(dir,'arm.json'), policyPath=path.join(dir,'policy.json');
+  const arm=path.join(dir,'runtime','arm.json'), policyPath=path.join(dir,'policy.json');
   const exeSha=sha(await readFile(process.execPath));
   const raw={
     schema:HOST_POLICY_SCHEMA_V2,enabled:true,arm_file:arm,
@@ -27,8 +28,8 @@ async function fixture(){
   };
   await writeFile(policyPath,JSON.stringify(raw,null,2));
   const policy=await loadHostPolicy(policyPath);
-  await writeFile(arm,JSON.stringify({schema:HOST_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,
-    instance_nonce:randomBytes(32).toString('hex'),armed_at_utc:new Date().toISOString()},null,2));
+  await writeBoundStandingGrant('host', arm, {schema:HOST_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,
+    instance_nonce:randomBytes(32).toString('hex'),armed_at_utc:new Date().toISOString()},{space:2});
   return {dir,root,arm,policy,exeSha};
 }
 

package/test/machine-fs-runtime.test.mjs

@@ -7,6 +7,7 @@ import path from 'node:path';
 import { generateTrustKeypair } from '../src/trust.mjs';
 import { loadCodingPolicy } from '../src/coding-plane.mjs';
 import { createMachineFsRuntime, verifyMachineFsReceiptFile } from '../src/machine-fs.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 
@@ -15,17 +16,17 @@ async function fixture({ readWorkerPath = undefined, listEntryLstat = undefined
   const project = path.join(root, 'project');
   await mkdir(project);
   const policyPath = path.join(root, 'coding-policy.json');
-  const grantPath = path.join(root, 'coding-grant.json');
+  const grantPath = path.join(root, 'runtime', 'coding-grant.json');
   await writeFile(policyPath, JSON.stringify({
     schema: 'deadbyte.coding-policy.v1', enabled: true,
     lease_file: grantPath, evidence_dir: path.join(root, 'evidence'),
     roots: { project: { path: project, read: true, write: true, exec: false, deny_paths: ['blocked'] } },
     commands: {}, max_read_bytes: 65536, max_write_bytes: 65536
   }));  const policy = await loadCodingPolicy(policyPath);
-  await writeFile(grantPath, JSON.stringify({
+  await writeBoundStandingGrant('coding', grantPath, {
     schema: 'deadbyte.coding-grant.v2', policy_sha256: policy.policy_sha256,
     instance_nonce: 'b'.repeat(64), root_ids: ['project'], granted_at_utc: new Date().toISOString()
-  }));
+  });
   const keys = await generateTrustKeypair({
     privateKeyPath: path.join(root, 'private.pem'), publicKeyPath: path.join(root, 'public.pem')
   });

package/test/process-longrun-r36.test.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
 import { createProcessRuntime } from '../src/process-runtime.mjs';
 import { generateTrustKeypair } from '../src/trust.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const repo=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
 const host=path.join(repo,'bin','deadbyte-process-host.exe');
@@ -20,11 +21,11 @@ async function fixture(){
   await mkdir(project); await mkdir(trust);
   const script=path.join(project,'longrun.mjs');
   await writeFile(script,`process.stdout.write('chunk-1\\n');\nsetTimeout(()=>process.stdout.write('chunk-2\\n'),180);\nsetTimeout(()=>process.stdout.write('chunk-3\\n'),360);\nsetTimeout(()=>process.exit(0),540);\n`);
-  const grantFile=path.join(root,'process-grant.json'); const stateDir=path.join(root,'state'); const policyPath=path.join(root,'process-policy.json');
+  const grantFile=path.join(root,'runtime','process-grant.json'); const stateDir=path.join(root,'state'); const policyPath=path.join(root,'process-policy.json');
   const raw={schema:PROCESS_POLICY_SCHEMA,enabled:true,grant_file:grantFile,state_dir:stateDir,native_host:{path:host,sha256:sha(await readFile(host))},roots:{core:{path:project,deny_paths:[]}},profiles:{longrun:{executable:process.execPath,executable_sha256:sha(await readFile(process.execPath)),root_ids:['core'],transport:'pipe',prefix_args:[script],max_args:0,max_arg_bytes:256,max_sessions:1,max_input_bytes:4096,max_retained_output_bytes:65536,env_allow:['PATH','TEMP','TMP'],input_actions:{}}}};
   await writeFile(policyPath,JSON.stringify(raw));
   const policy=await loadProcessPolicy(policyPath);
-  await writeFile(grantFile,JSON.stringify({schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'6'.repeat(64),profile_ids:['longrun'],root_ids:['core'],granted_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('process', grantFile, {schema:PROCESS_GRANT_SCHEMA,policy_sha256:policy.policy_sha256,instance_nonce:'6'.repeat(64),profile_ids:['longrun'],root_ids:['core'],granted_at_utc:new Date().toISOString()});
   const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
   const make=()=>createProcessRuntime({policy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   return {root,project,stateDir,policy,keys,make,runtime:make()};

package/test/process-policy.test.mjs

@@ -12,17 +12,19 @@ import {
   processSessionStatus,
   recheckProcessAuthority
 } from '../src/process-policy.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 
 async function fixture() {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-process-policy-'));
+  await mkdir(path.join(root,'runtime'));
   const project = path.join(root, 'project');
   await mkdir(project);
   const executable = process.execPath;
   const executableSha = sha(await readFile(executable));
   const policyPath = path.join(root, 'process-policy.json');
-  const grantFile = path.join(root, 'process-grant.json');
+  const grantFile = path.join(root, 'runtime', 'process-grant.json');
   const stateDir = path.join(root, 'process-state');  const raw = {
     schema: PROCESS_POLICY_SCHEMA, enabled: true, grant_file: grantFile, state_dir: stateDir,
     native_host: { path: executable, sha256: executableSha },
@@ -52,14 +54,14 @@ test('process policy loads pinned native host, profile and root while grant is a
 });test('process standing grant binds exact policy, profile and root', async () => {
   const f = await fixture();
   const policy = await loadProcessPolicy(f.policyPath);
-  await writeFile(f.grantFile, JSON.stringify({
+  await writeBoundStandingGrant('process', f.grantFile, {
     schema: PROCESS_GRANT_SCHEMA,
     policy_sha256: policy.policy_sha256,
     instance_nonce: 'a'.repeat(64),
     profile_ids: ['node'],
     root_ids: ['core'],
     granted_at_utc: '2026-09-14T00:00:00Z'
-  }));
+  });
   const status = await processSessionStatus(policy);
   assert.equal(status.armed, true);
   assert.equal(status.reason, 'standing-grant');
@@ -81,13 +83,15 @@ test('process authority recheck rejects grant generation or scope drift before s
     root_ids: ['core'],
     granted_at_utc: '2026-09-14T00:00:00Z'
   };
-  await writeFile(f.grantFile, JSON.stringify(grant));
+  await writeBoundStandingGrant('process', f.grantFile, grant);
   const initial = await assertProcessArmed(policy, 'node', 'core');
   await writeFile(f.grantFile, JSON.stringify({ ...grant, instance_nonce: 'b'.repeat(64) }));
   await assert.rejects(() => recheckProcessAuthority(policy, initial, 'node', 'core'), /process authority changed during operation/);
   await writeFile(f.grantFile, JSON.stringify({ ...grant, profile_ids: ['node', 'node'] }));
-  const deduped = await recheckProcessAuthority(policy, initial, 'node', 'core');
-  assert.equal(deduped.instance_nonce, initial.instance_nonce);
+  await assert.rejects(
+    () => recheckProcessAuthority(policy, initial, 'node', 'core'),
+    /process authority changed during operation|epoch-grant-mismatch/
+  );
 });
 
 test('process grant with wrong policy digest is disarmed', async () => {

package/test/process-runtime.test.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { PROCESS_GRANT_SCHEMA, PROCESS_POLICY_SCHEMA, loadProcessPolicy } from '../src/process-policy.mjs';
 import { createProcessRuntime } from '../src/process-runtime.mjs';
 import { generateTrustKeypair } from '../src/trust.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const host = path.join(repo, 'bin', 'deadbyte-process-host.exe');
@@ -21,7 +22,7 @@ async function fixture() {
   const project = path.join(root, 'project');
   const trust = path.join(root, 'trust');
   await mkdir(project); await mkdir(trust);
-  const grantFile = path.join(root, 'process-grant.json');
+  const grantFile = path.join(root, 'runtime', 'process-grant.json');
   const stateDir = path.join(root, 'process-state');
   const policyPath = path.join(root, 'process-policy.json');
   const hostSha = sha(await readFile(host));
@@ -66,11 +67,11 @@ async function fixture() {
   };
   await writeFile(policyPath, JSON.stringify(raw));
   const policy = await loadProcessPolicy(policyPath);
-  await writeFile(grantFile, JSON.stringify({
+  await writeBoundStandingGrant('process', grantFile, {
     schema: PROCESS_GRANT_SCHEMA, policy_sha256: policy.policy_sha256,
     instance_nonce: 'a'.repeat(64), profile_ids: ['echo', 'hold', 'conptyhold', 'powershell', 'powershell_repl'], root_ids: ['core'],
     granted_at_utc: '2026-09-14T00:00:00Z'
-  }));
+  });
   const keys = await generateTrustKeypair({
     privateKeyPath: path.join(trust, 'private.pem'), publicKeyPath: path.join(trust, 'public.pem')
   });
@@ -99,9 +100,11 @@ test('R31 runtime starts one approved profile and exposes ordered bounded output
   assert.equal(started.profile_id, 'echo');
   assert.equal(started.stream_id, started.session_id);
   assert.equal(started.stream_generation, 1);
-  assert.equal(started.stream_next_seq, 1);
-  assert.equal(started.stream_coverage.logical_item_count, 0);
-  assert.equal(started.stream_coverage.retained_item_count, 0);
+  // The child may emit its first chunk while start() persists the started
+  // event. Assert stream/coverage coherence, not an impossible empty-stream
+  // timing promise that fails only under parallel suite load.
+  assert.equal(started.stream_next_seq, started.stream_coverage.logical_item_count + 1);
+  assert.ok(started.stream_coverage.retained_item_count <= started.stream_coverage.logical_item_count);
   assert.equal(started.stream_coverage.complete, true);
   const observed = await waitFor(f.runtime, started.session_id, text => text.includes('DBR31RUNTIME:42'));
   assert.match(observed.text, /DBR31RUNTIME:42/);

package/test/r52-host-revocation.test.mjs

@@ -13,6 +13,7 @@ async function runRevoke(t,prelude){
   // filesystem that refuses deletion while Test-Path still sees the grant.
   const script=`$ErrorActionPreference='Stop'
 function Get-HostPolicyMetadata($Cfg) { return @{ArmFile='fixture-host-grant'} }
+function Invoke-AuthorityEpochCommand($Cfg,[string]$Plane,[string]$Action,[string]$GrantFile) { return @{} }
 ${prelude}
 ${source.slice(begin,end)}
 try { Disarm-Host @{}; exit 0 } catch { Write-Output $_.Exception.Message; exit 7 }

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'||packageVersion==='0.15.42'){
+    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/);
+});