deadbyte-mcp 0.15.41 → 0.15.43

package/src/desktop-policy-r40.mjs

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { decodeUtf8Strict } from './text-policy.mjs';
+import { verifyStandingGrantEpoch } from './authority-continuity-r65.mjs';
 
 export const DESKTOP_POLICY_SCHEMA='deadbyte.desktop-policy.v1';
 export const DESKTOP_GRANT_SCHEMA='deadbyte.desktop-grant.v1';
@@ -84,8 +85,8 @@ export async function loadDesktopPolicy(policyPath){
 
 export async function desktopSessionStatus(policy){
   if(!policy||policy.schema!==DESKTOP_POLICY_SCHEMA) throw new Error('desktop policy invalid');
-  let grant;
-  try{grant=JSON.parse(decodeUtf8Strict(await readFile(policy.grant_file)));}
+  let grant,grantBytes;
+  try{grantBytes=await readFile(policy.grant_file);grant=JSON.parse(decodeUtf8Strict(grantBytes));}
   catch(error){
     return Object.freeze({configured:true,armed:false,reason:error?.code==='ENOENT'?'disarmed':'invalid-grant',standing:false,action_kinds:[]});
   }
@@ -96,8 +97,10 @@ export async function desktopSessionStatus(policy){
   try{granted=actions(grant.action_kinds,'grant.action_kinds');}
   catch{return Object.freeze({configured:true,armed:false,reason:'actions-invalid',standing:false,action_kinds:[]});}
   if(granted.some(item=>!policy.allowed_actions.includes(item))) return Object.freeze({configured:true,armed:false,reason:'actions-outside-policy',standing:false,action_kinds:[]});
+  const epoch=await verifyStandingGrantEpoch({plane:'desktop',grantFile:policy.grant_file,grantBytes,grantInstanceNonce:grant.instance_nonce,policyPath:policy.policy_path});
+  if(!epoch.trusted)return Object.freeze({configured:true,armed:false,reason:epoch.reason,standing:false,instance_nonce:grant.instance_nonce,action_kinds:granted});
   return Object.freeze({
-    configured:true,armed:true,reason:'standing-grant',standing:true,instance_nonce:grant.instance_nonce,action_kinds:granted
+    configured:true,armed:true,reason:'standing-grant',standing:true,instance_nonce:grant.instance_nonce,action_kinds:granted,authority_epoch:epoch
   });
 }
 

package/src/doctor-runtime-r58.mjs

@@ -28,8 +28,10 @@ export function validateDoctorControllerObservation(value,expectedCoreRoot){
  if(typeof value.supervisor.configured!=='boolean'||typeof value.supervisor.running!=='boolean'||!reason(value.supervisor.reason)||(!value.supervisor.configured&&value.supervisor.running))throw new Error('supervisor observation invalid');
  object(value.authority,['process','coding','autonomous','desktop','host']);
  for(const item of Object.values(value.authority)){
-  object(item,['configured','armed','reason']);
+  const hasEpoch=Object.hasOwn(item,'epoch_seq')||Object.hasOwn(item,'epoch_sha256');
+  object(item,hasEpoch?['configured','armed','reason','epoch_seq','epoch_sha256']:['configured','armed','reason']);
   if(typeof item.configured!=='boolean'||typeof item.armed!=='boolean'||!reason(item.reason)||(!item.configured&&item.armed)||(item.armed&&item.reason!=='standing-grant'))throw new Error('authority observation invalid');
+  if(hasEpoch&&(!item.armed||!Number.isSafeInteger(item.epoch_seq)||item.epoch_seq<1||typeof item.epoch_sha256!=='string'||!/^[0-9a-f]{64}$/.test(item.epoch_sha256)))throw new Error('authority epoch observation invalid');
  }
  return value;
 }

package/src/doctor-transactions-r58.mjs

@@ -87,7 +87,7 @@ export async function inspectDoctorTransactions(explicitRoot,{maxEntries=1024}={
     }
 
     if(body.phase==='superseded'){terminal++;continue;}
-    if(body.phase==='failed_receipted'){
+    if(body.phase==='failed_receipted'||body.phase==='precondition_rejected'){
       add('FAIL','Transaction journal claims a signed failure receipt but the receipt is missing.',{state_sha256:digest,check:'missing_failure_receipt',recorded_phase:body.phase});
       continue;
     }

package/src/host-plane.mjs

@@ -11,6 +11,7 @@ import { spawn } from 'node:child_process';
 import { decodeUtf8Strict } from './text-policy.mjs';
 import { isInside, validatePortableRelativePath } from './path-policy.mjs';
 import { atomicMutation } from './atomic-mutation.mjs';
+import { verifyStandingGrantEpoch } from './authority-continuity-r65.mjs';
 
 export const HOST_POLICY_SCHEMA = 'deadbyte.host-policy.v1';
 export const HOST_POLICY_SCHEMA_V2 = 'deadbyte.host-policy.v2';
@@ -164,9 +165,10 @@ export async function loadHostPolicy(policyPath) {
 }
 
 export async function assertHostArmed(policy, now = new Date()) {
-  let arm;
+  let arm,armBytes;
   try {
-    arm = JSON.parse(decodeUtf8Strict(await readFile(policy.arm_file)));
+    armBytes=await readFile(policy.arm_file);
+    arm = JSON.parse(decodeUtf8Strict(armBytes));
   } catch (error) {
     throw new Error(`privileged host plane is disarmed: ${error?.code === 'ENOENT' ? 'arm file missing' : 'invalid arm file'}`);
   }
@@ -175,7 +177,11 @@ export async function assertHostArmed(policy, now = new Date()) {
   if (typeof arm.instance_nonce !== 'string' || !SHA256_RE.test(arm.instance_nonce)) {
     throw new Error('privileged host plane is disarmed: nonce invalid');
   }
-  if (arm.schema === HOST_GRANT_SCHEMA) return { arm, standing:true, remaining_ms:null };
+  if (arm.schema === HOST_GRANT_SCHEMA) {
+    const epoch=await verifyStandingGrantEpoch({plane:'host',grantFile:policy.arm_file,grantBytes:armBytes,grantInstanceNonce:arm.instance_nonce,policyPath:policy.policy_path});
+    if(!epoch.trusted)throw new Error(`privileged host plane is disarmed: ${epoch.reason}`);
+    return { arm, standing:true, remaining_ms:null, authority_epoch:epoch };
+  }
   const expires = Date.parse(arm.expires_at_utc);
   if (!Number.isFinite(expires) || expires <= now.getTime()) throw new Error('privileged host plane is disarmed: arm expired');
   return { arm, standing:false, remaining_ms: expires - now.getTime() };

package/src/process-policy.mjs

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { lstat, mkdir, readFile, realpath, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { decodeUtf8Strict } from './text-policy.mjs';
+import { verifyStandingGrantEpoch } from './authority-continuity-r65.mjs';
 
 export const PROCESS_POLICY_SCHEMA = 'deadbyte.process-policy.v1';
 export const PROCESS_GRANT_SCHEMA = 'deadbyte.process-grant.v1';
@@ -124,8 +125,8 @@ function configuredStatus(policy, reason) {
     policy_sha256: policy.policy_sha256
   };
 }export async function processSessionStatus(policy) {
-  let grant;
-  try { grant = JSON.parse(decodeUtf8Strict(await readFile(policy.grant_file))); }
+  let grant,grantBytes;
+  try { grantBytes=await readFile(policy.grant_file); grant = JSON.parse(decodeUtf8Strict(grantBytes)); }
   catch (error) { return configuredStatus(policy, error?.code === 'ENOENT' ? 'disarmed' : 'invalid-grant'); }
   if (!grant || grant.schema !== PROCESS_GRANT_SCHEMA) return configuredStatus(policy, 'grant-schema');
   if (grant.policy_sha256 !== policy.policy_sha256) return configuredStatus(policy, 'policy-digest');
@@ -136,10 +137,12 @@ function configuredStatus(policy, reason) {
       grant.root_ids.some(id => !ID_RE.test(id) || !policy.roots[id])) return configuredStatus(policy, 'roots-invalid');
   const profileIds = [...new Set(grant.profile_ids)].sort();
   const rootIds = [...new Set(grant.root_ids)].sort();
+  const epoch=await verifyStandingGrantEpoch({plane:'process',grantFile:policy.grant_file,grantBytes,grantInstanceNonce:grant.instance_nonce,policyPath:policy.policy_path});
+  if(!epoch.trusted)return configuredStatus(policy,epoch.reason);
   return {
     configured: true, armed: true, reason: 'standing-grant', expires_at_utc: null,
     root_ids: rootIds, profile_ids: profileIds, policy_sha256: policy.policy_sha256,
-    instance_nonce: grant.instance_nonce, standing: true
+    instance_nonce: grant.instance_nonce, standing: true, authority_epoch:epoch
   };
 }
 
@@ -168,4 +171,4 @@ export async function recheckProcessAuthority(policy, initial, profileId = null,
     current.root_ids.some((id, index) => id !== initial.root_ids[index]);
   if (changed) throw new Error('process authority changed during operation');
   return current;
-}
+}

package/src/remote-authority.mjs

@@ -32,7 +32,16 @@ export function parseAuthorityObservation(raw){
     const entry=value.authority[plane];
     if(!entry||typeof entry!=='object'||typeof entry.armed!=='boolean'||typeof entry.configured!=='boolean'||typeof entry.reason!=='string')
       throw new Error(`controller authority ${plane} observation invalid`);
-    authority[plane]=Object.freeze({configured:entry.configured,armed:entry.armed,reason:entry.reason.slice(0,128)});
+    const hasEpochSeq=Object.hasOwn(entry,'epoch_seq'),hasEpochSha=Object.hasOwn(entry,'epoch_sha256');
+    if(hasEpochSeq!==hasEpochSha)throw new Error(`controller authority ${plane} epoch observation incomplete`);
+    let epochSeq=null,epochSha256=null;
+    if(hasEpochSeq){
+      if(!Number.isSafeInteger(entry.epoch_seq)||entry.epoch_seq<1||typeof entry.epoch_sha256!=='string'||!/^[0-9a-f]{64}$/.test(entry.epoch_sha256))
+        throw new Error(`controller authority ${plane} epoch observation invalid`);
+      epochSeq=entry.epoch_seq;epochSha256=entry.epoch_sha256;
+    }
+    authority[plane]=Object.freeze({configured:entry.configured,armed:entry.armed,reason:entry.reason.slice(0,128),
+      epoch_seq:epochSeq,epoch_sha256:epochSha256});
   }
   return Object.freeze({...value,authority:Object.freeze(authority)});
 }

package/src/runtime-update.mjs

@@ -859,7 +859,7 @@ async function captureRuntime(ctx){
   const bridge=await readLedger(ctx,'bridge'); const cloud=await readLedger(ctx,'cloud'); const core=coreProcess(ctx.core_root,bridge);
   return {status,status_text:statusText.trim(),bridge,cloud,core};
 }
-export async function capturePredecessor(ctx,recoverOfflinePredecessor){
+export async function capturePredecessor(ctx,recoverOfflinePredecessor,{allowHostDisarm=true}={}){
   let statusText,status;
   try{
     statusText=controllerCaptured(ctx,'status',15000);
@@ -894,6 +894,7 @@ export async function capturePredecessor(ctx,recoverOfflinePredecessor){
   if(!recoverOfflinePredecessor) throw new Error(`slot update requires ONLINE runtime: ${statusText}`);
   if(!status.offline||status.bridge_pid||status.cloud_pid||status.local_ready) throw new Error(`offline predecessor recovery requires clean OFFLINE controller state: ${statusText}`);
   if(status.host_armed){
+    if(!allowHostDisarm) throw new Error('offline predecessor recovery requires host plane DISARMED');
     controllerCaptured(ctx,'disarmhost',15000);
     statusText=controllerCaptured(ctx,'status',15000);
     status=parseControllerStatus(statusText);
@@ -1235,7 +1236,7 @@ async function restoreRollbackLaunchers(plan){
 const UPDATE_PHASE_RANK=Object.freeze({
   initial:0,candidate_prepared:10,old_runtime_verified:20,shutdown_handoff_armed:25,supervisor_spawned:30,
   authority_revoked:40,old_runtime_stopped:50,workspace_ready:60,launcher_installed:70,pointer_committed:80,
-  fresh_runtime_verified:90,authority_verified:100,completed:110,superseded:120,failed:1000,failed_receipted:1001,failed_unreceipted:1002
+  fresh_runtime_verified:90,authority_verified:100,completed:110,superseded:120,failed:1000,failed_receipted:1001,failed_unreceipted:1002,precondition_rejected:1003
 });
 function phaseRank(phase){ return UPDATE_PHASE_RANK[String(phase)]??-1; }
 function activeTransitionPhase(phase){
@@ -1657,6 +1658,9 @@ export async function recoverInterruptedSlotUpdates({stateRoot=DEFAULT_STATE_ROO
 }
 
 export async function performSlotUpdate({stage,developmentRoot,expectedVersion,expectedManifest,sourceRoot=null,stateRoot=DEFAULT_STATE_ROOT,restoreStandingGrants=false,recoverOfflinePredecessor=false,cloudTransport=null,bridgeBootstrap=null,processPolicyBootstrap=null,hostPolicyBootstrap=null,codingPolicyBootstrap=null,desktopPolicyBootstrap=null,semanticLspBootstrap=null,enableMachineFs=false,enableObservation=false,enableDesktop=false,enableAutonomousSupervisor=false,hostCommandPins=[]}){
+  // R64 grants have no signed revocation epoch. The historical boolean restore
+  // cannot prove continuity, and must never materialize a successor grant.
+  if(restoreStandingGrants)throw new Error('R65 standing grant auto-restore disabled: explicit reauthorization required');
   stateRoot=resolveStateRoot(stateRoot);
   if(process.platform!=='win32') throw new Error('R27 slot update is Windows-only');
   const state=path.resolve(stateRoot),stageRoot=path.resolve(stage),development=assertDevelopmentRootSafe(developmentRoot,state);
@@ -1669,12 +1673,17 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
   await writeState(statePath,journal,'initial');
   let pointerInfo=null,control=null,predecessor=null,oldRuntime=null,priorStatus=null,authorityPreparation=null,workspace=null,launchers=null,newPointer=null;
   let stableMcpUrl=null,mcpUrlSnapshot=null;
+  let mutationBegan=false;
   try{
     pointerInfo=await loadPointerIfPresent(state);
     const stageVerified=await verifyPackageRoot(stageRoot,expectedVersion,expectedManifest,'stage');
     const developmentVerified=await verifyPackageRoot(development,expectedVersion,expectedManifest,'development');
-    const slot=await materializeReleaseSlot({source:stageRoot,stateRoot:state,version:expectedVersion,manifestSha256:expectedManifest});
     control=await loadControlInputs({stateRoot:state,sourceRoot,pointerInfo,bridgeBootstrap});
+    // Read-only predecessor authority and process identity must be safe before
+    // materializing a slot or changing any stable runtime file.
+    await capturePredecessor(control.ctx,recoverOfflinePredecessor,{allowHostDisarm:false});
+    mutationBegan=true;
+    const slot=await materializeReleaseSlot({source:stageRoot,stateRoot:state,version:expectedVersion,manifestSha256:expectedManifest});
     const hostBootstrap=await prepareHostPolicyBootstrap(hostPolicyBootstrap);if(hostBootstrap) control.hostPolicy=hostBootstrap.policy;
     const codingBootstrap=await prepareCodingPolicyBootstrap(codingPolicyBootstrap);if(codingBootstrap) control.codingPolicy=codingBootstrap.policy;
     const processBootstrap=await prepareProcessPolicyBootstrap(processPolicyBootstrap);
@@ -1722,7 +1731,7 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
       bridge:{working_directory:control.config.Bridge.WorkingDirectory,script_path:control.config.Bridge.ScriptPath,script_sha256:control.config.Bridge.ScriptSha256},
       host_repin:{requested:hostCommandPins.length>0,repinned:authorityPreparation.hostRepinned},coding_repin:{requested:hostCommandPins.length>0,repinned:authorityPreparation.codingRepinned},
       new_pointer:publicPointer(newPointer)});
-    predecessor=await capturePredecessor(control.ctx,recoverOfflinePredecessor);oldRuntime=predecessor.runtime;priorStatus=predecessor.status;
+    predecessor=await capturePredecessor(control.ctx,recoverOfflinePredecessor,{allowHostDisarm:false});oldRuntime=predecessor.runtime;priorStatus=predecessor.status;
     await writeState(statePath,journal,'old_runtime_verified',{predecessor_mode:predecessor.mode,old_runtime:generationTuple(oldRuntime),
       prior_authority:{process_armed:priorStatus.process_armed,coding_armed:priorStatus.coding_armed,autonomous_armed:priorStatus.autonomous_armed,desktop_armed:priorStatus.desktop_armed,host_armed:priorStatus.host_armed}});
     const handoff=await writeHandoff({stateRoot:state,state:journal,journal,statePath,evidenceDir,key,pointerInfo,newPointer,predecessor,priorStatus,workspace,launchers,stableMcpUrl,mcpUrlSnapshot,controlCtx:control.ctx});
@@ -1730,12 +1739,13 @@ export async function performSlotUpdate({stage,developmentRoot,expectedVersion,e
     return {ok:true,handed_off:true,completed:false,update_id:updateId,state_path:statePath,handoff_path:handoff.path,handoff_receipt_sha256:handoff.receipt.receipt_sha256,supervisor_pid:supervisor.pid,pointer:newPointer};
   }catch(error){
     const failure={schema:FAILURE_SCHEMA,update_id:updateId,release_version:expectedVersion,candidate_manifest_sha256:expectedManifest,failed_at_utc:new Date().toISOString(),
+      result:mutationBegan?'MUTATION_OUTCOME_REQUIRES_RECONCILIATION':'PRECONDITION_REJECTED',
       phase:journal.phase??'unknown',error:{name:error?.name??'Error',code:error?.code??null,message:String(error?.message??error)},
       predecessor_mode:predecessor?.mode??null,prior_pointer:publicPointer(pointerInfo?.pointer??null),attempted_pointer:publicPointer(newPointer),old_runtime:generationTuple(oldRuntime),
       rollback:{attempted:false,new_runtime_stopped:false,pointer_restored:false,launchers_restored:false,workspace_restored:false,mcp_url_restored:false,old_runtime_restarted:false,authority_restored:false,errors:[]}};
     await writeState(statePath,journal,'failed',{failure}).catch(()=>{});
     let failureReceipt=null;
-    try{ failureReceipt=await writeEnvelope(failurePath,failure,key);await writeState(statePath,journal,'failed_receipted',{failure_receipt_path:failurePath,failure_receipt_sha256:failureReceipt.receipt_sha256});}
+    try{ failureReceipt=await writeEnvelope(failurePath,failure,key);await writeState(statePath,journal,mutationBegan?'failed_receipted':'precondition_rejected',{failure_receipt_path:failurePath,failure_receipt_sha256:failureReceipt.receipt_sha256});}
     catch(receiptError){ await writeState(statePath,journal,'failed_unreceipted',{failure_receipt_error:String(receiptError?.message??receiptError)}).catch(()=>{}); }
     const wrapped=new Error('R27 slot update handoff failed: '+(error?.message??error));wrapped.cause=error;wrapped.statePath=statePath;wrapped.failureReceiptPath=failureReceipt?failurePath:null;throw wrapped;
   }

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.41';
+export const DEADBYTE_VERSION = '0.15.43';
 export const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const RECEIPT_SCHEMA_V1 = 'deadbyte.receipt.v1';
 export const RECEIPT_SCHEMA_V2 = 'deadbyte.receipt.v2';

package/test/audit-context.test.mjs

@@ -6,6 +6,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { releaseId } from '../src/release-slot.mjs';
 import { createAuditContextProvider } from '../src/audit-context.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const H=x=>x.repeat(64);
 const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
@@ -19,10 +20,20 @@ test('audit context binds verified active release, generation, machine and all a
     const manifestSha=sha(manifest);const generationRoot=path.join(root,'generations','g-test');await mkdir(generationRoot,{recursive:true});
     const generationSha=H('2');const rid=releaseId('0.8.7',manifestSha);
     await writeFile(path.join(root,'active-release.json'),JSON.stringify({schema:'deadbyte.active-release.v1',release_id:rid,version:'0.8.7',manifest_sha256:manifestSha,release_root:pkg,generation_root:generationRoot,generation_manifest_sha256:generationSha,launcher_sha256:H('3'),config_path:path.join(generationRoot,'controller-config.psd1')}));
-    const processPolicy={grant_file:path.join(root,'process-grant.json'),policy_sha256:H('4'),roots:{core:{}},profiles:{dev:{}}};
-    await writeFile(processPolicy.grant_file,JSON.stringify({schema:'deadbyte.process-grant.v1',policy_sha256:processPolicy.policy_sha256,instance_nonce:H('5'),profile_ids:['dev'],root_ids:['core']}));
-    const hostPolicy={arm_file:path.join(root,'host-grant.json'),policy_sha256:H('6')};
-    await writeFile(hostPolicy.arm_file,JSON.stringify({schema:'deadbyte.host-grant.v2',policy_sha256:hostPolicy.policy_sha256,instance_nonce:H('7')}));
+    const processPolicyFile=path.join(root,'process-policy.json');
+    const processPolicyBytes=Buffer.from(JSON.stringify({schema:'deadbyte.process-policy.v1',enabled:true,
+      grant_file:path.join(root,'runtime','process-grant.json'),state_dir:path.join(root,'process-state'),
+      native_host:{path:process.execPath,sha256:H('a')},roots:{core:{path:root,deny_paths:[]}},
+      profiles:{dev:{executable:process.execPath,executable_sha256:H('a'),root_ids:['core'],prefix_args:[],transport:'pipe',allow_raw_input:false,max_args:8,max_arg_bytes:1024,max_sessions:1,max_input_bytes:4096,max_retained_output_bytes:4096}}}));
+    await writeFile(processPolicyFile,processPolicyBytes);
+    const processPolicy={grant_file:path.join(root,'runtime','process-grant.json'),policy_path:processPolicyFile,policy_sha256:sha(processPolicyBytes),roots:{core:{}},profiles:{dev:{}}};
+    await writeBoundStandingGrant('process',processPolicy.grant_file,{schema:'deadbyte.process-grant.v1',policy_sha256:processPolicy.policy_sha256,instance_nonce:H('5'),profile_ids:['dev'],root_ids:['core']});
+    const hostPolicyFile=path.join(root,'host-policy.json');
+    const hostPolicyBytes=Buffer.from(JSON.stringify({schema:'deadbyte.host-policy.v2',enabled:true,
+      arm_file:path.join(root,'runtime','host-grant.json'),roots:{core:{path:root,read:true,write:false,exec:false,deny_paths:[]}},commands:{},max_read_bytes:4096,max_write_bytes:4096}));
+    await writeFile(hostPolicyFile,hostPolicyBytes);
+    const hostPolicy={arm_file:path.join(root,'runtime','host-grant.json'),policy_path:hostPolicyFile,policy_sha256:sha(hostPolicyBytes)};
+    await writeBoundStandingGrant('host',hostPolicy.arm_file,{schema:'deadbyte.host-grant.v2',policy_sha256:hostPolicy.policy_sha256,instance_nonce:H('7')});
     const machineRuntime={status:async()=>({status:'ok',release_id:rid,release_manifest_sha256:manifestSha,generation_manifest_sha256:generationSha,machine_id:H('8'),identity_generation:9,online_epoch:H('9')})};
     const codingRuntime={sessionStatus:async()=>({status:'ok',configured:true,armed:true,reason:'standing-grant'})};
     const autonomousRuntime={sessionStatus:async()=>({status:'ok',configured:true,armed:true,autonomous_armed:true,autonomous_reason:'standing-grant'})};

package/test/autonomous-local-supervisor.test.mjs

@@ -18,6 +18,7 @@ import {
   startLocalSupervisorHost, recoverManagedRuntime, runPinnedControllerOperation
 } from '../src/autonomous-local-supervisor.mjs';
 import { localSupervisorFixture } from './helpers/autonomous-r34-fixture.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const here=path.dirname(fileURLToPath(import.meta.url));
 const repoRoot=path.resolve(here,'..');
@@ -32,11 +33,11 @@ async function createProviderHostFixture(){
   const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
   const codingPath=path.join(root,'coding.json');
   await writeFile(codingPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
-    lease_file:path.join(root,'coding-grant.json'),evidence_dir:path.join(root,'coding-evidence'),
+    lease_file:path.join(root,'runtime','coding-grant.json'),evidence_dir:path.join(root,'coding-evidence'),
     roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:[]}},commands:{}}));
   const codingPolicy=await loadCodingPolicy(codingPath);
-  await writeFile(codingPolicy.lease_file,JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:codingPolicy.policy_sha256,
-    instance_nonce:nonce(),root_ids:['project'],granted_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('coding', codingPolicy.lease_file, {schema:'deadbyte.coding-grant.v2',policy_sha256:codingPolicy.policy_sha256,
+    instance_nonce:nonce(),root_ids:['project'],granted_at_utc:new Date().toISOString()});
   let round=0;
   const planner=createServer(async(req,res)=>{ let body=''; for await(const chunk of req) body+=chunk; JSON.parse(body); round+=1;
     const decision=round===1
@@ -47,13 +48,13 @@ async function createProviderHostFixture(){
   await new Promise(resolve=>planner.listen(0,'127.0.0.1',resolve));
   const autonomousPath=path.join(root,'autonomous.json');
   await writeFile(autonomousPath,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
-    lease_file:path.join(root,'autonomous-grant.json'),evidence_dir:path.join(root,'autonomous-evidence'),
+    lease_file:path.join(root,'runtime','autonomous-grant.json'),evidence_dir:path.join(root,'autonomous-evidence'),
     coding_policy_sha256:codingPolicy.policy_sha256,root_ids:['project'],
     planner:{backend:'openai_compatible',endpoint:`http://127.0.0.1:${planner.address().port}/v1/chat/completions`,model:'r34-host-test',max_tokens:2048,timeout_ms:30000,max_response_bytes:262144},
     limits:{max_iterations:8,max_mutations:8,max_wall_ms:null,max_context_bytes:262144,max_diff_bytes:262144,max_files_per_diff:4},profiles:{}}));
   const autonomousPolicy=await loadAutonomousPolicy(autonomousPath,codingPolicy);
-  await writeFile(autonomousPolicy.lease_file,JSON.stringify({schema:'deadbyte.autonomous-grant.v2',policy_sha256:autonomousPolicy.policy_sha256,
-    instance_nonce:nonce(),root_ids:['project'],granted_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('autonomous', autonomousPolicy.lease_file, {schema:'deadbyte.autonomous-grant.v2',policy_sha256:autonomousPolicy.policy_sha256,
+    instance_nonce:nonce(),root_ids:['project'],granted_at_utc:new Date().toISOString()});
   const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   const nativeDiffRuntime=createNativeDiffRuntime({policy:autonomousPolicy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   const runtime=createAutonomousRuntime({policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});

package/test/autonomous-supervisor-integration.test.mjs

@@ -10,6 +10,7 @@ import { fileURLToPath } from 'node:url';
 import { Client } from '@modelcontextprotocol/client';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
 import { generateTrustKeypair } from '../src/trust.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(here, '..');
@@ -52,18 +53,18 @@ async function startPlanner() {
   const codingPath = path.join(root, 'coding.json');
   await writeFile(codingPath, JSON.stringify({
     schema:'deadbyte.coding-policy.v1', enabled:true,
-    lease_file:path.join(root, 'coding-grant.json'), evidence_dir:path.join(root, 'coding-evidence'),
+    lease_file:path.join(root, 'runtime', 'coding-grant.json'), evidence_dir:path.join(root, 'coding-evidence'),
     roots:{ project:{ path:project, read:true, write:true, exec:false, deny_paths:[] } }, commands:{}
   }));
   const codingSha = sha(await readFile(codingPath));
-  await writeFile(path.join(root, 'coding-grant.json'), JSON.stringify({
+  await writeBoundStandingGrant('coding', path.join(root, 'runtime', 'coding-grant.json'), {
     schema:'deadbyte.coding-grant.v2', policy_sha256:codingSha,
     instance_nonce:nonce(), root_ids:['project'], granted_at_utc:new Date().toISOString()
-  }));
+  });
   const planner = await startPlanner();
   const autonomousPath = path.join(root, 'autonomous.json');  await writeFile(autonomousPath, JSON.stringify({
     schema:'deadbyte.autonomous-policy.v1', enabled:true,
-    lease_file:path.join(root, 'autonomous-grant.json'), evidence_dir:path.join(root, 'autonomous-evidence'),
+    lease_file:path.join(root, 'runtime', 'autonomous-grant.json'), evidence_dir:path.join(root, 'autonomous-evidence'),
     coding_policy_sha256:codingSha, root_ids:['project'],
     planner:{ backend:'openai_compatible', endpoint:planner.endpoint, model:'fake-supervisor', max_tokens:2048,
       timeout_ms:30000, max_response_bytes:262144 },
@@ -71,10 +72,10 @@ async function startPlanner() {
       max_context_bytes:262144, max_diff_bytes:262144, max_files_per_diff:4 }, profiles:{}
   }));
   const autonomousSha = sha(await readFile(autonomousPath));
-  await writeFile(path.join(root, 'autonomous-grant.json'), JSON.stringify({
+  await writeBoundStandingGrant('autonomous', path.join(root, 'runtime', 'autonomous-grant.json'), {
     schema:'deadbyte.autonomous-grant.v2', policy_sha256:autonomousSha,
     instance_nonce:nonce(), root_ids:['project'], granted_at_utc:new Date().toISOString()
-  }));
+  });
   const client = new Client({ name:'deadbyte-supervisor-integration', version:'0.8.0' },
     { versionNegotiation:{ mode:{ pin:'2026-07-28' } } });
   const transport = new StdioClientTransport({
@@ -148,4 +149,4 @@ test('external supervisor mode leaves provider goal durable until standalone hos
     await new Promise(resolve=>f.planner.server.close(resolve));
     await rm(f.root,{recursive:true,force:true});
   }
-});
+});

package/test/capability-resolver.test.mjs

@@ -2,6 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import os from 'node:os';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import {
   CAPABILITY_STATES,
@@ -9,6 +10,7 @@ import {
   resolveCapabilityStates
 } from '../src/capability-resolver.mjs';
 import { R36_CAPABILITY_LEDGER } from '../src/capability-ledger.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 test('capability resolver enforces 5 canonical states', () => {
   assert.equal(CAPABILITY_STATES.AVAILABLE, 'AVAILABLE');
@@ -187,14 +189,18 @@ test('capability resolver reports actual disarmed authority across coding proces
 test('capability resolver reports armed Host capability when the standing grant is valid', async () => {
   const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-capability-host-'));
   try{
-    const armFile=path.join(root,'host-grant.json');
-    const policySha='b'.repeat(64);
-    await writeFile(armFile,JSON.stringify({
+    const armFile=path.join(root,'runtime','host-grant.json');
+    const policyFile=path.join(root,'host-policy.json');
+    const policyBytes=Buffer.from(JSON.stringify({schema:'deadbyte.host-policy.v2',enabled:true,arm_file:armFile,
+      roots:{core:{path:root,read:true,write:false,exec:false,deny_paths:[]}},commands:{},max_read_bytes:4096,max_write_bytes:4096}));
+    await writeFile(policyFile,policyBytes);
+    const policySha=createHash('sha256').update(policyBytes).digest('hex');
+    await writeBoundStandingGrant('host',armFile,{
       schema:'deadbyte.host-grant.v2',
       policy_sha256:policySha,
       instance_nonce:'c'.repeat(64),
       armed_at_utc:new Date().toISOString()
-    }));
+    });
     const result=await resolveCapabilityStates({
       ledger:{entries:[{
         id:'host.file_read',compact_tool:'host_file_read',full_tool:'host_file_read',compact_op:'direct',
@@ -203,7 +209,7 @@ test('capability resolver reports armed Host capability when the standing grant
       toolCatalog:['host_file_read'],
       profile:'compact',
       env:{},
-      hostPolicy:{arm_file:armFile,policy_sha256:policySha}
+      hostPolicy:{arm_file:armFile,policy_path:policyFile,policy_sha256:policySha}
     });
     const hostRead=result.capabilities[0];
     assert.equal(hostRead.state,CAPABILITY_STATES.AVAILABLE);

package/test/codex-autonomous-r44.test.mjs

@@ -10,6 +10,7 @@ import { loadAutonomousPolicy } from '../src/autonomous-policy.mjs';
 import { createNativeDiffRuntime } from '../src/native-diff.mjs';
 import { createAutonomousRuntime } from '../src/autonomous-runtime.mjs';
 import { providerCircuitId } from '../src/provider-circuit.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha=b=>createHash('sha256').update(b).digest('hex');
 const nonce=()=>randomBytes(32).toString('hex');
@@ -21,13 +22,13 @@ async function fixture(){
   const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
   const codingPath=path.join(root,'coding.json');
   await writeFile(codingPath,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
-    lease_file:path.join(root,'coding-grant.json'),evidence_dir:path.join(root,'coding-evidence'),
+    lease_file:path.join(root,'runtime','coding-grant.json'),evidence_dir:path.join(root,'coding-evidence'),
     roots:{project:{path:project,read:true,write:true,exec:false,deny_paths:[]}},commands:{}},null,2));
   const codingPolicy=await loadCodingPolicy(codingPath);
   const nodeSha=sha(await readFile(process.execPath));
   const autonomousPath=path.join(root,'autonomous.json');
   await writeFile(autonomousPath,JSON.stringify({schema:'deadbyte.autonomous-policy.v1',enabled:true,
-    lease_file:path.join(root,'autonomous-grant.json'),evidence_dir:path.join(root,'autonomous-evidence'),
+    lease_file:path.join(root,'runtime','autonomous-grant.json'),evidence_dir:path.join(root,'autonomous-evidence'),
     coding_policy_sha256:codingPolicy.policy_sha256,root_ids:['project'],
     planner:{backend:'codex_app_server',model:'gpt-test',root_id:'project',executable:process.execPath,
       executable_sha256:nodeSha,args:['app-server'],max_tokens:4096,timeout_ms:30000,
@@ -35,10 +36,10 @@ async function fixture(){
     profiles:{},limits:{max_iterations:8,max_mutations:4,max_wall_ms:600000,max_context_bytes:262144,
       max_diff_bytes:262144,max_files_per_diff:4,max_stalled_cycles:2,max_post_replan_stalls:2,max_replans:4}},null,2));
   const policy=await loadAutonomousPolicy(autonomousPath,codingPolicy);
-  await writeFile(codingPolicy.lease_file,JSON.stringify({schema:'deadbyte.coding-grant.v2',policy_sha256:codingPolicy.policy_sha256,
-    instance_nonce:nonce(),root_ids:['project'],armed_at_utc:new Date().toISOString()}));
-  await writeFile(policy.lease_file,JSON.stringify({schema:'deadbyte.autonomous-grant.v2',policy_sha256:policy.policy_sha256,
-    instance_nonce:nonce(),root_ids:['project'],armed_at_utc:new Date().toISOString()}));
+  await writeBoundStandingGrant('coding', codingPolicy.lease_file, {schema:'deadbyte.coding-grant.v2',policy_sha256:codingPolicy.policy_sha256,
+    instance_nonce:nonce(),root_ids:['project'],armed_at_utc:new Date().toISOString()});
+  await writeBoundStandingGrant('autonomous', policy.lease_file, {schema:'deadbyte.autonomous-grant.v2',policy_sha256:policy.policy_sha256,
+    instance_nonce:nonce(),root_ids:['project'],armed_at_utc:new Date().toISOString()});
   const codingRuntime=createCodingRuntime({policy:codingPolicy,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   const nativeDiffRuntime=createNativeDiffRuntime({policy,codingRuntime,signingKeyPath:keys.privateKeyPath,verifyKeyPath:keys.publicKeyPath});
   return {root,project,keys,codingPolicy,policy,codingRuntime,nativeDiffRuntime,cleanup:()=>rm(root,{recursive:true,force:true})};

package/test/coding-observation.test.mjs

@@ -6,6 +6,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { generateTrustKeypair } from '../src/trust.mjs';
 import { createCodingRuntime, loadCodingPolicy } from '../src/coding-plane.mjs';
+import { writeBoundStandingGrant } from './r65-authority-fixture.mjs';
 
 const sha = bytes => createHash('sha256').update(bytes).digest('hex');
 
@@ -18,7 +19,7 @@ async function fixture() {
   await writeFile(path.join(project, 'src', 'b.txt'), 'beta NEEDLE two\n');
   await writeFile(path.join(project, 'node_modules', 'hidden.txt'), 'needle hidden\n');
   const policyPath = path.join(root, 'coding-policy.json');
-  const leasePath = path.join(root, 'coding-grant.json');
+  const leasePath = path.join(root, 'runtime', 'coding-grant.json');
   await writeFile(policyPath, JSON.stringify({
     schema: 'deadbyte.coding-policy.v1', enabled: true,
     lease_file: leasePath, evidence_dir: path.join(root, 'evidence'),
@@ -26,10 +27,10 @@ async function fixture() {
     commands: {}
   }));
   const policy = await loadCodingPolicy(policyPath);
-  await writeFile(leasePath, JSON.stringify({
+  await writeBoundStandingGrant('coding', leasePath, {
     schema: 'deadbyte.coding-grant.v2', policy_sha256: policy.policy_sha256,
     instance_nonce: 'a'.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/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');