deadbyte-mcp 0.15.35 → 0.15.37

package/src/remote-log-decode-r60.mjs

@@ -0,0 +1,32 @@
+import path from 'node:path';
+
+export function safeRemoteLogPrefixLength(bytes,encoding='utf8'){
+  if(!Buffer.isBuffer(bytes))throw new Error('remote log prefix bytes invalid');
+  if(encoding==='utf16le'){
+    let size=bytes.length-(bytes.length%2);
+    if(size>=2){const last=bytes.readUInt16LE(size-2);if(last>=0xd800&&last<=0xdbff)size-=2;}
+    return size;
+  }
+  if(encoding!=='utf8')throw new Error('remote log prefix encoding invalid');
+  let index=bytes.length-1;
+  while(index>=0&&(bytes[index]&0xc0)===0x80)index--;
+  if(index<0)return 0;
+  const lead=bytes[index];
+  const needed=lead<0x80?1:lead>=0xc2&&lead<=0xdf?2:lead>=0xe0&&lead<=0xef?3:lead>=0xf0&&lead<=0xf4?4:1;
+  return bytes.length-index<needed?index:bytes.length;
+}
+
+export function decodeRemoteLogBytes(file,bytes,{encoding=null}={}){
+  if(typeof file!=='string'||!Buffer.isBuffer(bytes))throw new Error('remote log decoder input invalid');
+  const knownLog=/\.log$/i.test(path.basename(file));
+  if(!knownLog)return bytes.toString('utf8');
+  const utf16=encoding==='utf16le'||(bytes.length>=2&&bytes[0]===0xff&&bytes[1]===0xfe);
+  if(!utf16)return bytes.toString('utf8').replace(/^\uFEFF/,'');
+  return bytes.toString('utf16le').replace(/^\uFEFF/,'');
+}
+
+export function boundedRemoteDiagnostic(value,maxChars=2048){
+  if(!Number.isInteger(maxChars)||maxChars<32||maxChars>8192)throw new Error('remote diagnostic bound invalid');
+  const line=String(value??'').replace(/\x1b\[[0-9;]*[A-Za-z]/g,'').replace(/[\x00-\x1f\x7f]+/g,' ').replace(/\s{2,}/g,' ').trim();
+  return line.length<=maxChars?line:`${line.slice(0,maxChars)}...`;
+}

package/src/remote-mcp-machine-smoke-client.mjs

@@ -1,11 +1,17 @@
 import { randomBytes } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
 import { verifyMachinePingPublic } from './machine-identity.mjs';
+import { parseActivePointer } from './release-slot.mjs';
+import { probeRemoteEnforcement } from './remote-enforcement-probe-r60.mjs';
 
 const endpointText = process.argv[2];
 if (!endpointText) throw new Error('usage: node src/remote-mcp-machine-smoke-client.mjs https://host/mcp/path');
 const endpoint = new URL(endpointText);
 if (endpoint.protocol !== 'https:') throw new Error('machine live gate requires HTTPS');
+const enforcementMode=process.argv[3]??null;
+if(enforcementMode!==null&&!['default','desktop','host','full','revoked'].includes(enforcementMode))throw new Error('remote enforcement probe mode invalid');
 
 const machineTools = ['machine_list', 'machine_ping', 'machine_revoke', 'machine_status'];
 const client = new Client(
@@ -49,6 +55,17 @@ try {
   }
   const signatureVerified = await verifyMachinePingPublic({ ping, publicKeySpkiBase64: status.public_key_spki_base64 });
   if (!signatureVerified) throw new Error('machine ping public Ed25519 verification failed');
+  if(enforcementMode!==null){
+    const stateRoot=process.env.DEADBYTE_STATE_ROOT;
+    if(!stateRoot||!path.isAbsolute(stateRoot))throw new Error('remote enforcement probe state root missing');
+    const pointer=parseActivePointer(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+    for(const [actual,expected] of [
+      [status.release_id,pointer.release_id],
+      [status.release_manifest_sha256,pointer.manifest_sha256],
+      [status.generation_manifest_sha256,pointer.generation_manifest_sha256]
+    ])if(actual!==expected)throw new Error('signed machine status does not bind active release/generation');
+    await probeRemoteEnforcement({client,mode:enforcementMode});
+  }
 
   console.log(JSON.stringify({
     status: 'passed',
@@ -59,7 +76,8 @@ try {
     release_id: status.release_id,
     release_manifest_sha256: status.release_manifest_sha256,
     generation_manifest_sha256: status.generation_manifest_sha256,
-    signature_verified: true
+    signature_verified: true,
+    ...(enforcementMode?{enforcement_mode:enforcementMode,enforcement_verified:true}:{})
   }));
 } finally {
   await client.close().catch(() => {});

package/src/remote-mcp-r40-parity-client.mjs

@@ -98,7 +98,7 @@ export async function runR40CompactParity(endpointText){
       if(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false||!tool.outputSchema?.properties) throw new Error(`tool ${tool.name} missing strict output schema`);
     }
     const manifest=gateway(await client.callTool({name:'capability_manifest',arguments:{}}),'capability_manifest');
-    if(manifest.schema!=='deadbyte.capability-manifest.v2'||manifest.profile!=='compact'||!Array.isArray(manifest.capabilities)||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R40 compact capability manifest malformed');
+    if(!['deadbyte.capability-manifest.v2','deadbyte.capability-manifest.v3'].includes(manifest.schema)||manifest.profile!=='compact'||!Array.isArray(manifest.capabilities)||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R40 compact capability manifest malformed');
     if(manifest.tool_count!==names.length||JSON.stringify(manifest.tool_catalog)!==JSON.stringify(names)||
       manifest.catalog_sha256!==sha256(Buffer.from(JSON.stringify(names),'utf8'))) throw new Error('R40 compact manifest catalog binding mismatch');
     const required=manifest.capabilities.filter(item=>item?.production===true&&item?.host_only!==true);

package/src/remote-mcp-r44-parity-client.mjs

@@ -98,7 +98,7 @@ export async function runR44CompactParity(endpointText){
       if(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false||!tool.outputSchema?.properties) throw new Error(`tool ${tool.name} missing strict output schema`);
     }
     const manifest=gateway(await client.callTool({name:'capability_manifest',arguments:{}}),'capability_manifest');
-    if(manifest.schema!=='deadbyte.capability-manifest.v2'||manifest.profile!=='compact'||!Array.isArray(manifest.capabilities)||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R44 compact capability manifest malformed');
+    if(!['deadbyte.capability-manifest.v2','deadbyte.capability-manifest.v3'].includes(manifest.schema)||manifest.profile!=='compact'||!Array.isArray(manifest.capabilities)||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R44 compact capability manifest malformed');
     if(manifest.tool_count!==names.length||JSON.stringify(manifest.tool_catalog)!==JSON.stringify(names)||
       manifest.catalog_sha256!==sha256(Buffer.from(JSON.stringify(names),'utf8'))) throw new Error('R44 compact manifest catalog binding mismatch');
     const required=manifest.capabilities.filter(item=>item?.production===true&&item?.host_only!==true);

package/src/remote-mcp-r45-parity-client.mjs

@@ -98,7 +98,7 @@ export async function runR45CompactParity(endpointText){
       if(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false||!tool.outputSchema?.properties) throw new Error(`tool ${tool.name} missing strict output schema`);
     }
     const manifest=gateway(await client.callTool({name:'capability_manifest',arguments:{}}),'capability_manifest');
-    if(manifest.schema!=='deadbyte.capability-manifest.v2'||manifest.profile!=='compact'||!Array.isArray(manifest.capabilities)||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R45 compact capability manifest malformed');
+    if(!['deadbyte.capability-manifest.v2','deadbyte.capability-manifest.v3'].includes(manifest.schema)||manifest.profile!=='compact'||!Array.isArray(manifest.capabilities)||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R45 compact capability manifest malformed');
     if(manifest.tool_count!==names.length||JSON.stringify(manifest.tool_catalog)!==JSON.stringify(names)||
       manifest.catalog_sha256!==sha256(Buffer.from(JSON.stringify(names),'utf8'))) throw new Error('R45 compact manifest catalog binding mismatch');
     const required=manifest.capabilities.filter(item=>item?.production===true&&item?.host_only!==true);

package/src/remote-mcp-smoke-client.mjs

@@ -127,7 +127,7 @@ try {
   if (compactProfile) {
     const manifest = gateway(await client.callTool({ name: 'capability_manifest', arguments: {} }), 'capability_manifest');
     const manifestV1 = manifest.schema === 'deadbyte.capability-manifest.v1' && exactR36Compact;
-    const manifestV2 = manifest.schema === 'deadbyte.capability-manifest.v2' && (exactR40Compact || exactR44Compact);
+    const manifestV2 = ['deadbyte.capability-manifest.v2','deadbyte.capability-manifest.v3'].includes(manifest.schema) && (exactR40Compact || exactR44Compact);
     if ((!manifestV1 && !manifestV2) || manifest.profile !== 'compact' ||
         !Array.isArray(manifest.capabilities) || !/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256 ?? ''))) {
       throw new Error('compact capability manifest malformed');

package/src/remote-session-guardian.mjs

@@ -6,8 +6,9 @@ import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
+import { AUTHORITY_PLANES, parseAuthorityObservation, assertAuthorityVector } from './remote-authority.mjs';
 
-const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park'];
+const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost'];
 // This inherited IPC channel is an OS-owned parent lifetime handle, not a PID
 // poll. A reused PID cannot keep a new foreground guardian alive.
 let ownerDisconnected=false;
@@ -42,12 +43,23 @@ function markerMatches(marker,{ownerPid,nonce}){
     marker?.owner_pid===ownerPid&&
     marker?.session_nonce===nonce;
 }
-function invokeCleanup(powershell,launcher,command,stateRoot){
+function invokeCleanup(powershell,launcher,command,stateRoot,probeMode=null){
   const result=spawnSync(powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,command],{
-    stdio:'ignore',windowsHide:true,shell:false,env:windowsPowerShellEnvironment({...process.env,DEADBYTE_STATE_ROOT:stateRoot}),timeout:30000
+    stdio:'ignore',windowsHide:true,shell:false,env:windowsPowerShellEnvironment({...process.env,DEADBYTE_STATE_ROOT:stateRoot,
+      ...(probeMode?{DEADBYTE_REMOTE_PROBE_MODE:probeMode}:{})}),timeout:probeMode?150000:30000
   });
   return !result.error&&result.status===0;
 }
+function verifyRevoked(powershell,launcher,stateRoot){
+  const result=spawnSync(powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,'status','-Json'],{
+    stdio:['ignore','pipe','pipe'],encoding:'utf8',windowsHide:true,shell:false,
+    env:windowsPowerShellEnvironment({...process.env,DEADBYTE_STATE_ROOT:stateRoot}),timeout:30000
+  });
+  if(result.error||result.status!==0) return null;
+  try{
+    return assertAuthorityVector(parseAuthorityObservation(result.stdout),Object.fromEntries(AUTHORITY_PLANES.map(plane=>[plane,false])));
+  }catch{return null;}
+}
 
 async function main(){
   if(process.platform!=='win32') return;
@@ -82,6 +94,11 @@ async function main(){
       if(!invokeCleanup(powershell,launcher,command,root)) failed.push(command);
     }
     if(failed.length) throw new Error('guardian cleanup failed; ownership marker retained: '+failed.join(','));
+    const observed=verifyRevoked(powershell,launcher,root);
+    if(!observed) throw new Error('guardian authority cleanup unverified; ownership marker retained');
+    if(observed.state==='ONLINE'&&!invokeCleanup(powershell,launcher,'machinetest',root,'revoked'))
+      throw new Error('guardian runtime enforcement cleanup unverified; ownership marker retained');
+    if(!invokeCleanup(powershell,launcher,'park',root)) throw new Error('guardian park failed; ownership marker retained');
     const current=await readMarker(markerPath);
     if(current&&markerMatches(current,{ownerPid,nonce})) await rm(markerPath,{force:true});
     return;

package/src/runtime-plane-registry.mjs

@@ -0,0 +1,74 @@
+const PLANE_ID=/^[a-z][a-z0-9_-]{0,63}$/;
+
+function boundedReason(error){
+  const text=error instanceof Error?error.message:String(error);
+  return text.replace(/[\r\n\t]+/g,' ').slice(0,1024);
+}
+
+export class RuntimePlaneUnavailableError extends Error {
+  constructor(plane,diagnostic={}){
+    super(`${plane} runtime unavailable: ${String(diagnostic.reason??diagnostic.code??'not ready')}`);
+    this.name='RuntimePlaneUnavailableError';
+    this.code='DEADBYTE_RUNTIME_UNAVAILABLE';
+    this.plane=plane;
+    this.diagnostic=diagnostic;
+  }
+}
+
+export function createUnavailableRuntime(plane,diagnostic={}){
+  if(typeof plane!=='string'||!PLANE_ID.test(plane)) throw new Error('runtime plane id invalid');
+  const fail=()=>Promise.reject(new RuntimePlaneUnavailableError(plane,diagnostic));
+  return new Proxy(Object.freeze({plane,unavailable:true,diagnostic}),{
+    get(target,property){
+      if(property in target) return target[property];
+      if(property==='then') return undefined;
+      return fail;
+    }
+  });
+}
+
+export function createRuntimePlaneRegistry(){
+  const planes=new Map();
+  let epoch=0;
+  function update(id,next){
+    planes.set(id,Object.freeze({...next}));
+    epoch++;
+    return next.runtime??null;
+  }
+  function define(id,{configured,required=false,dependencies=[]}={}){
+    if(typeof id!=='string'||!PLANE_ID.test(id)||planes.has(id)) throw new Error(`runtime plane definition invalid: ${String(id)}`);
+    if(!Array.isArray(dependencies)||dependencies.some(dep=>typeof dep!=='string'||!PLANE_ID.test(dep))) throw new Error(`runtime plane dependencies invalid: ${id}`);
+    planes.set(id,Object.freeze({id,configured:configured===true,required:required===true,dependencies:[...new Set(dependencies)],state:configured===true?'STARTING':'DISABLED',ready:false,runtime:null,diagnostic:configured===true?null:{code:'RUNTIME_DISABLED',reason:'runtime is not configured',recoverable:false}}));
+  }
+  async function initialize(id,initializer,{policySha256=null}={}){
+    const current=planes.get(id);
+    if(!current) throw new Error(`runtime plane not defined: ${id}`);
+    if(!current.configured) return null;
+    for(const dependency of current.dependencies){
+      const dep=planes.get(dependency);
+      if(!dep||!dep.ready){
+        return update(id,{...current,state:'UNAVAILABLE',ready:false,runtime:null,policy_sha256:policySha256,
+          diagnostic:{code:'DEPENDENCY_UNAVAILABLE',reason:`dependency '${dependency}' is not ready`,recoverable:true}});
+      }
+    }
+    try{
+      const runtime=await initializer();
+      if(!runtime) throw new Error('initializer returned no runtime');
+      return update(id,{...current,state:'READY',ready:true,runtime,policy_sha256:policySha256,diagnostic:null});
+    }catch(error){
+      if(current.required) throw error;
+      return update(id,{...current,state:'DEGRADED',ready:false,runtime:null,policy_sha256:policySha256,
+        diagnostic:{code:'INITIALIZATION_FAILED',reason:boundedReason(error),recoverable:true}});
+    }
+  }
+  function state(id){
+    const value=planes.get(id);
+    if(!value) throw new Error(`runtime plane not defined: ${id}`);
+    const {runtime,...publicState}=value;
+    return Object.freeze(publicState);
+  }
+  function runtime(id){return planes.get(id)?.runtime??null;}
+  function snapshot(){return Object.freeze({epoch,planes:Object.freeze(Object.fromEntries([...planes].map(([id])=>[id,state(id)])))});}
+  return Object.freeze({define,initialize,state,runtime,snapshot});
+}
+

package/src/tool-audit.mjs

@@ -116,7 +116,12 @@ function summarizeOutcome(result,error,durationMs){
   const structured=result?.structuredContent;
   const status=typeof structured?.status==='string'?structured.status:(result?.isError===true?'error':'ok');
   const isError=result?.isError===true;
+  const capability=structured?.result;
+  const snapshot=capability?.schema==='deadbyte.capability-manifest.v3'&&HEX64.test(String(capability.snapshot_id??''))&&
+    Number.isInteger(capability.state_epoch)&&capability.state_epoch>0
+    ?{snapshot_id:capability.snapshot_id,state_epoch:capability.state_epoch}:{};
   return {status:String(status).slice(0,128),is_error:isError,duration_ms:duration,receipt_sha256s:outcomeReceiptHashes(result),
+    ...snapshot,
     ...(isError?{reason:resultOutcomeReason(result)}:{})};
 }
 

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.35';
+export const DEADBYTE_VERSION = '0.15.37';
 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/bridge-runtime-r59.test.mjs

@@ -0,0 +1,60 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createBridgeGovernor } from '../bridge/src/r40-governor.mjs';
+import { createBridgeHealth } from '../bridge/src/bridge-health-r59.mjs';
+
+const limits={
+  normal:{max_active:1,max_queue:2,queue_timeout_ms:1000},
+  autonomous:{max_active:1,max_queue:1,queue_timeout_ms:1000},
+  desktop_observe:{max_active:1,max_queue:1,queue_timeout_ms:1000},
+  desktop_action:{max_active:1,max_queue:1,queue_timeout_ms:1000}
+};
+
+test('R59 bridge governor removes cancelled queued work and drains without replay',async()=>{
+  const governor=createBridgeGovernor({limits});
+  const first=await governor.acquire('machine_status');
+  const abort=new AbortController();
+  const queued=governor.acquire('machine_ping',{signal:abort.signal});
+  abort.abort(new Error('caller disconnected'));
+  await assert.rejects(queued,/caller disconnected|aborted/);
+  assert.equal(governor.snapshot().normal.queued,0);
+  assert.equal(governor.snapshot().normal.cancelled,1);
+  const queuedDuringRecovery=governor.acquire('machine_ping');
+  assert.equal(governor.reconcile('core generation changed'),1);
+  await assert.rejects(queuedDuringRecovery,/core generation changed/);
+  first.release();
+  const after=await governor.acquire('machine_status');
+  after.release();
+  const drain=governor.close('bridge reconciling');
+  await assert.rejects(governor.acquire('machine_status'),/closed/);
+  await drain;
+  assert.equal(governor.snapshot().normal.active,0);
+});
+
+test('R59 bridge health requires fresh child negotiation catalog and v3 capability attestation',()=>{
+  let now=100_000;
+  const health=createBridgeHealth({clock:()=>now,maxCapabilityAgeMs:15_000});
+  assert.equal(health.snapshot().http_status,503);
+  health.coreConnected({childIdentity:'core-abc',protocolEra:'modern',catalogSha256:'a'.repeat(64)});
+  assert.equal(health.snapshot().http_status,503);
+  health.capabilityObserved({schema:'deadbyte.capability-manifest.v3',snapshot_id:'b'.repeat(64),
+    state_epoch:3,observed_at_utc:new Date(now).toISOString(),valid_until_utc:new Date(now+5000).toISOString(),
+    bindings:{release_manifest_sha256:'c'.repeat(64),generation_manifest_sha256:'d'.repeat(64)}});
+  assert.equal(health.snapshot().state,'READY');
+  assert.equal(health.snapshot().http_status,200);
+  health.capabilityObserved({schema:'deadbyte.capability-manifest.v3',snapshot_id:'e'.repeat(64),state_epoch:4,
+    observed_at_utc:new Date(now).toISOString(),valid_until_utc:new Date(now+5000).toISOString(),
+    bindings:{release_manifest_sha256:'c'.repeat(64),generation_manifest_sha256:'d'.repeat(64)},
+    planes:{DEADBYTE_CODING_RUNTIME:{state:'DEGRADED',diagnostic:{code:'INITIALIZATION_FAILED'}}}});
+  assert.equal(health.snapshot().state,'DEGRADED');
+  assert.equal(health.snapshot().http_status,503);
+  health.capabilityObserved({schema:'deadbyte.capability-manifest.v3',snapshot_id:'b'.repeat(64),state_epoch:5,
+    observed_at_utc:new Date(now).toISOString(),valid_until_utc:new Date(now+5000).toISOString(),bindings:{}});
+  now+=15_001;
+  assert.equal(health.snapshot().state,'DEGRADED');
+  assert.equal(health.snapshot().http_status,503);
+  health.reconciling('core transport closed after dispatch');
+  const degraded=health.snapshot();
+  assert.equal(degraded.state,'RECONCILING');
+  assert.doesNotMatch(JSON.stringify(degraded),/token|secret|C:\\/i);
+});

package/test/capability-resolver.test.mjs

@@ -18,6 +18,22 @@ test('capability resolver enforces 5 canonical states', () => {
   assert.equal(CAPABILITY_STATES.UNAVAILABLE, 'UNAVAILABLE');
 });
 
+test('R59 live plane state can only reduce signed capability availability', async()=>{
+  const ledger={entries:[{
+    id:'coding.search',compact_tool:'coding_inspect',full_tool:'coding_search',compact_op:'search',
+    authority:'coding',mutating:false,production:true,runtime_flag:'DEADBYTE_CODING_RUNTIME'
+  }]};
+  const result=await resolveCapabilityStates({
+    ledger,toolCatalog:['coding_inspect'],profile:'compact',env:{DEADBYTE_CODING_RUNTIME:'1'},
+    codingRuntime:{sessionStatus:async()=>({armed:true})},
+    runtimePlanes:{DEADBYTE_CODING_RUNTIME:{state:'DEGRADED',ready:false,diagnostic:{code:'INITIALIZATION_FAILED',reason:'missing root',recoverable:true}}}
+  });
+  assert.equal(result.capabilities[0].state,CAPABILITY_STATES.DEGRADED);
+  assert.equal(result.capabilities[0].ready,false);
+  assert.equal(result.capabilities[0].diagnostic.code,'INITIALIZATION_FAILED');
+  assert.deepEqual(result.effective_capabilities,[]);
+});
+
 test('deriveCapabilityRequirements maps dependencies accurately', () => {
   const reqCodingRead = deriveCapabilityRequirements({
     id: 'coding.search',

package/test/capability-snapshot-r59.test.mjs

@@ -0,0 +1,39 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createCapabilitySnapshotTracker } from '../src/capability-snapshot.mjs';
+
+const H=value=>String(value).repeat(64).slice(0,64);
+const ledger={schema:'deadbyte.capability-ledger.v1',ledger_sha256:H('a'),entries:[{
+  id:'machine.status',full_tool:'machine_status',compact_tool:'machine_observe',compact_op:'machine_status',
+  runtime_flag:'DEADBYTE_MACHINE_RUNTIME',authority:'none',mutating:false,receipt_class:'machine',production:true,host_only:false
+}]};
+const resolution={capabilities:[{...ledger.entries[0],tool:'machine_observe',operations:['machine_status'],requires:['DEADBYTE_MACHINE_RUNTIME'],state:'AVAILABLE',ready:true,diagnostic:null}],effective_capabilities:['machine.status'],unavailable_capabilities:[],degraded_capabilities:[]};
+
+test('R59 capability snapshot v3 is a backward-compatible content-bound live overlay', () => {
+  let now=Date.parse('2026-10-02T12:00:00.000Z');
+  const tracker=createCapabilitySnapshotTracker({clock:()=>now,ttlMs:5000});
+  const input={profile:'compact',ledger,toolCatalog:['machine_observe'],catalogSha256:H('b'),resolution,
+    bindings:{release_id:'v0.15.36-test',release_manifest_sha256:H('c'),generation_manifest_sha256:H('d')},
+    planes:{machine:{state:'READY',ready:true,policy_sha256:null,diagnostic:null}}};
+  const first=tracker.snapshot(input);
+  assert.equal(first.schema,'deadbyte.capability-manifest.v3');
+  assert.equal(first.ledger_sha256,ledger.ledger_sha256);
+  assert.deepEqual(first.tool_catalog,['machine_observe']);
+  assert.equal(first.state_epoch,1);
+  assert.match(first.snapshot_id,/^[0-9a-f]{64}$/);
+  assert.equal(first.capabilities[0].selected_route.tool,'machine_observe');
+  now+=1000;
+  const same=tracker.snapshot(input);
+  assert.equal(same.snapshot_id,first.snapshot_id);
+  assert.equal(same.state_epoch,1);
+  assert.notEqual(same.observed_at_utc,first.observed_at_utc);
+  const changed=tracker.snapshot({...input,planes:{machine:{state:'DEGRADED',ready:false,policy_sha256:null,diagnostic:{code:'DOWN',reason:'probe failed'}}}});
+  assert.equal(changed.state_epoch,2);
+  assert.notEqual(changed.snapshot_id,first.snapshot_id);
+});
+
+test('R59 capability snapshot rejects routes outside the signed ledger', () => {
+  const tracker=createCapabilitySnapshotTracker();
+  assert.throws(()=>tracker.snapshot({profile:'compact',ledger,toolCatalog:['invented'],catalogSha256:H('b'),
+    resolution:{...resolution,capabilities:[{...resolution.capabilities[0],id:'invented.capability'}]},bindings:{},planes:{}}),/outside signed ledger/);
+});

package/test/compact-gateway-r36.test.mjs

@@ -72,7 +72,7 @@ test('R36 coding_inspect gateway calls runtime directly and never MCP-recurses',
   assert.equal(result.structuredContent.result.path,'src/a.mjs');
 });
 
-test('R40 capability manifest v2 attests the exact registered compact catalog',async()=>{
+test('R59 capability manifest v3 preserves exact compact catalog attestation',async()=>{
   const server=fakeServer();
   registerCompactGatewayTools(server,{
     profile:'compact',ledger:{schema:'deadbyte.capability-ledger.v1',entries:[],ledger_sha256:'a'.repeat(64)},
@@ -81,13 +81,33 @@ test('R40 capability manifest v2 attests the exact registered compact catalog',a
   });
   const result=await server.tools.get('capability_manifest').handler({});
   const manifest=result.structuredContent.result;
-  assert.equal(manifest.schema,'deadbyte.capability-manifest.v2');
+  assert.equal(manifest.schema,'deadbyte.capability-manifest.v3');
   assert.equal(manifest.profile,'compact');
   assert.deepEqual(manifest.tool_catalog,[...server.tools.keys()].sort());
   assert.equal(manifest.tool_count,server.tools.size);
   assert.match(manifest.catalog_sha256,/^[0-9a-f]{64}$/);
 });
 
+test('R59 capability manifest v3 preserves v2 catalog fields and adds live bindings',async()=>{
+  const server=fakeServer();
+  registerCompactGatewayTools(server,{
+    profile:'compact',ledger:{schema:'deadbyte.capability-ledger.v1',entries:[],ledger_sha256:'a'.repeat(64)},
+    codingRuntime:null,semanticRuntime:null,machineFsRuntime:null,processRuntime:null,observationRuntime:null,machineRuntime:null,desktopRuntime:null,
+    runtimePlanes:{DEADBYTE_CODING_RUNTIME:{state:'DEGRADED',ready:false,diagnostic:{code:'INITIALIZATION_FAILED',reason:'missing root',recoverable:true}}},
+    releaseBindingProvider:async()=>({release_id:'v0.15.36-test',release_manifest_sha256:'b'.repeat(64),generation_manifest_sha256:'c'.repeat(64)}),
+    catalogProvider:()=>[...server.tools.keys()]
+  });
+  const result=await server.tools.get('capability_manifest').handler({});
+  const manifest=result.structuredContent.result;
+  assert.equal(manifest.schema,'deadbyte.capability-manifest.v3');
+  assert.equal(manifest.tool_count,server.tools.size);
+  assert.deepEqual(manifest.tool_catalog,[...server.tools.keys()].sort());
+  assert.match(manifest.snapshot_id,/^[0-9a-f]{64}$/);
+  assert.equal(manifest.state_epoch,1);
+  assert.equal(manifest.bindings.release_id,'v0.15.36-test');
+  assert.equal(manifest.planes.DEADBYTE_CODING_RUNTIME.state,'DEGRADED');
+});
+
 
 test('R40 desktop_control is stable when runtime is absent and routes typed read-only operations when present',async()=>{
   const server=fakeServer();

package/test/compact-max-catalog-r44.test.mjs

@@ -81,7 +81,7 @@ test('R44 real max-runtime compact stdio catalog is exactly 43 with verified ski
     const manifest=await client.callTool({name:'capability_manifest',arguments:{}});
     assert.equal(manifest.isError,false);
     const m=manifest.structuredContent.result;
-    assert.equal(m.schema,'deadbyte.capability-manifest.v2');
+    assert.equal(m.schema,'deadbyte.capability-manifest.v3');
     assert.equal(m.profile,'compact');
     assert.equal(m.tool_count,43);
     assert.deepEqual(m.tool_catalog,names);

package/test/compact-max-catalog-r45.test.mjs

@@ -81,7 +81,7 @@ test('R45 real max-runtime compact stdio catalog is exactly 43 with verified ski
     const manifest=await client.callTool({name:'capability_manifest',arguments:{}});
     assert.equal(manifest.isError,false);
     const m=manifest.structuredContent.result;
-    assert.equal(m.schema,'deadbyte.capability-manifest.v2');
+    assert.equal(m.schema,'deadbyte.capability-manifest.v3');
     assert.equal(m.profile,'compact');
     assert.equal(m.tool_count,43);
     assert.deepEqual(m.tool_catalog,names);

package/test/contained.test.mjs

@@ -714,7 +714,8 @@ test('MCP contained_transform schema is a compile-time operation enum with no ex
   assert.ok(containedStart >= 0 && containedEnd > containedStart);
   assert.match(contained, /z\.enum\(CONTAINED_TRANSFORM_OPERATIONS\)/);
   assert.match(contained, /inputSchema: z\.strictObject\(\{/);
-  assert.match(server, /if \(hostPolicy\)/);
+  assert.match(server, /if \(planeRegistry\.state\('host'\)\.configured\)/);
+  assert.match(server, /requirePlane\('host',hostPolicy\)/);
   for (const name of ['host_file_read', 'host_file_write', 'host_exec']) assert.match(server, new RegExp(`'${name}'`));
   assert.doesNotMatch(contained, /inputSchema: z\.object\(\{/);
   assert.doesNotMatch(contained, /executable:\s*z\.|argv:\s*z\.|environment:\s*z\.|challenge:\s*z\.|request_digest:\s*z\.|worker_id:\s*z\./);

package/test/controller-policy-preflight-r59.test.mjs

@@ -0,0 +1,39 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const controllerPath=new URL('../controller/deadbyte-controller.ps1',import.meta.url);
+function quote(value){return `'${String(value).replaceAll("'","''")}'`;}
+function functionBlock(source,name,nextName){
+  const start=source.indexOf(`function ${name}`),end=source.indexOf(`function ${nextName}`,start+1);
+  assert.ok(start>=0&&end>start,`missing ${name}`);
+  return source.slice(start,end);
+}
+
+test('R59 controller refuses to arm process or coding policy with a missing root',async()=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r59-controller-preflight-'));
+  try{
+    const runtime=path.join(root,'runtime');
+    const missing=path.join(root,'missing');
+    const coding=path.join(root,'coding.json'),processPolicy=path.join(root,'process.json');
+    await writeFile(coding,JSON.stringify({schema:'deadbyte.coding-policy.v1',enabled:true,
+      lease_file:path.join(runtime,'coding-grant.json'),roots:{project:{path:missing}}}));
+    await writeFile(processPolicy,JSON.stringify({schema:'deadbyte.process-policy.v1',enabled:true,
+      grant_file:path.join(runtime,'process-grant.json'),roots:{project:{path:missing}},profiles:{node:{}}}));
+    const source=await readFile(controllerPath,'utf8');
+    const blocks=[functionBlock(source,'Assert-PolicyRootsAvailable','Get-HostPolicyMetadata'),
+      functionBlock(source,'Get-ProcessPolicyMetadata','Get-ProcessGrantStatus'),
+      functionBlock(source,'Get-CodingPolicyMetadata','Get-CodingLeaseStatus')].join('\n');
+    const script=`$ErrorActionPreference='Stop';$RuntimeDir=${quote(runtime)};function Fail([string]$m){throw $m};function Get-ExecutableHash($p){return '${'a'.repeat(64)}'};${blocks};`+
+      `$errors=@();foreach($case in @(@{kind='process';cfg=@{ProcessPolicyFile=${quote(processPolicy)}}},@{kind='coding';cfg=@{CodingPolicyFile=${quote(coding)}}})){try{if($case.kind -eq 'process'){Get-ProcessPolicyMetadata $case.cfg|Out-Null}else{Get-CodingPolicyMetadata $case.cfg|Out-Null};throw 'unexpected pass'}catch{$errors+=$_.Exception.Message}};$errors|ConvertTo-Json -Compress`;
+    const result=spawnSync('powershell',['-NoLogo','-NoProfile','-NonInteractive','-Command',script],{encoding:'utf8'});
+    assert.equal(result.status,0,result.stderr);
+    const errors=JSON.parse(result.stdout.trim());
+    assert.equal(errors.length,2);
+    assert.match(errors[0],/process policy root 'project' missing/);
+    assert.match(errors[1],/coding policy root 'project' missing/);
+  }finally{await rm(root,{recursive:true,force:true});}
+});