deadbyte-mcp 0.15.39 → 0.15.42

package/src/deadbyte-cli.mjs

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

package/src/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-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/machine-fs-mcp-tools.mjs

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

package/src/machine-fs.mjs

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

package/src/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

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