deadbyte-mcp 0.15.34 → 0.15.36

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

@@ -8,6 +8,10 @@ import { windowsPowerShellEnvironment } from './runtime-update.mjs';
 import { resolveStateRoot } from './state-root.mjs';
 
 const CLEANUP=['disarmautonomous','disarmcoding','disarmprocess','disarmdesktop','disarmhost','park'];
+// 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;
+process.once('disconnect',()=>{ownerDisconnected=true;});
 
 function parseArgs(argv){
   const out={};
@@ -51,7 +55,10 @@ async function main(){
   const root=resolveStateRoot(args['state-root']);
   const ownerPid=Number(args['owner-pid']);
   const nonce=String(args['session-nonce']||'');
+  const ipcOwner=args['owner-channel']==='ipc';
+  if(ipcOwner&&typeof process.send!=='function')throw new Error('guardian owner IPC channel missing');
   if(!Number.isInteger(ownerPid)||ownerPid<1) throw new Error('guardian owner pid invalid');
+  if(ipcOwner&&process.ppid!==ownerPid)throw new Error('guardian IPC parent does not match declared owner');
   if(!/^[0-9a-f]{64}$/.test(nonce)) throw new Error('guardian session nonce invalid');
 
   const launcher=await requireRegular(path.join(root,'bin','DEADBYTE-MCP.ps1'),'stable DEADBYTE launcher');
@@ -63,7 +70,7 @@ async function main(){
   for(;;){
     const marker=await readMarker(markerPath);
     if(!marker||!markerMatches(marker,{ownerPid,nonce})) return;
-    if(pidAlive(ownerPid)){
+    if(ipcOwner?!ownerDisconnected:pidAlive(ownerPid)){
       await sleep(250);
       continue;
     }

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/runtime-update.mjs

@@ -1,7 +1,7 @@
 import { createHash, createPrivateKey, createPublicKey, randomBytes, sign as cryptoSign, verify as cryptoVerify } from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { lstat, mkdir, open, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, open, readFile, readdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -306,6 +306,69 @@ async function normalizeComponentIdentities(config){
   return next;
 }
 
+function bridgeDependencyName(relativePath,usedNames){
+  const normalized=String(relativePath).replaceAll('\\','/').replaceAll('/','_');
+  let name=normalized;
+  if(!/^[A-Za-z0-9._-]{1,32}$/.test(name)||usedNames.has(name)){
+    name=`dep-${sha256Bytes(Buffer.from(String(relativePath),'utf8')).slice(0,20)}`;
+  }
+  if(usedNames.has(name)) throw new Error(`bridge dependency name collision: ${relativePath}`);
+  usedNames.add(name);
+  return name;
+}
+function bridgeStaticRelativeImports(source,file){
+  const found=[];
+  for(const [index,line] of String(source).split(/\r?\n/).entries()){
+    if(/\bimport\s*\(\s*['"]\.\.?\//.test(line)) throw new Error(`bridge dynamic relative import is forbidden: ${file}:${index+1}`);
+    const importStart=/^\s*import\b/.test(line);
+    const exportStart=/^\s*export\b/.test(line)&&/\bfrom\b/.test(line);
+    if(!importStart&&!exportStart) continue;
+    const match=importStart
+      ? /^\s*import\s+(?:(?:[^'"]+?)\s+from\s*)?['"]([^'"]+)['"]\s*;?\s*$/.exec(line)
+      : /^\s*export\s+[^'"]*?\s+from\s*['"]([^'"]+)['"]\s*;?\s*$/.exec(line);
+    if(!match) throw new Error(`bridge import syntax unsupported for dependency binding: ${file}:${index+1}`);
+    if(match[1].startsWith('.')) found.push(match[1]);
+  }
+  return found;
+}
+async function discoverBridgeLocalDependencies(root,entryScript){
+  const absoluteRoot=path.resolve(root),realRoot=await realpath(absoluteRoot);
+  const srcRoot=path.join(absoluteRoot,'src');
+  const queue=[path.resolve(entryScript)],visited=new Set(),files=[];
+  while(queue.length){
+    const current=queue.shift();
+    const currentReal=await realpath(current);
+    const relativeReal=path.relative(realRoot,currentReal);
+    if(relativeReal.startsWith('..')||path.isAbsolute(relativeReal)) throw new Error(`bridge dependency escapes bridge root: ${current}`);
+    if(visited.has(currentReal)) continue;
+    visited.add(currentReal);
+    if(visited.size>16) throw new Error('bridge local dependency closure exceeds 16 files');
+    const stat=await lstat(current);
+    if(!stat.isFile()||stat.isSymbolicLink()) throw new Error(`bridge dependency must be a regular file: ${current}`);
+    const source=await readFile(current,'utf8');
+    const specifiers=bridgeStaticRelativeImports(source,current);
+    if(currentReal!==await realpath(entryScript)) files.push(currentReal);
+    for(const specifier of specifiers){
+      if(!specifier.startsWith('./')) throw new Error(`bridge relative import escapes bridge root: ${specifier}`);
+      if(specifier.includes('?')||specifier.includes('#')) throw new Error(`bridge relative import query/fragment unsupported: ${specifier}`);
+      const resolved=path.resolve(path.dirname(current),specifier);
+      const relative=path.relative(absoluteRoot,resolved);
+      if(relative.startsWith('..')||path.isAbsolute(relative)) throw new Error(`bridge dependency escapes bridge root: ${specifier}`);
+      if(!/\.(?:mjs|js)$/i.test(resolved)) throw new Error(`bridge local dependency must be .mjs/.js: ${specifier}`);
+      queue.push(resolved);
+    }
+  }
+  const unique=[...new Set(files)].sort((a,b)=>a.localeCompare(b));
+  const usedNames=new Set();
+  const dependencies=[];
+  for(const file of unique){
+    const relative=path.relative(srcRoot,file).replaceAll('\\','/');
+    if(relative.startsWith('..')||path.isAbsolute(relative)) throw new Error(`bridge dependency must remain under src: ${file}`);
+    dependencies.push({Name:bridgeDependencyName(relative,usedNames),Path:file,Sha256:await sha256File(file)});
+  }
+  return dependencies;
+}
+
 export async function prepareBridgeSpec(config,bootstrap){
   if(!bootstrap) return structuredClone(config);
   if(typeof bootstrap.root!=='string'||!path.isAbsolute(bootstrap.root)||!HEX64.test(String(bootstrap.scriptSha256??''))) {
@@ -327,6 +390,7 @@ export async function prepareBridgeSpec(config,bootstrap){
   next.Bridge.Arguments='src\\bridge.mjs';
   next.Bridge.ScriptPath=script;
   next.Bridge.ScriptSha256=actual;
+  next.Bridge.Dependencies=await discoverBridgeLocalDependencies(root,script);
   return next;
 }
 
@@ -1334,6 +1398,23 @@ function handoffPriorPointer(body){
 function handoffNewPointer(body){
   return body.new_pointer?parseActivePointer(JSON.stringify(body.new_pointer)):null;
 }
+async function verifyCompletedUpdateReceipt(body,state,statePath,key){
+  const candidate=handoffNewPointer(body),prior=handoffPriorPointer(body);
+  if(!candidate||!samePublicPointer(candidate,statePointer(state,'new_pointer'))||!samePublicPointer(prior,statePointer(state,'prior_pointer'))) throw new Error('completed update handoff pointer binding mismatch');
+  if(state.expected_version!==candidate.version||state.expected_manifest_sha256!==candidate.manifest_sha256) throw new Error('completed update journal subject mismatch');
+  const expectedPath=path.join(path.dirname(statePath),'receipt.json');
+  if(typeof state.receipt_path!=='string'||!path.isAbsolute(state.receipt_path)||path.resolve(state.receipt_path)!==expectedPath||!HEX64.test(String(state.receipt_sha256??''))) throw new Error('completed update receipt reference invalid');
+  const info=await lstat(expectedPath);
+  if(!info.isFile()||info.isSymbolicLink()) throw new Error('completed update receipt must be a regular file');
+  const receipt=await readJson(expectedPath);
+  if(!verifySlotUpdateEnvelope(receipt,key.publicKey)||receipt.receipt_sha256!==state.receipt_sha256) throw new Error('completed update receipt signature or digest mismatch');
+  const subject=receipt.body;
+  if(subject.schema!==UPDATE_SCHEMA||subject.rollback_performed!==false||subject.update_id!==body.update_id||subject.release_version!==candidate.version||subject.candidate_manifest_sha256!==candidate.manifest_sha256||
+     !samePublicPointer(statePointer(subject,'active_pointer'),candidate)||!samePublicPointer(statePointer(subject,'prior_pointer'),prior)||
+     subject.release_slot?.release_id!==candidate.release_id||subject.release_slot?.release_root!==candidate.release_root||subject.release_slot?.manifest_sha256!==candidate.manifest_sha256||
+     subject.generation?.generation_root!==candidate.generation_root||subject.generation?.generation_manifest_sha256!==candidate.generation_manifest_sha256||subject.launcher?.sha256!==candidate.launcher_sha256) throw new Error('completed update receipt subject binding mismatch');
+  return {receipt_path:expectedPath,receipt_sha256:receipt.receipt_sha256};
+}
 async function resumeSlotUpdate({handoffPath}){
   const absoluteHandoff=path.resolve(handoffPath),probe=await readJson(absoluteHandoff);
   const stateRoot=path.resolve(String(probe?.body?.state_root??path.dirname(path.dirname(path.dirname(path.dirname(absoluteHandoff))))));
@@ -1342,8 +1423,9 @@ async function resumeSlotUpdate({handoffPath}){
   if(releaseState.schema!=='deadbyte.r27-slot-update-state.v1'||releaseState.update_id!==body.update_id) throw new Error('handoff state binding mismatch');
   let phase=String(releaseState.phase??'');
   if(phase==='completed'){
+    const verifiedReceipt=await verifyCompletedUpdateReceipt(body,releaseState,statePath,key);
     return {ok:true,resumed:false,completed:true,update_id:body.update_id,state_path:statePath,
-      receipt_path:releaseState.receipt_path??null,receipt_sha256:releaseState.receipt_sha256??null};
+      ...verifiedReceipt,historical_receipt_verified:true,current_runtime_verified:false};
   }
   if(phase.startsWith('failed')) throw new Error('slot update already failed at phase='+phase);
   const priorPointer=handoffPriorPointer(body),candidatePointer=handoffNewPointer(body);
@@ -1735,6 +1817,7 @@ export async function runSlotUpdateCli(argv=process.argv.slice(2),{stateRoot=DEF
     console.log('UPDATE_ID '+result.update_id);
     console.log('STATE_PATH '+result.state_path);
     if(result.receipt_sha256) console.log('RECEIPT_SHA256 '+result.receipt_sha256);
+    if(result.historical_receipt_verified===true) console.log('VERIFICATION_SCOPE historical-signed-receipt; current-runtime-not-observed');
     return result;
   }
   if(argv.includes('--recover-interrupted')){

package/src/version.mjs

@@ -1,4 +1,4 @@
-export const DEADBYTE_VERSION = '0.15.34';
+export const DEADBYTE_VERSION = '0.15.36';
 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});}
+});

package/test/controller-r211.test.mjs

@@ -17,5 +17,8 @@ test('R21.1 binds controller execution to CoreRoot controller directory', async
 
 test('R21.1 validates controller root before creating command runtime directories', async () => {
   const source = await readFile(controller, 'utf8');
-  assert.match(source, /function Run-Command[\s\S]*?\$cfg = Get-Config\s+Assert-ControllerRootBound \$cfg\s+Ensure-Directory \$RuntimeDir/);
+  const dispatch = source.slice(source.indexOf('function Run-CommandCore('), source.indexOf('function Run-Command(', source.indexOf('function Run-CommandCore(')));
+  assert.match(dispatch, /\$cfg = Get-Config\s+Assert-ControllerRootBound \$cfg\s+\$readOnly = \$Name -in/);
+  assert.match(dispatch, /if \(-not \$readOnly\) \{ Ensure-Directory \$RuntimeDir; Ensure-Directory \$LogDir \}/);
+  assert.ok(dispatch.indexOf('Assert-ControllerRootBound $cfg') < dispatch.indexOf('Ensure-Directory $RuntimeDir'));
 });

package/test/controller.test.mjs

@@ -12,7 +12,8 @@ test('controller derives runtime state from observed identities and readiness',
   assert.match(source, /'OFFLINE'/);
   assert.match(source, /'PARKED'/);
   assert.match(source, /'ONLINE'/);
-  assert.match(source, /'DEGRADED'/);
+  assert.match(source, /'STARTING'/);
+  assert.match(source, /'FAILED'/);
   assert.doesNotMatch(source, /state\.txt/i);
 });