deadbyte-mcp 0.15.34 → 0.15.36

package/src/foreground-process-identity.mjs

@@ -0,0 +1,27 @@
+import {spawnSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import path from 'node:path';
+import {windowsPowerShellEnvironment} from './runtime-update.mjs';
+
+export function validForegroundIdentity(value){
+ return value?.schema==='deadbyte.foreground-process.v1'&&Number.isSafeInteger(value.pid)&&value.pid>0&&Number.isSafeInteger(value.parent_pid)&&value.parent_pid>=0&&typeof value.creation_utc==='string'&&/^\d{4}-\d\d-\d\dT.*Z$/.test(value.creation_utc)&&Number.isFinite(Date.parse(value.creation_utc))&&typeof value.executable_path==='string'&&path.isAbsolute(value.executable_path)&&/^[0-9a-f]{64}$/.test(value.command_line_sha256??'');
+}
+export function foregroundIdentityMatches(expected,observed){
+ if(!validForegroundIdentity(expected))throw new Error('foreground ownership identity unverified');
+ if(observed===null)return false;
+ if(!validForegroundIdentity(observed))throw new Error('observed foreground identity incomplete');
+ return expected.pid===observed.pid&&expected.parent_pid===observed.parent_pid&&expected.creation_utc===observed.creation_utc&&path.resolve(expected.executable_path).toLowerCase()===path.resolve(observed.executable_path).toLowerCase()&&expected.command_line_sha256===observed.command_line_sha256;
+}
+export function queryForegroundIdentity(pid){
+ if(process.platform!=='win32'||!Number.isSafeInteger(pid)||pid<1)throw new Error('foreground identity requires a positive Windows PID');
+ const root=process.env.SystemRoot||process.env.WINDIR;if(!root)throw new Error('Windows system root missing');
+ const command=`$p=Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; if ($null -eq $p) {Write-Output 'null';exit 0}; [pscustomobject]@{pid=$p.ProcessId;parent_pid=$p.ParentProcessId;creation_utc=$p.CreationDate.ToUniversalTime().ToString('o');executable_path=$p.ExecutablePath;command_line=$p.CommandLine} | ConvertTo-Json -Compress`;
+ const result=spawnSync(path.join(root,'System32/WindowsPowerShell/v1.0/powershell.exe'),['-NoLogo','-NoProfile','-Command',command],{encoding:'utf8',windowsHide:true,env:windowsPowerShellEnvironment(process.env),timeout:15000,maxBuffer:1024*1024});
+ if(result.error||result.status!==0)throw new Error('foreground process identity query failed');
+ let raw;try{raw=JSON.parse(result.stdout);}catch{throw new Error('foreground process identity query malformed');}
+ if(raw===null)return null;
+ if(typeof raw.command_line!=='string'||!raw.command_line)throw new Error('foreground process command identity unavailable');
+ const identity={schema:'deadbyte.foreground-process.v1',pid:raw.pid,parent_pid:raw.parent_pid,creation_utc:raw.creation_utc,executable_path:raw.executable_path,command_line_sha256:createHash('sha256').update(raw.command_line).digest('hex')};
+ if(!validForegroundIdentity(identity)||identity.pid!==pid)throw new Error('foreground process identity incomplete');
+ return identity;
+}

package/src/foreground-session-lock.mjs

@@ -0,0 +1,20 @@
+import {spawn} from 'node:child_process';
+import {createHash} from 'node:crypto';
+import {fileURLToPath} from 'node:url';
+import path from 'node:path';
+import {windowsPowerShellEnvironment} from './runtime-update.mjs';
+
+export async function acquireForegroundSessionLock({root,powershell}){
+ const hash=createHash('sha256').update(path.resolve(root).toLowerCase()).digest('hex');
+ const child=spawn(powershell,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',fileURLToPath(new URL('./foreground-session-lock.ps1',import.meta.url)),'-LockName',`Local\\DEADBYTE-foreground-${hash}`],{windowsHide:true,stdio:['pipe','pipe','pipe'],env:windowsPowerShellEnvironment(process.env)});
+ let text='',errorText='';child.stderr.on('data',b=>{errorText=(errorText+b).slice(-2048);});
+ let settled=false;
+ const exited=new Promise(resolve=>{child.once('exit',(code,signal)=>resolve({code,signal}));child.once('error',error=>resolve({error}));});
+ const ready=new Promise((resolve,reject)=>{
+  const timer=setTimeout(()=>{if(!settled){settled=true;child.kill();reject(new Error('foreground session lock acquisition timed out'));}},15000);
+  child.stdout.on('data',b=>{text+=b.toString();if(!settled&&text.includes('DEADBYTE_FOREGROUND_LOCK_READY')){settled=true;clearTimeout(timer);resolve();}});
+  exited.then(result=>{if(!settled){settled=true;clearTimeout(timer);reject(new Error(result.code===73?'remote session already claimed (startup/recovery lock)':`foreground session lock failed: ${errorText||result.error?.message||result.code}`));}});
+ });
+ try{await ready;}catch(error){child.stdin.end();await exited;throw error;}
+ return {assertHeld(){if(child.exitCode!==null||child.signalCode!==null)throw new Error('foreground session lock ownership lost');},async release(){child.stdin.end();const result=await exited;if(result.code!==0)throw new Error('foreground session lock release failed');}};
+}

package/src/foreground-session-lock.ps1

@@ -0,0 +1,15 @@
+param([Parameter(Mandatory=$true)][ValidatePattern('^Local\\DEADBYTE-foreground-[0-9a-f]{64}$')][string]$LockName)
+$ErrorActionPreference='Stop'
+$mutex=New-Object System.Threading.Mutex($false,$LockName)
+$owned=$false
+try {
+    try { $owned=$mutex.WaitOne(0) } catch [System.Threading.AbandonedMutexException] { $owned=$true }
+    if(-not $owned){exit 73}
+    [Console]::Out.WriteLine('DEADBYTE_FOREGROUND_LOCK_READY')
+    [Console]::Out.Flush()
+    # Owner death closes the inherited stdin pipe. No persisted PID lockfile.
+    [void][Console]::In.ReadLine()
+} finally {
+    if($owned){$mutex.ReleaseMutex()}
+    $mutex.Dispose()
+}

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/release-generation.mjs

@@ -200,6 +200,7 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     `        WorkingDirectory = ${psQuote(bridge.WorkingDirectory)}`,
     `        ScriptPath = ${psQuote(bridge.ScriptPath)}`,
     `        ScriptSha256 = ${psQuote(bridge.ScriptSha256)}`,
+    ...renderPsDependencies(bridge.Dependencies),
     '    }','    Cloud = @{',
     `        FilePath = ${psQuote(cloud.FilePath)}`,
     `        FileSha256 = ${psQuote(cloud.FileSha256)}`,

package/src/release-slot.mjs

@@ -289,7 +289,8 @@ export function renderStableLauncherPs1(){
     '$env:DEADBYTE_STATE_ROOT = $StateRoot',
     '$env:DEADBYTE_CONTROLLER_CONFIG = $configPath',
     "$env:DEADBYTE_CONTROLLER_RUNTIME_ROOT = Join-Path $StateRoot 'runtime'",
-    "$powershell = Join-Path $PSHOME 'powershell.exe'",
+    "$powershell = Join-Path ([Environment]::GetFolderPath('Windows')) 'System32\\WindowsPowerShell\\v1.0\\powershell.exe'",
+    "if (-not (Test-Path -LiteralPath $powershell -PathType Leaf)) { Fail 'native Windows PowerShell missing' }",
     '& $powershell -NoLogo -NoProfile -ExecutionPolicy Bypass -File $controller @ControllerArgs',
     '$exitCode = (Get-Variable -Name LASTEXITCODE -ValueOnly -ErrorAction SilentlyContinue)',
     'if ($null -eq $exitCode) { $exitCode = 0 }',

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);