deadbyte-mcp 0.15.35 → 0.15.37

package/src/mcp-server.mjs

@@ -66,6 +66,7 @@ import { capabilityProfileFromEnv, COMPACT_SURFACE_TOOL_LIMIT, R36_CAPABILITY_LE
 import { registerCompactGatewayTools } from './compact-gateway-mcp-tools.mjs';
 import { createSkillPlane } from './skill-plane-r44.mjs';
 import { registerSkillToolsR44 } from './skill-mcp-tools-r44.mjs';
+import { createRuntimePlaneRegistry, createUnavailableRuntime, RuntimePlaneUnavailableError } from './runtime-plane-registry.mjs';
 import {
   containedTransformOutputSchema,
   evidenceVerifyOutputSchema,
@@ -86,6 +87,7 @@ const verifyKeyPath = process.env.DEADBYTE_VERIFY_KEY ?? defaultPublicKeyPath();
 const auditRuntimeMode = process.env.DEADBYTE_AUDIT_RUNTIME ?? '0';
 if (!['0','1'].includes(auditRuntimeMode)) throw new Error('DEADBYTE_AUDIT_RUNTIME must be 0 or 1');
 const runtimeStateRoot = path.resolve(process.env.DEADBYTE_STATE_ROOT || path.join(os.homedir(),'.deadbyte-mcp'));
+const planeRegistry=createRuntimePlaneRegistry();
 const interruptedUpdateRecovery = await recoverInterruptedSlotUpdates({ stateRoot: runtimeStateRoot });
 if (interruptedUpdateRecovery.launched > 0) {
   console.error(`[runtime-update-recovery] launched ${interruptedUpdateRecovery.launched} detached supervisor(s)`);
@@ -103,15 +105,16 @@ if (!privilegedPolicyExplicit) {
     if (error?.code !== 'ENOENT') throw error;
   }
 }
-const hostPolicy = privilegedPolicyPath ? await loadHostPolicy(privilegedPolicyPath) : null;
+planeRegistry.define('host',{configured:Boolean(privilegedPolicyPath),required:false});
+const hostPolicy=await planeRegistry.initialize('host',async()=>loadHostPolicy(privilegedPolicyPath));
 const machineRuntimeMode = process.env.DEADBYTE_MACHINE_RUNTIME ?? '0';
 if (!['0', '1'].includes(machineRuntimeMode)) throw new Error('DEADBYTE_MACHINE_RUNTIME must be 0 or 1');
-const machineRuntime = machineRuntimeMode === '1'
-  ? await createMachineRuntime({ stateRoot: runtimeStateRoot })
-  : null;
+planeRegistry.define('machine',{configured:machineRuntimeMode==='1',required:true});
+const machineRuntime=await planeRegistry.initialize('machine',async()=>createMachineRuntime({stateRoot:runtimeStateRoot}));
 const agentRuntimeMode = process.env.DEADBYTE_AGENT_RUNTIME ?? '0';
 if (!['0', '1'].includes(agentRuntimeMode)) throw new Error('DEADBYTE_AGENT_RUNTIME must be 0 or 1');
-const agentRuntime = agentRuntimeMode === '1' ? createAgentRuntime({ signingKeyPath, verifyKeyPath }) : null;
+planeRegistry.define('agent',{configured:agentRuntimeMode==='1',required:false});
+const agentRuntime=await planeRegistry.initialize('agent',async()=>createAgentRuntime({signingKeyPath,verifyKeyPath}));
 
 const processRuntimeMode = process.env.DEADBYTE_PROCESS_RUNTIME ?? '0';
 if (!['0', '1'].includes(processRuntimeMode)) throw new Error('DEADBYTE_PROCESS_RUNTIME must be 0 or 1');
@@ -121,9 +124,14 @@ if (processRuntimeMode === '1' && !processPolicyPath) {
   try { await access(localProcessPolicyPath); processPolicyPath = localProcessPolicyPath; }
   catch (error) { if (error?.code !== 'ENOENT') throw error; }
 }
-if (processRuntimeMode === '1' && !processPolicyPath) throw new Error('DEADBYTE_PROCESS_RUNTIME=1 requires a process policy');
-const processPolicy = processRuntimeMode === '1' ? await loadProcessPolicy(processPolicyPath) : null;
-const processRuntime = processPolicy ? createProcessRuntime({ policy: processPolicy, signingKeyPath, verifyKeyPath }) : null;
+planeRegistry.define('process',{configured:processRuntimeMode==='1',required:false});
+let processPolicy=null;
+const processRuntime=await planeRegistry.initialize('process',async()=>{
+  if(!processPolicyPath) throw new Error('DEADBYTE_PROCESS_RUNTIME=1 requires a process policy');
+  processPolicy=await loadProcessPolicy(processPolicyPath);
+  return createProcessRuntime({policy:processPolicy,signingKeyPath,verifyKeyPath});
+});
+if(!processRuntime) processPolicy=null;
 
 const codingRuntimeMode = process.env.DEADBYTE_CODING_RUNTIME ?? '0';
 if (!['0', '1'].includes(codingRuntimeMode)) throw new Error('DEADBYTE_CODING_RUNTIME must be 0 or 1');
@@ -133,29 +141,32 @@ if (codingRuntimeMode === '1' && !codingPolicyPath) {
   try { await access(localCodingPolicyPath); codingPolicyPath = localCodingPolicyPath; }
   catch (error) { if (error?.code !== 'ENOENT') throw error; }
 }
-if (codingRuntimeMode === '1' && !codingPolicyPath) throw new Error('DEADBYTE_CODING_RUNTIME=1 requires a coding policy');
-const codingPolicy = codingRuntimeMode === '1' ? await loadCodingPolicy(codingPolicyPath) : null;
-const codingRuntime = codingPolicy ? createCodingRuntime({ policy: codingPolicy, signingKeyPath, verifyKeyPath }) : null;
-const codingTaskRuntime = codingRuntime ? createCodingTaskRuntime({ codingRuntime, signingKeyPath, verifyKeyPath }) : null;
+planeRegistry.define('coding',{configured:codingRuntimeMode==='1',required:false});
+let codingPolicy=null;
+const codingRuntime=await planeRegistry.initialize('coding',async()=>{
+  if(!codingPolicyPath) throw new Error('DEADBYTE_CODING_RUNTIME=1 requires a coding policy');
+  codingPolicy=await loadCodingPolicy(codingPolicyPath);
+  return createCodingRuntime({policy:codingPolicy,signingKeyPath,verifyKeyPath});
+});
+if(!codingRuntime) codingPolicy=null;
+const codingTaskRuntime=codingRuntime?createCodingTaskRuntime({codingRuntime,signingKeyPath,verifyKeyPath}):null;
 const semanticLspBinding = semanticConfigBindingFromEnv(process.env);
-const semanticLsp = codingRuntime && semanticLspBinding
-  ? await loadSemanticLspBackends({ ...semanticLspBinding, codingRuntime })
-  : { backends: [], required_ids: [] };
-let semanticRuntime = null;
+planeRegistry.define('semantic',{configured:codingRuntimeMode==='1',required:false,dependencies:['coding']});
+let semanticLsp={backends:[],required_ids:[]};
+let semanticRuntime=await planeRegistry.initialize('semantic',async()=>{
+  semanticLsp=semanticLspBinding?await loadSemanticLspBackends({...semanticLspBinding,codingRuntime}):semanticLsp;
+  return createSemanticCodeRuntime({codingRuntime,backends:semanticLsp.backends,nativeDiffRuntime:null});
+});
 const machineFsRuntimeMode = process.env.DEADBYTE_MACHINE_FS_RUNTIME ?? '0';
 if (!['0','1'].includes(machineFsRuntimeMode)) throw new Error('DEADBYTE_MACHINE_FS_RUNTIME must be 0 or 1');
-if (machineFsRuntimeMode === '1' && !codingPolicy) throw new Error('DEADBYTE_MACHINE_FS_RUNTIME=1 requires DEADBYTE_CODING_RUNTIME=1');
-const machineFsRuntime = machineFsRuntimeMode === '1'
-  ? createMachineFsRuntime({ policy: codingPolicy, signingKeyPath, verifyKeyPath })
-  : null;
+planeRegistry.define('machine_fs',{configured:machineFsRuntimeMode==='1',required:false,dependencies:['coding']});
+const machineFsRuntime=await planeRegistry.initialize('machine_fs',async()=>createMachineFsRuntime({policy:codingPolicy,signingKeyPath,verifyKeyPath}));
 const observationRuntimeMode = process.env.DEADBYTE_OBSERVATION_RUNTIME ?? '0';
 if (!['0','1'].includes(observationRuntimeMode)) throw new Error('DEADBYTE_OBSERVATION_RUNTIME must be 0 or 1');
-if (observationRuntimeMode === '1' && !machineRuntime) throw new Error('DEADBYTE_OBSERVATION_RUNTIME=1 requires DEADBYTE_MACHINE_RUNTIME=1');
-if (observationRuntimeMode === '1' && !codingPolicy) throw new Error('DEADBYTE_OBSERVATION_RUNTIME=1 requires DEADBYTE_CODING_RUNTIME=1');
-const observationRuntime = observationRuntimeMode === '1'
-  ? createObservationRuntime({ policy: codingPolicy, processRuntime, signingKeyPath, verifyKeyPath,
-      stateRoot: runtimeStateRoot })
-  : null;
+planeRegistry.define('observation',{configured:observationRuntimeMode==='1',required:false,dependencies:['machine','coding']});
+const observationRuntime=await planeRegistry.initialize('observation',async()=>createObservationRuntime({
+  policy:codingPolicy,processRuntime,signingKeyPath,verifyKeyPath,stateRoot:runtimeStateRoot
+}));
 
 const desktopRuntimeMode=process.env.DEADBYTE_DESKTOP_RUNTIME??'0';
 if(!['0','1'].includes(desktopRuntimeMode)) throw new Error('DEADBYTE_DESKTOP_RUNTIME must be 0 or 1');
@@ -165,35 +176,37 @@ if(desktopRuntimeMode==='1'&&!desktopPolicyPath){
   try{await access(localDesktopPolicyPath);desktopPolicyPath=localDesktopPolicyPath;}
   catch(error){if(error?.code!=='ENOENT')throw error;}
 }
-if(desktopRuntimeMode==='1'&&!desktopPolicyPath) throw new Error('DEADBYTE_DESKTOP_RUNTIME=1 requires a desktop policy');
-const desktopPolicy=desktopRuntimeMode==='1'?await loadDesktopPolicy(desktopPolicyPath):null;
-const desktopObserverRuntime=desktopPolicy?createDesktopObserverRuntime({
-  observerPath:desktopPolicy.observer.executable,expectedObserverSha256:desktopPolicy.observer.sha256,
-  maxFrameBytes:desktopPolicy.limits.max_frame_bytes,timeoutMs:desktopPolicy.limits.capture_timeout_ms,
-  allowInputDesktops:desktopPolicy.allowed_input_desktops
-}):null;
-const desktopInputProvider=desktopPolicy?createNativeDesktopInputProvider({
-  inputPath:desktopPolicy.input.executable,expectedInputSha256:desktopPolicy.input.sha256,
-  timeoutMs:desktopPolicy.limits.input_timeout_ms
-}):null;
-const desktopGrounderProvider=desktopPolicy?createNativeDesktopGrounder({
-  grounderPath:desktopPolicy.grounder.executable,expectedGrounderSha256:desktopPolicy.grounder.sha256,
-  timeoutMs:desktopPolicy.limits.ground_timeout_ms
-}):null;
-const desktopSigningKey=desktopPolicy?await loadPrivateSigningKey(signingKeyPath):null;
-const desktopVerifyKey=desktopPolicy?await loadPublicVerifyKey(verifyKeyPath):null;
-if(desktopPolicy&&desktopSigningKey.keyId!==desktopVerifyKey.keyId) throw new Error('Desktop signing/verify key mismatch');
-const desktopRuntime=desktopPolicy?createDesktopRuntime({
-  policy:desktopPolicy,observerRuntime:desktopObserverRuntime,inputProvider:desktopInputProvider,
-  grounderProvider:desktopGrounderProvider,
-  privateKey:desktopSigningKey.privateKey,publicKey:desktopVerifyKey.publicKey,keyId:desktopSigningKey.keyId
-}):null;
-const desktopMemoryProvider=desktopPolicy?createDesktopMemoryProvider({
-  evidenceDir:desktopPolicy.evidence_dir,
-  snapshotPath:path.join(desktopPolicy.evidence_dir,'desktop-memory.json'),
-  policySha256:desktopPolicy.policy_sha256,
-  privateKey:desktopSigningKey.privateKey,publicKey:desktopVerifyKey.publicKey,keyId:desktopSigningKey.keyId
-}):null;
+planeRegistry.define('desktop',{configured:desktopRuntimeMode==='1',required:false});
+let desktopPolicy=null;
+let desktopMemoryProvider=null;
+const desktopRuntime=await planeRegistry.initialize('desktop',async()=>{
+  if(!desktopPolicyPath) throw new Error('DEADBYTE_DESKTOP_RUNTIME=1 requires a desktop policy');
+  desktopPolicy=await loadDesktopPolicy(desktopPolicyPath);
+  const observerRuntime=createDesktopObserverRuntime({
+    observerPath:desktopPolicy.observer.executable,expectedObserverSha256:desktopPolicy.observer.sha256,
+    maxFrameBytes:desktopPolicy.limits.max_frame_bytes,timeoutMs:desktopPolicy.limits.capture_timeout_ms,
+    allowInputDesktops:desktopPolicy.allowed_input_desktops
+  });
+  const inputProvider=createNativeDesktopInputProvider({
+    inputPath:desktopPolicy.input.executable,expectedInputSha256:desktopPolicy.input.sha256,
+    timeoutMs:desktopPolicy.limits.input_timeout_ms
+  });
+  const grounderProvider=createNativeDesktopGrounder({
+    grounderPath:desktopPolicy.grounder.executable,expectedGrounderSha256:desktopPolicy.grounder.sha256,
+    timeoutMs:desktopPolicy.limits.ground_timeout_ms
+  });
+  const signingKey=await loadPrivateSigningKey(signingKeyPath);
+  const verifyKey=await loadPublicVerifyKey(verifyKeyPath);
+  if(signingKey.keyId!==verifyKey.keyId) throw new Error('Desktop signing/verify key mismatch');
+  desktopMemoryProvider=createDesktopMemoryProvider({
+    evidenceDir:desktopPolicy.evidence_dir,snapshotPath:path.join(desktopPolicy.evidence_dir,'desktop-memory.json'),
+    policySha256:desktopPolicy.policy_sha256,privateKey:signingKey.privateKey,
+    publicKey:verifyKey.publicKey,keyId:signingKey.keyId
+  });
+  return createDesktopRuntime({policy:desktopPolicy,observerRuntime,inputProvider,grounderProvider,
+    privateKey:signingKey.privateKey,publicKey:verifyKey.publicKey,keyId:signingKey.keyId});
+});
+if(!desktopRuntime){desktopPolicy=null;desktopMemoryProvider=null;}
 
 const autonomousRuntimeMode = process.env.DEADBYTE_AUTONOMOUS_RUNTIME ?? '0';
 if (!['0','1'].includes(autonomousRuntimeMode)) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME must be 0 or 1');
@@ -201,53 +214,55 @@ const autonomousSupervisorMode = process.env.DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE
 if (!['in_process','external'].includes(autonomousSupervisorMode)) {
   throw new Error('DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE must be in_process or external');
 }
-if (autonomousRuntimeMode === '1' && !codingRuntime) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME=1 requires DEADBYTE_CODING_RUNTIME=1');
 const localAutonomousPolicyPath = path.join(packageRoot,'controller','deadbyte-autonomous-policy.json');
 let autonomousPolicyPath = process.env.DEADBYTE_AUTONOMOUS_POLICY ?? '';
 if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) {
   try { await access(localAutonomousPolicyPath); autonomousPolicyPath = localAutonomousPolicyPath; }
   catch (error) { if (error?.code !== 'ENOENT') throw error; }
 }
-if (autonomousRuntimeMode === '1' && !autonomousPolicyPath) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME=1 requires an autonomous policy');
-const autonomousPolicy = autonomousRuntimeMode === '1' ? await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy) : null;
-const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath }) : null;
-semanticRuntime = codingRuntime ? createSemanticCodeRuntime({ codingRuntime, backends: semanticLsp.backends, nativeDiffRuntime }) : null;
-const autonomousMemorySigningKey=autonomousPolicy?await loadPrivateSigningKey(signingKeyPath):null;
-const autonomousMemoryVerifyKey=autonomousPolicy?await loadPublicVerifyKey(verifyKeyPath):null;
-if(autonomousPolicy&&autonomousMemorySigningKey.keyId!==autonomousMemoryVerifyKey.keyId) throw new Error('R41 memory signing/verify key mismatch');
-const memoryProvider=autonomousPolicy?createR41MemoryProvider({
-  memoryRoot:path.join(autonomousPolicy.evidence_dir,'memory-r41',packageManifestSha256),sourceReleaseManifest:packageManifestSha256,
-  journalRoot:path.join(autonomousPolicy.evidence_dir,'goals'),
-  writerVersion:DEADBYTE_VERSION,privateKey:autonomousMemorySigningKey.privateKey,
-  publicKey:autonomousMemoryVerifyKey.publicKey,keyId:autonomousMemorySigningKey.keyId,
-  byteBudget:Math.min(262144,Math.max(65536,Math.floor(autonomousPolicy.limits.max_context_bytes/2))),semantic:{enabled:false}
-}):null;
-const plannerProviderRuntime=autonomousPolicy?.planner.backend==='codex_app_server'
-  ? await createCodexAppServerR44({
-      stateDir:path.join(autonomousPolicy.evidence_dir,'provider-r44','codex-app-server'),
-      model:autonomousPolicy.planner.model,cwd:codingPolicy.roots[autonomousPolicy.planner.root_id].real_path,
-      clientVersion:DEADBYTE_VERSION,executable:autonomousPolicy.planner.executable,
-      executableSha256:autonomousPolicy.planner.executable_sha256,args:autonomousPolicy.planner.args
-    })
-  : null;
-const autonomousRuntime = autonomousPolicy ? createAutonomousRuntime({ policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,
-  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,memoryProvider,
-  plannerProviderRuntime,signingKeyPath,verifyKeyPath }) : null;
+planeRegistry.define('autonomous',{configured:autonomousRuntimeMode==='1',required:false,dependencies:['coding']});
+let autonomousPolicy=null;
+let nativeDiffRuntime=null;
+const autonomousRuntime=await planeRegistry.initialize('autonomous',async()=>{
+  if(!autonomousPolicyPath) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME=1 requires an autonomous policy');
+  autonomousPolicy=await loadAutonomousPolicy(autonomousPolicyPath,codingPolicy);
+  nativeDiffRuntime=createNativeDiffRuntime({policy:autonomousPolicy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath});
+  semanticRuntime=createSemanticCodeRuntime({codingRuntime,backends:semanticLsp.backends,nativeDiffRuntime});
+  const memorySigningKey=await loadPrivateSigningKey(signingKeyPath);
+  const memoryVerifyKey=await loadPublicVerifyKey(verifyKeyPath);
+  if(memorySigningKey.keyId!==memoryVerifyKey.keyId) throw new Error('R41 memory signing/verify key mismatch');
+  const memoryProvider=createR41MemoryProvider({
+    memoryRoot:path.join(autonomousPolicy.evidence_dir,'memory-r41',packageManifestSha256),sourceReleaseManifest:packageManifestSha256,
+    journalRoot:path.join(autonomousPolicy.evidence_dir,'goals'),writerVersion:DEADBYTE_VERSION,
+    privateKey:memorySigningKey.privateKey,publicKey:memoryVerifyKey.publicKey,keyId:memorySigningKey.keyId,
+    byteBudget:Math.min(262144,Math.max(65536,Math.floor(autonomousPolicy.limits.max_context_bytes/2))),semantic:{enabled:false}
+  });
+  const plannerProviderRuntime=autonomousPolicy.planner.backend==='codex_app_server'
+    ? await createCodexAppServerR44({stateDir:path.join(autonomousPolicy.evidence_dir,'provider-r44','codex-app-server'),
+        model:autonomousPolicy.planner.model,cwd:codingPolicy.roots[autonomousPolicy.planner.root_id].real_path,
+        clientVersion:DEADBYTE_VERSION,executable:autonomousPolicy.planner.executable,
+        executableSha256:autonomousPolicy.planner.executable_sha256,args:autonomousPolicy.planner.args})
+    : null;
+  return createAutonomousRuntime({policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,machineFsRuntime,
+    observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,memoryProvider,
+    plannerProviderRuntime,signingKeyPath,verifyKeyPath});
+});
+if(!autonomousRuntime){autonomousPolicy=null;nativeDiffRuntime=null;}
 const autonomousSupervisor = autonomousRuntime && ['openai_compatible','openai_responses','codex_app_server'].includes(autonomousPolicy.planner.backend) &&
   autonomousSupervisorMode === 'in_process'
   ? startAutonomousSupervisor({ runtime: autonomousRuntime, policy: autonomousPolicy })
   : null;
 void autonomousSupervisor;
-if (auditRuntimeMode === '1' && !machineRuntime) throw new Error('DEADBYTE_AUDIT_RUNTIME=1 requires DEADBYTE_MACHINE_RUNTIME=1');
-const auditContextProvider = auditRuntimeMode === '1' ? createAuditContextProvider({
-  stateRoot:runtimeStateRoot,packageRoot,machineRuntime,processPolicy,codingRuntime,autonomousRuntime,hostPolicy
-}) : null;
-const toolAudit = auditRuntimeMode === '1' ? await createToolAudit({
-  stateRoot:runtimeStateRoot,signingKeyPath,contextProvider:auditContextProvider
-}) : null;
+planeRegistry.define('audit',{configured:auditRuntimeMode==='1',required:false,dependencies:['machine']});
+const toolAudit=await planeRegistry.initialize('audit',async()=>{
+  const contextProvider=createAuditContextProvider({stateRoot:runtimeStateRoot,packageRoot,machineRuntime,
+    processPolicy,codingRuntime,autonomousRuntime,hostPolicy});
+  return createToolAudit({stateRoot:runtimeStateRoot,signingKeyPath,contextProvider});
+});
 const skillRoot=path.join(runtimeStateRoot,'skills');
 await mkdir(skillRoot,{recursive:true});
-const skillRuntime=await createSkillPlane({root:skillRoot,verifyKeyPath});
+planeRegistry.define('skill',{configured:true,required:false});
+const skillRuntime=await planeRegistry.initialize('skill',async()=>createSkillPlane({root:skillRoot,verifyKeyPath}));
 const commanderExtendedRuntime=createCommanderExtendedRuntime({stateRoot:runtimeStateRoot});
 const commanderExternalProcessRuntime=observationRuntime?createCommanderExternalProcessRuntime({
   observationRuntime,hostPolicy,hostExecInlineFn:hostExecInline
@@ -259,6 +274,48 @@ const remoteCapabilities=new Set(String(process.env.DEADBYTE_REMOTE_CAPABILITIES
 const remoteRelay=remoteRelayEndpoint?await createCommanderRemoteRelayR47({endpoint:remoteRelayEndpoint}):null;
 const remoteDevicePlane=remoteRelay?await createRemoteDevicePlaneR44({stateDir:path.join(runtimeStateRoot,'remote-device-r44'),relay:remoteRelay,authorizeCapability:async capability=>remoteCapabilities.has(capability)}):null;
 
+function runtimeForRegistration(plane,runtime){
+  const state=planeRegistry.state(plane);
+  return runtime??(state.configured?createUnavailableRuntime(plane,state.diagnostic??{}):null);
+}
+function requirePlane(plane,runtime){
+  if(runtime) return runtime;
+  const state=planeRegistry.state(plane);
+  throw new RuntimePlaneUnavailableError(plane,state.diagnostic??{});
+}
+function capabilityPlaneSnapshot(){
+  const planes=planeRegistry.snapshot().planes;
+  return {
+    DEADBYTE_MACHINE_RUNTIME:planes.machine,
+    DEADBYTE_PROCESS_RUNTIME:planes.process,
+    DEADBYTE_CODING_RUNTIME:planes.coding,
+    DEADBYTE_MACHINE_FS_RUNTIME:planes.machine_fs,
+    DEADBYTE_OBSERVATION_RUNTIME:planes.observation,
+    DEADBYTE_DESKTOP_RUNTIME:planes.desktop,
+    DEADBYTE_AUTONOMOUS_RUNTIME:planes.autonomous,
+    DEADBYTE_PRIVILEGED_POLICY:planes.host
+  };
+}
+async function currentReleaseBindings(){
+  if(machineRuntime){
+    try{return await machineRuntime.status();}catch{}
+  }
+  return {release_id:`package-${packageManifestSha256.slice(0,16)}`,
+    release_manifest_sha256:packageManifestSha256,generation_manifest_sha256:null};
+}
+const registeredMachineRuntime=runtimeForRegistration('machine',machineRuntime);
+const registeredAgentRuntime=runtimeForRegistration('agent',agentRuntime);
+const registeredProcessRuntime=runtimeForRegistration('process',processRuntime);
+const registeredCodingRuntime=runtimeForRegistration('coding',codingRuntime);
+const registeredCodingTaskRuntime=codingTaskRuntime??(planeRegistry.state('coding').configured?createUnavailableRuntime('coding',planeRegistry.state('coding').diagnostic??{}):null);
+const registeredSemanticRuntime=runtimeForRegistration('semantic',semanticRuntime);
+const registeredMachineFsRuntime=runtimeForRegistration('machine_fs',machineFsRuntime);
+const registeredObservationRuntime=runtimeForRegistration('observation',observationRuntime);
+const registeredDesktopRuntime=runtimeForRegistration('desktop',desktopRuntime);
+const registeredAutonomousRuntime=runtimeForRegistration('autonomous',autonomousRuntime);
+const registeredNativeDiffRuntime=nativeDiffRuntime??(planeRegistry.state('autonomous').configured?createUnavailableRuntime('autonomous',planeRegistry.state('autonomous').diagnostic??{}):null);
+const registeredSkillRuntime=runtimeForRegistration('skill',skillRuntime);
+
 installStdioConsoleGuard();
 if (process.env.DEADBYTE_STDIO_CONSOLE_GUARD_PROBE === '1') console.log('DEADBYTE_STDIO_CONSOLE_GUARD_PROBE');
 
@@ -437,54 +494,58 @@ serveStdio(() => {
     }
   );
 
-  if (machineRuntime) {
+  if (registeredMachineRuntime) {
     registerMachineTools(toolServer, {
-      runtime: machineRuntime,
+      runtime: registeredMachineRuntime,
       assertRevokeAuthority: async () => {
         if (!hostPolicy) throw new Error('privileged host plane is not configured');
-        await assertHostArmed(hostPolicy);
+        await assertHostArmed(requirePlane('host',hostPolicy));
       }
     });
   }
 
-  if (agentRuntime && surfaceProfile === 'full') {
-    registerAgentTools(toolServer, { runtime: agentRuntime, workspacePathFromId });
+  if (registeredAgentRuntime && surfaceProfile === 'full') {
+    registerAgentTools(toolServer, { runtime: registeredAgentRuntime, workspacePathFromId });
   }
 
-  if (processRuntime && surfaceProfile === 'full') {
-    registerProcessTools(toolServer, { runtime: processRuntime });
+  if (registeredProcessRuntime && surfaceProfile === 'full') {
+    registerProcessTools(toolServer, { runtime: registeredProcessRuntime });
   }
 
-  if (codingRuntime && codingTaskRuntime && semanticRuntime) {
+  if (registeredCodingRuntime && registeredCodingTaskRuntime && registeredSemanticRuntime) {
     const codingServer=surfaceProfile==='full'?toolServer:filteredToolServer(toolServer,COMPACT_CODING_DIRECT_TOOLS);
-    registerCodingTools(codingServer, { codingRuntime, taskRuntime: codingTaskRuntime, semanticRuntime });
+    registerCodingTools(codingServer, { codingRuntime:registeredCodingRuntime, taskRuntime:registeredCodingTaskRuntime, semanticRuntime:registeredSemanticRuntime });
   }
 
-  if (machineFsRuntime && surfaceProfile === 'full') {
-    registerMachineFsTools(toolServer, { runtime: machineFsRuntime });
+  if (registeredMachineFsRuntime && surfaceProfile === 'full') {
+    registerMachineFsTools(toolServer, { runtime: registeredMachineFsRuntime });
   }
 
-  if (observationRuntime && surfaceProfile === 'full') {
-    registerObservationTools(toolServer, { runtime: observationRuntime });
+  if (registeredObservationRuntime && surfaceProfile === 'full') {
+    registerObservationTools(toolServer, { runtime: registeredObservationRuntime });
   }
 
-  if (desktopRuntime && surfaceProfile === 'full') {
-    registerDesktopTools(toolServer,{runtime:desktopRuntime});
+  if (registeredDesktopRuntime && surfaceProfile === 'full') {
+    registerDesktopTools(toolServer,{runtime:registeredDesktopRuntime});
   }
 
-  if (autonomousRuntime && nativeDiffRuntime) {
-    registerAutonomousTools(toolServer, { autonomousRuntime, nativeDiffRuntime });
+  if (registeredAutonomousRuntime && registeredNativeDiffRuntime) {
+    registerAutonomousTools(toolServer, { autonomousRuntime:registeredAutonomousRuntime, nativeDiffRuntime:registeredNativeDiffRuntime });
   }
 
-  registerSkillToolsR44(toolServer,{runtime:skillRuntime});
+  registerSkillToolsR44(toolServer,{runtime:registeredSkillRuntime});
 
   registerCompactGatewayTools(toolServer,{
-    profile:surfaceProfile,ledger:R36_CAPABILITY_LEDGER,codingRuntime,semanticRuntime,machineFsRuntime,
-    processRuntime,observationRuntime,machineRuntime,desktopRuntime,skillRuntime,autonomousRuntime,hostPolicy,
-    catalogProvider:()=>[...registeredToolNames]
+    profile:surfaceProfile,ledger:R36_CAPABILITY_LEDGER,codingRuntime:registeredCodingRuntime,
+    semanticRuntime:registeredSemanticRuntime,machineFsRuntime:registeredMachineFsRuntime,
+    processRuntime:registeredProcessRuntime,observationRuntime:registeredObservationRuntime,
+    machineRuntime:registeredMachineRuntime,desktopRuntime:registeredDesktopRuntime,
+    skillRuntime:registeredSkillRuntime,autonomousRuntime:registeredAutonomousRuntime,hostPolicy,
+    catalogProvider:()=>[...registeredToolNames],runtimePlanes:capabilityPlaneSnapshot,
+    releaseBindingProvider:currentReleaseBindings
   });
 
-  if (hostPolicy) {
+  if (planeRegistry.state('host').configured) {
     toolServer.registerTool(
       'host_file_read',
       {
@@ -498,7 +559,7 @@ serveStdio(() => {
       },
       async ({ root_id, path: relativePath, encoding }) => {
         try {
-          const result = await hostFileRead(hostPolicy, { rootId: root_id, relativePath, encoding });
+          const result = await hostFileRead(requirePlane('host',hostPolicy), { rootId: root_id, relativePath, encoding });
           return textResult(hostFileReadOutputSchema, { status: 'ok', root_id, path: relativePath, ...result });
         } catch (error) {
           return textResult(hostFileReadOutputSchema, { status: 'denied', error: String(error) }, true);
@@ -521,7 +582,7 @@ serveStdio(() => {
       },
       async ({ root_id, path: relativePath, content, encoding, expected_sha256 }) => {
         try {
-          const result = await hostFileWrite(hostPolicy, {
+          const result = await hostFileWrite(requirePlane('host',hostPolicy), {
             rootId: root_id,
             relativePath,
             content,
@@ -585,7 +646,7 @@ serveStdio(() => {
         try {
           let result;
           if (args.mode === 'inline') {
-            result = await hostExecInline(hostPolicy, {
+            result = await hostExecInline(requirePlane('host',hostPolicy), {
               commandId: args.command_id,
               rootId: args.root_id,
               command: args.command,
@@ -593,7 +654,7 @@ serveStdio(() => {
               timeoutMs: args.timeout_ms
             });
           } else if (args.mode === 'native') {
-            result = await hostExecNative(hostPolicy, {
+            result = await hostExecNative(requirePlane('host',hostPolicy), {
               rootId: args.root_id,
               executable: args.executable,
               executableSha256: args.executable_sha256,
@@ -602,7 +663,7 @@ serveStdio(() => {
               timeoutMs: args.timeout_ms
             });
           } else {
-            result = await hostExec(hostPolicy, {
+            result = await hostExec(requirePlane('host',hostPolicy), {
               commandId: args.command_id,
               rootId: args.root_id,
               scriptPath: args.script_path,
@@ -622,8 +683,8 @@ serveStdio(() => {
   }
 
   if (surfaceProfile === 'full') {
-    registerCommanderCoreBridge(toolServer,{machineFsRuntime,processRuntime,searchRuntime:codingRuntime?.search??null,extendedRuntime:commanderExtendedRuntime,externalProcessRuntime:commanderExternalProcessRuntime,includeMarkdownEditor:true});
-    registerCommanderExtendedBridge(toolServer,{extendedRuntime:commanderExtendedRuntime,observability:commanderObservability,skillPlane:skillRuntime});
+    registerCommanderCoreBridge(toolServer,{machineFsRuntime:registeredMachineFsRuntime,processRuntime:registeredProcessRuntime,searchRuntime:registeredCodingRuntime?.search??null,extendedRuntime:commanderExtendedRuntime,externalProcessRuntime:commanderExternalProcessRuntime,includeMarkdownEditor:true});
+    registerCommanderExtendedBridge(toolServer,{extendedRuntime:commanderExtendedRuntime,observability:commanderObservability,skillPlane:registeredSkillRuntime});
     registerCommanderRemoteBridge(toolServer,{remoteDevicePlane});
     registerCommanderHiddenUiDispatch(server);
     registerCommanderUiResources(server);

package/src/r40-compact-disarmed-probe.mjs

@@ -41,7 +41,7 @@ export async function probeR40CompactDisarmed(endpointText){
     for(const name of R40_COMPACT_GATEWAYS)if(!names.includes(name))throw new Error('R40 compact gateway missing '+name);
     for(const tool of listed.tools)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'||manifest.tool_count!==names.length||
+    if(!['deadbyte.capability-manifest.v2','deadbyte.capability-manifest.v3'].includes(manifest.schema)||manifest.profile!=='compact'||manifest.tool_count!==names.length||
        JSON.stringify(manifest.tool_catalog)!==JSON.stringify(names))throw new Error('R40 compact manifest malformed');
     const required=manifest.capabilities.filter(x=>x?.production===true&&x?.host_only!==true);
     for(const item of required)if(typeof item.compact_tool!=='string'||!names.includes(item.compact_tool))throw new Error('compact route missing '+String(item.id));

package/src/r44-compact-disarmed-probe.mjs

@@ -41,7 +41,7 @@ export async function probeR44CompactDisarmed(endpointText){
     for(const name of R44_COMPACT_GATEWAYS)if(!names.includes(name))throw new Error('R44 compact gateway missing '+name);
     for(const tool of listed.tools)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'||manifest.tool_count!==names.length||
+    if(!['deadbyte.capability-manifest.v2','deadbyte.capability-manifest.v3'].includes(manifest.schema)||manifest.profile!=='compact'||manifest.tool_count!==names.length||
        JSON.stringify(manifest.tool_catalog)!==JSON.stringify(names))throw new Error('R44 compact manifest malformed');
     const required=manifest.capabilities.filter(x=>x?.production===true&&x?.host_only!==true);
     for(const item of required)if(typeof item.compact_tool!=='string'||!names.includes(item.compact_tool))throw new Error('compact route missing '+String(item.id));

package/src/r45-compact-disarmed-probe.mjs

@@ -41,7 +41,7 @@ export async function probeR45CompactDisarmed(endpointText){
     for(const name of R45_COMPACT_GATEWAYS)if(!names.includes(name))throw new Error('R45 compact gateway missing '+name);
     for(const tool of listed.tools)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'||manifest.tool_count!==names.length||
+    if(!['deadbyte.capability-manifest.v2','deadbyte.capability-manifest.v3'].includes(manifest.schema)||manifest.profile!=='compact'||manifest.tool_count!==names.length||
        JSON.stringify(manifest.tool_catalog)!==JSON.stringify(names))throw new Error('R45 compact manifest malformed');
     const required=manifest.capabilities.filter(x=>x?.production===true&&x?.host_only!==true);
     for(const item of required)if(typeof item.compact_tool!=='string'||!names.includes(item.compact_tool))throw new Error('compact route missing '+String(item.id));

package/src/remote-authority.mjs

@@ -0,0 +1,56 @@
+import path from 'node:path';
+
+export const AUTHORITY_PLANES=Object.freeze(['process','coding','autonomous','desktop','host']);
+
+export function authorityVector(mode='default'){
+  if(!['default','desktop','host','full'].includes(mode)) throw new Error('remote authority mode invalid');
+  return Object.freeze({
+    process:true,coding:true,autonomous:true,
+    desktop:mode==='desktop'||mode==='full',
+    host:mode==='host'||mode==='full'
+  });
+}
+
+export function parseAuthorityObservation(raw){
+  let value;
+  try{value=typeof raw==='string'?JSON.parse(raw.replace(/^\uFEFF/,'')):raw;}
+  catch{throw new Error('controller observation JSON invalid');}
+  if(value?.schema!=='deadbyte.controller-observation.v1'||!value.authority||typeof value.authority!=='object'||Array.isArray(value.authority))
+    throw new Error('controller observation schema invalid');
+  const authority={};
+  for(const plane of AUTHORITY_PLANES){
+    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)});
+  }
+  return Object.freeze({...value,authority:Object.freeze(authority)});
+}
+
+export function assertAuthorityVector(snapshot,expected){
+  for(const plane of AUTHORITY_PLANES){
+    const entry=snapshot?.authority?.[plane];
+    if(!entry||typeof expected?.[plane]!=='boolean') throw new Error(`authority ${plane} observation or expectation invalid`);
+    if(entry.armed!==expected[plane]) throw new Error(`${plane} authority expected ${expected[plane]?'ARMED':'DISARMED'}; observed ${entry.armed?'ARMED':'DISARMED'} (${entry.reason})`);
+    if(expected[plane]&&!entry.configured) throw new Error(`${plane} authority unconfigured`);
+  }
+  return snapshot;
+}
+
+export function authorityBanner(snapshot){
+  return AUTHORITY_PLANES.map(plane=>`${plane} ${snapshot.authority[plane].armed?'ARMED':'DISARMED'}`).join(' | ');
+}
+
+export function assertRuntimeReadyObservation(snapshot,{coreRoot=null}={}){
+  if(snapshot?.state!=='ONLINE') throw new Error(`runtime state not ONLINE: ${String(snapshot?.state)}`);
+  for(const name of ['bridge','core','cloud']){
+    if(snapshot[name]?.alive!==true||snapshot[name]?.reason!=='verified') throw new Error(`${name} runtime identity unverified`);
+  }
+  if(snapshot.local_ready!==true) throw new Error('local MCP readiness unverified');
+  if(snapshot.supervisor?.running!==true) throw new Error('autonomous supervisor not running');
+  if(coreRoot!==null){
+    if(typeof snapshot.core_root!=='string'||path.win32.resolve(snapshot.core_root).toLowerCase()!==path.win32.resolve(coreRoot).toLowerCase())
+      throw new Error('core root does not match active release');
+  }
+  return snapshot;
+}

package/src/remote-enforcement-probe-r60.mjs

@@ -0,0 +1,17 @@
+import { authorityVector } from './remote-authority.mjs';
+
+export async function probeRemoteEnforcement({client,mode='default'}={}){
+  if(!client||typeof client.callTool!=='function')throw new Error('remote enforcement client invalid');
+  const expected=mode==='revoked'?{desktop:false,host:false}:authorityVector(mode);
+  const desktop=await client.callTool({name:'desktop_control',arguments:{op:'status'}});
+  const desktopValue=desktop?.structuredContent;
+  const desktopArmed=desktop?.isError===false&&desktopValue?.status==='ok'&&desktopValue?.result?.armed===true;
+  const desktopUnavailable=desktop?.isError===true&&desktopValue?.status==='unavailable';
+  if(expected.desktop?!desktopArmed:desktopArmed||(!desktopUnavailable&&desktopValue?.result?.armed!==false))
+    throw new Error('Desktop enforcement does not match requested authority');
+  const host=await client.callTool({name:'host_file_read',arguments:{root_id:'core',path:'package.json',encoding:'utf8'}});
+  const hostArmed=host?.isError===false&&host?.structuredContent?.status==='ok'&&/^[0-9a-f]{64}$/.test(String(host.structuredContent.sha256??''));
+  const hostDenied=host?.isError===true&&host?.structuredContent?.status==='denied';
+  if(expected.host?!hostArmed:!hostDenied) throw new Error('Host enforcement does not match requested authority');
+  return Object.freeze({desktop_armed:desktopArmed,host_armed:hostArmed});
+}

package/src/remote-live-log.mjs

@@ -319,19 +319,21 @@ export function createLiveTimelineWriter({stream=process.stdout,displayMode='uni
   return Object.freeze({write,flush,pending(){return active?{...active}:null;}});
 }
 
-export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false,slowCallMs=1000}={}){
+export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,foldHeartbeats=false,heartbeatBurstLimit=10,heartbeatWindowMs=3000,displayMode='unicode',rootPaths={},trace=false,slowCallMs=1000}={}){
   if(typeof clock!=='function') throw new Error('live timeline clock must be a function');
   if(!REMOTE_DISPLAY_MODES.includes(displayMode)) throw new Error('remote display mode invalid');
   if(!Number.isInteger(heartbeatBurstLimit)||heartbeatBurstLimit<2||heartbeatBurstLimit>100) throw new Error('heartbeatBurstLimit invalid');
   if(!Number.isInteger(heartbeatWindowMs)||heartbeatWindowMs<250||heartbeatWindowMs>60000) throw new Error('heartbeatWindowMs invalid');
   if(!rootPaths||typeof rootPaths!=='object'||Array.isArray(rootPaths)) throw new Error('live timeline rootPaths invalid');
   if(typeof trace!=='boolean') throw new Error('live timeline trace invalid');
+  if(typeof foldHeartbeats!=='boolean') throw new Error('live timeline foldHeartbeats invalid');
   if(!Number.isInteger(slowCallMs)||slowCallMs<100||slowCallMs>600000) throw new Error('live timeline slowCallMs invalid');
   const pending=new Map();
   const completed=new Set();
   const toolCounts=new Map();
   const durationSamples=[];
   let resultCount=0,okCount=0,errorCount=0,unknownCount=0,mutationCount=0,totalDurationMs=0,slowest=null,burst=null,foldedHeartbeatLines=0,peakInFlight=0;
+  let lastCapability=null,suppressedCapability=0,suppressedCapabilityReported=false;
 
   function eventPrefix(event,sequence,{displayTool=null,icon=null}={}){
     const seq=Number.isSafeInteger(sequence)&&sequence>0?'#'+sequence+'  ':'';
@@ -419,7 +421,18 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
       addStats(event,span);
       const error=event.outcome?.is_error===true;
       const nowMs=eventMs(event,clock);
-      if(HEARTBEAT_TOOLS.has(tool)&&!error){
+      if(tool==='capability_manifest'&&!error){
+        const snapshot=event.outcome?.snapshot_id,epoch=event.outcome?.state_epoch;
+        if(/^[0-9a-f]{64}$/.test(String(snapshot??''))&&Number.isInteger(epoch)&&epoch>0){
+          const identity=`${snapshot}:${epoch}`;
+          if(identity===lastCapability){suppressedCapability++;return null;}
+          lastCapability=identity;
+          const prior=flushBurst();
+          const line=resultLine(event,span,sequence)+`  snapshot=${snapshot.slice(0,8)} epoch=${epoch}`;
+          return prior?[prior,line]:line;
+        }
+      }
+      if(foldHeartbeats&&HEARTBEAT_TOOLS.has(tool)&&!error){
         const duration=Number(event.outcome?.duration_ms);
         if(burst&&burst.tool===tool&&nowMs-burst.last_ms<=heartbeatWindowMs){
           burst.count++;
@@ -449,6 +462,10 @@ export function createLiveTimelineTracker({clock=()=>Date.now(),verbose=false,he
     const lines=[];
     const folded=flushBurst();
     if(folded) lines.push(folded);
+    if(suppressedCapability>0&&!suppressedCapabilityReported){
+      lines.push(remoteDisplayText(`capability_manifest ×${suppressedCapability} unchanged suppressed`,displayMode));
+      suppressedCapabilityReported=true;
+    }
     for(const item of pending.values()) lines.push(remoteDisplayText((displayMode==='ascii'?'[WARN]':'⚠')+' ['+shortSpanId(item.request_id)+'] OUTCOME_UNKNOWN '+item.tool+' — '+suffix+'; inspect state before retry',displayMode));
     pending.clear();
     return lines;