deadbyte-mcp 0.11.2 → 0.12.0

package/src/desktop-uia-r40.mjs

@@ -0,0 +1,123 @@
+import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export const DESKTOP_UIA_GROUND_SCHEMA='deadbyte.desktop-uia-ground.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const HWND=/^0x[0-9a-f]{1,16}$/;
+const QUERY_KINDS=new Set(['root','name_exact','name_contains','automation_id_exact','control_type']);
+const sha256Bytes=value=>createHash('sha256').update(value).digest('hex');
+
+function insist(c,m){if(!c)throw new Error(m);}
+function integer(v,label,{min=Number.MIN_SAFE_INTEGER,max=Number.MAX_SAFE_INTEGER}={}){
+  insist(Number.isSafeInteger(v)&&v>=min&&v<=max,label+' invalid');return v;
+}
+function hwnd(v){const s=String(v??'').toLowerCase();insist(HWND.test(s),'desktop UIA hwnd invalid');return s;}
+function queryInput(query){
+  insist(query&&typeof query==='object'&&!Array.isArray(query),'desktop UIA query invalid');
+  const kind=String(query.kind??'');
+  insist(QUERY_KINDS.has(kind),'desktop UIA query kind invalid');
+  const value=query.value??'';
+  insist(typeof value==='string'&&!value.includes('\0'),'desktop UIA query value invalid');
+  const bytes=Buffer.from(value,'utf8');
+  if(kind==='root') insist(bytes.length===0,'desktop UIA root query cannot carry value');
+  else insist(bytes.length>=1&&bytes.length<=512,'desktop UIA query value bytes invalid');
+  const maxResults=integer(query.max_results??8,'desktop UIA max_results',{min:1,max:16});
+  const ordinal=integer(query.ordinal??0,'desktop UIA ordinal',{min:0,max:maxResults-1});
+  const querySha256=sha256Bytes(Buffer.from(JSON.stringify({kind,value,max_results:maxResults,ordinal}),'utf8'));
+  return {kind,value,bytes,maxResults,ordinal,querySha256};
+}
+
+export function serializeDesktopUiaRequest({expectedWindow,query}={}){
+  insist(expectedWindow&&typeof expectedWindow==='object','desktop UIA expected window missing');
+  const expectedHwnd=hwnd(expectedWindow.hwnd);
+  const expectedPid=integer(expectedWindow.pid,'desktop UIA expected pid',{min:1,max:0x7fffffff});
+  const q=queryInput(query);
+  const header=Buffer.from([
+    'DEADBYTE_DESKTOP_UIA_V1',
+    'expected_hwnd='+expectedHwnd,
+    'expected_pid='+expectedPid,
+    'query_kind='+q.kind,
+    'max_results='+q.maxResults,
+    'query_bytes='+q.bytes.length,
+    ''
+  ].join('\n'),'utf8');
+  const request=Buffer.concat([header,q.bytes]);
+  insist(request.length<=8192,'desktop UIA request exceeds bound');
+  return {request,query:q};
+}
+
+export function parseDesktopUiaResponse(bytes,{expectedWindow,query,expectedBounds}={}){
+  insist(Buffer.isBuffer(bytes)&&bytes.length>=2&&bytes.length<=256*1024,'desktop UIA response invalid');
+  let raw;try{raw=JSON.parse(bytes.toString('utf8').trim());}catch{throw new Error('desktop UIA response JSON invalid');}
+  insist(raw?.schema===DESKTOP_UIA_GROUND_SCHEMA,'desktop UIA response schema mismatch');
+  const q=queryInput(query);
+  insist(String(raw.query_kind)===q.kind,'desktop UIA response query mismatch');
+  insist(hwnd(raw.foreground_hwnd)===hwnd(expectedWindow.hwnd),'desktop UIA response hwnd mismatch');
+  insist(integer(raw.foreground_pid,'desktop UIA response pid',{min:1,max:0x7fffffff})===expectedWindow.pid,'desktop UIA response pid mismatch');
+  integer(raw.visited,'desktop UIA visited',{min:0,max:2048});
+  insist(typeof raw.truncated==='boolean','desktop UIA truncated invalid');
+  insist(Array.isArray(raw.matches)&&raw.matches.length<=q.maxResults,'desktop UIA matches invalid');
+  const left=integer(expectedBounds.left,'desktop UIA bounds left',{min:-131072,max:131072});
+  const top=integer(expectedBounds.top,'desktop UIA bounds top',{min:-131072,max:131072});
+  const width=integer(expectedBounds.width,'desktop UIA bounds width',{min:1,max:131072});
+  const height=integer(expectedBounds.height,'desktop UIA bounds height',{min:1,max:131072});
+  const matches=[];
+  for(const item of raw.matches){
+    const rect={
+      left:integer(item.left,'desktop UIA rect left',{min:-131072,max:131072}),
+      top:integer(item.top,'desktop UIA rect top',{min:-131072,max:131072}),
+      width:integer(item.width,'desktop UIA rect width',{min:1,max:131072}),
+      height:integer(item.height,'desktop UIA rect height',{min:1,max:131072})
+    };
+    const inside=rect.left>=left&&rect.top>=top&&rect.left+rect.width<=left+width&&rect.top+rect.height<=top+height;
+    if(!inside) continue;
+    matches.push(Object.freeze({
+      rect:Object.freeze(rect),
+      control_type:integer(item.control_type,'desktop UIA control_type',{min:0,max:100000}),
+      enabled:item.enabled===true,offscreen:item.offscreen===true
+    }));
+  }
+  return Object.freeze({
+    status:'ok',query_sha256:q.querySha256,query_kind:q.kind,ordinal:q.ordinal,
+    visited:raw.visited,truncated:raw.truncated,matches:Object.freeze(matches),
+    provider_receipt_sha256:sha256Bytes(bytes)
+  });
+}
+
+export async function invokeNativeDesktopGrounder({grounderPath,expectedGrounderSha256,timeoutMs=5000,expectedWindow,expectedBounds,query}={}){
+  insist(typeof grounderPath==='string'&&path.isAbsolute(grounderPath),'desktop grounderPath must be absolute');
+  insist(HEX64.test(expectedGrounderSha256??''),'desktop expectedGrounderSha256 invalid');
+  integer(timeoutMs,'desktop UIA timeoutMs',{min:100,max:30000});
+  const exe=await readFile(grounderPath);
+  insist(exe.length>0&&exe.length<=4*1024*1024,'desktop UIA binary size invalid');
+  insist(sha256Bytes(exe)===expectedGrounderSha256,'desktop UIA executable hash mismatch');
+  const packed=serializeDesktopUiaRequest({expectedWindow,query});
+  return await new Promise((resolve,reject)=>{
+    const child=spawn(grounderPath,[],{shell:false,windowsHide:true,stdio:['pipe','pipe','pipe']});
+    const stdout=[];let bytes=0,stderr='',done=false,timer=null;
+    const finish=(error,value)=>{if(done)return;done=true;if(timer!==null)clearTimeout(timer);error?reject(error):resolve(value);};
+    child.stdout.on('data',chunk=>{bytes+=chunk.length;if(bytes>256*1024){try{child.kill('SIGKILL');}catch{};return finish(new Error('desktop UIA stdout exceeds bound'));}stdout.push(Buffer.from(chunk));});
+    child.stderr.on('data',chunk=>{stderr+=chunk.toString('utf8');if(Buffer.byteLength(stderr,'utf8')>64*1024){try{child.kill('SIGKILL');}catch{};finish(new Error('desktop UIA stderr exceeds bound'));}});
+    child.once('error',error=>finish(error));
+    child.once('exit',(code,signal)=>{
+      if(code!==0)return finish(new Error('desktop UIA exit='+code+' signal='+(signal??'none')+' stderr='+stderr.slice(-8192)));
+      try{finish(null,parseDesktopUiaResponse(Buffer.concat(stdout),{expectedWindow,query,expectedBounds}));}
+      catch(error){finish(error);}
+    });
+    child.stdin.on('error',error=>finish(error));
+    child.stdin.end(packed.request);
+    timer=setTimeout(()=>{try{child.kill('SIGKILL');}catch{};finish(new Error('desktop UIA timed out after '+timeoutMs+'ms'));},timeoutMs);
+  });
+}
+
+export function createNativeDesktopGrounder({grounderPath,expectedGrounderSha256,timeoutMs=5000}={}){
+  return async({frame,query}={})=>{
+    insist(frame?.active_window,'desktop UIA grounding requires foreground window');
+    return invokeNativeDesktopGrounder({
+      grounderPath,expectedGrounderSha256,timeoutMs,
+      expectedWindow:frame.active_window,expectedBounds:frame.bounds,query
+    });
+  };
+}

package/src/mcp-server.mjs

@@ -9,7 +9,7 @@ import { executeProof } from './executor.mjs';
 import { CONTAINED_TRANSFORM_OPERATIONS, executeContainedTransform } from './contained-executor.mjs';
 import { resolveExistingInside, resolveWorkspace } from './path-policy.mjs';
 import { verifyReceipt } from './verifier.mjs';
-import { defaultPrivateKeyPath, defaultPublicKeyPath } from './trust.mjs';
+import { defaultPrivateKeyPath, defaultPublicKeyPath, loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { DEADBYTE_VERSION } from './version.mjs';
 import { currentIngressAdapterMode, TUNNEL_STDIO_PROBE_COMPAT_MODE } from './ingress-mode.mjs';
 import { installTunnelStdioProbeCompat } from './tunnel-stdio-compat.mjs';
@@ -31,6 +31,13 @@ import { createMachineFsRuntime } from './machine-fs.mjs';
 import { registerMachineFsTools } from './machine-fs-mcp-tools.mjs';
 import { createObservationRuntime } from './observation-runtime.mjs';
 import { registerObservationTools } from './observation-mcp-tools.mjs';
+import { loadDesktopPolicy } from './desktop-policy-r40.mjs';
+import { createDesktopObserverRuntime } from './desktop-observer-r40.mjs';
+import { createNativeDesktopInputProvider } from './desktop-input-r40.mjs';
+import { createNativeDesktopGrounder } from './desktop-uia-r40.mjs';
+import { createDesktopRuntime } from './desktop-runtime-r40.mjs';
+import { createDesktopMemoryProvider } from './desktop-memory-r40.mjs';
+import { registerDesktopTools } from './desktop-mcp-tools-r40.mjs';
 import { loadAutonomousPolicy } from './autonomous-policy.mjs';
 import { createNativeDiffRuntime } from './native-diff.mjs';
 import { createAutonomousRuntime } from './autonomous-runtime.mjs';
@@ -125,6 +132,44 @@ const observationRuntime = observationRuntimeMode === '1'
       stateRoot: runtimeStateRoot })
   : null;
 
+const desktopRuntimeMode=process.env.DEADBYTE_DESKTOP_RUNTIME??'0';
+if(!['0','1'].includes(desktopRuntimeMode)) throw new Error('DEADBYTE_DESKTOP_RUNTIME must be 0 or 1');
+const localDesktopPolicyPath=path.join(packageRoot,'controller','deadbyte-desktop-policy.json');
+let desktopPolicyPath=process.env.DEADBYTE_DESKTOP_POLICY??'';
+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;
+
 const autonomousRuntimeMode = process.env.DEADBYTE_AUTONOMOUS_RUNTIME ?? '0';
 if (!['0','1'].includes(autonomousRuntimeMode)) throw new Error('DEADBYTE_AUTONOMOUS_RUNTIME must be 0 or 1');
 const autonomousSupervisorMode = process.env.DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE ?? 'in_process';
@@ -143,7 +188,7 @@ const autonomousPolicy = autonomousRuntimeMode === '1' ? await loadAutonomousPol
 const nativeDiffRuntime = autonomousPolicy ? createNativeDiffRuntime({ policy:autonomousPolicy,codingRuntime,machineFsRuntime,signingKeyPath,verifyKeyPath }) : null;
 semanticRuntime = codingRuntime ? createSemanticCodeRuntime({ codingRuntime, backends: semanticLsp.backends, nativeDiffRuntime }) : null;
 const autonomousRuntime = autonomousPolicy ? createAutonomousRuntime({ policy:autonomousPolicy,codingRuntime,nativeDiffRuntime,
-  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,signingKeyPath,verifyKeyPath }) : null;
+  machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,desktopRuntime,desktopMemoryProvider,signingKeyPath,verifyKeyPath }) : null;
 const autonomousSupervisor = autonomousRuntime && autonomousPolicy.planner.backend === 'openai_compatible' &&
   autonomousSupervisorMode === 'in_process'
   ? startAutonomousSupervisor({ runtime: autonomousRuntime, policy: autonomousPolicy })
@@ -185,11 +230,17 @@ function filteredToolServer(server,allowed){
 
 serveStdio(() => {
   const server = new McpServer({ name: 'deadbyte-mcp', version: DEADBYTE_VERSION });
+  const registeredToolNames=new Set();
+  const toolServer={registerTool(name,...args){
+    if(registeredToolNames.has(name)) throw new Error(`duplicate tool registration: ${name}`);
+    registeredToolNames.add(name);
+    return server.registerTool(name,...args);
+  }};
   registerOperatorSurface(server,{packageRoot,surfaceProfile,compactToolLimit:COMPACT_SURFACE_TOOL_LIMIT});
   if (toolAudit) installToolAudit(server,toolAudit);
 
   if (surfaceProfile === 'full') {
-  server.registerTool(
+  toolServer.registerTool(
     'workspace_open',
     {
       description: 'Open a named workspace below the configured DEADBYTE workspace root.',
@@ -206,7 +257,7 @@ serveStdio(() => {
     }
   );
 
-  server.registerTool(
+  toolServer.registerTool(
     'file_read',
     {
       description: 'Read one UTF-8 file inside a named workspace. Path traversal and symlink escape are denied.',
@@ -229,7 +280,7 @@ serveStdio(() => {
     }
   );
 
-  server.registerTool(
+  toolServer.registerTool(
     'proof_execute',
     {
       description: 'Run the fixed DEADBYTE V0 proof worker inside one workspace and produce an Ed25519-signed hashed receipt. This is not a general shell.',
@@ -263,7 +314,7 @@ serveStdio(() => {
     }
   );
 
-  server.registerTool(
+  toolServer.registerTool(
     'contained_transform',
     {
       description: 'Run one compile-time allowlisted ASCII transform inside the proven Windows AppContainer + atomic Job boundary. Input is copied into a private sandbox profile; the host workspace is never mounted. This is not a shell and does not accept an executable path.',
@@ -306,7 +357,7 @@ serveStdio(() => {
 
   }
 
-  server.registerTool(
+  toolServer.registerTool(
     'evidence_verify',
     {
       description: 'Independently verify Ed25519 receipt authenticity and recompute file, stream, and worker hashes.',
@@ -327,7 +378,7 @@ serveStdio(() => {
   );
 
   if (machineRuntime) {
-    registerMachineTools(server, {
+    registerMachineTools(toolServer, {
       runtime: machineRuntime,
       assertRevokeAuthority: async () => {
         if (!hostPolicy) throw new Error('privileged host plane is not configured');
@@ -337,37 +388,41 @@ serveStdio(() => {
   }
 
   if (agentRuntime && surfaceProfile === 'full') {
-    registerAgentTools(server, { runtime: agentRuntime, workspacePathFromId });
+    registerAgentTools(toolServer, { runtime: agentRuntime, workspacePathFromId });
   }
 
   if (processRuntime && surfaceProfile === 'full') {
-    registerProcessTools(server, { runtime: processRuntime });
+    registerProcessTools(toolServer, { runtime: processRuntime });
   }
 
   if (codingRuntime && codingTaskRuntime && semanticRuntime) {
-    const codingServer=surfaceProfile==='full'?server:filteredToolServer(server,COMPACT_CODING_DIRECT_TOOLS);
+    const codingServer=surfaceProfile==='full'?toolServer:filteredToolServer(toolServer,COMPACT_CODING_DIRECT_TOOLS);
     registerCodingTools(codingServer, { codingRuntime, taskRuntime: codingTaskRuntime, semanticRuntime });
   }
 
   if (machineFsRuntime && surfaceProfile === 'full') {
-    registerMachineFsTools(server, { runtime: machineFsRuntime });
+    registerMachineFsTools(toolServer, { runtime: machineFsRuntime });
   }
 
   if (observationRuntime && surfaceProfile === 'full') {
-    registerObservationTools(server, { runtime: observationRuntime });
+    registerObservationTools(toolServer, { runtime: observationRuntime });
+  }
+
+  if (desktopRuntime && surfaceProfile === 'full') {
+    registerDesktopTools(toolServer,{runtime:desktopRuntime});
   }
 
   if (autonomousRuntime && nativeDiffRuntime) {
-    registerAutonomousTools(server, { autonomousRuntime, nativeDiffRuntime });
+    registerAutonomousTools(toolServer, { autonomousRuntime, nativeDiffRuntime });
   }
 
-  registerCompactGatewayTools(server,{
+  registerCompactGatewayTools(toolServer,{
     profile:surfaceProfile,ledger:R36_CAPABILITY_LEDGER,codingRuntime,semanticRuntime,machineFsRuntime,
-    processRuntime,observationRuntime,machineRuntime
+    processRuntime,observationRuntime,machineRuntime,desktopRuntime,catalogProvider:()=>[...registeredToolNames]
   });
 
   if (hostPolicy) {
-    server.registerTool(
+    toolServer.registerTool(
       'host_file_read',
       {
         description: 'Privileged host-plane read from a locally allowlisted root. Requires a live local arm lease; path traversal and symlink escape are denied.',
@@ -388,7 +443,7 @@ serveStdio(() => {
       }
     );
 
-    server.registerTool(
+    toolServer.registerTool(
       'host_file_write',
       {
         description: 'Privileged host-plane hash-precondition file write inside a locally allowlisted root. Commit is same-directory atomic rename and post-commit SHA-256 verified. Requires a live local arm lease.',
@@ -417,7 +472,7 @@ serveStdio(() => {
       }
     );
 
-    server.registerTool(
+    toolServer.registerTool(
       'host_exec',
       {
         description: 'Privileged host-plane script execution through a locally allowlisted and SHA-256-pinned executable. No raw shell command string is accepted. Requires a live local arm lease.',

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

@@ -0,0 +1,71 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { R40_COMPACT_GATEWAYS,R40_COMPACT_TOOL_LIMIT } from './remote-mcp-r40-parity-client.mjs';
+import { loadDesktopPolicy } from './desktop-policy-r40.mjs';
+import { verifyDesktopReceiptObject } from './desktop-runtime-r40.mjs';
+import { loadPublicVerifyKey } from './trust.mjs';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const verifyKeyPath=path.join(stateRoot,'trust','ed25519-public.pem');
+function structured(result,label){
+  if(result.isError) throw new Error(label+' returned error: '+JSON.stringify(result.structuredContent??result.content));
+  if(!result.structuredContent||typeof result.structuredContent!=='object') throw new Error(label+' missing structured output');
+  return result.structuredContent;
+}
+function gateway(result,label){
+  const value=structured(result,label);
+  if(value.status!=='ok'||!value.result||typeof value.result!=='object') throw new Error(label+' gateway status='+String(value.status));
+  return value.result;
+}
+async function verifyDesktop(policy,verifyKey,id,sha,kind){
+  const receipt=JSON.parse(await readFile(path.join(policy.evidence_dir,id+'.json'),'utf8'));
+  const proof=verifyDesktopReceiptObject(receipt,{policySha256:policy.policy_sha256,publicKey:verifyKey.publicKey,keyId:verifyKey.keyId});
+  if(!proof.ok||proof.receipt_sha256!==sha||proof.kind!==kind) throw new Error('R40 desktop '+kind+' receipt verification failed');
+}
+export async function probeR40CompactDisarmed(endpointText){
+  const endpoint=new URL(endpointText);if(endpoint.protocol!=='https:')throw new Error('R40 compact disarmed probe requires HTTPS');
+  const pointer=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  const desktopPolicy=await loadDesktopPolicy(path.join(pointer.generation_root,'desktop-policy.json'));
+  const verifyKey=await loadPublicVerifyKey(verifyKeyPath);
+  const client=new Client({name:'deadbyte-r40-compact-disarmed-probe',version:'0.12.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StreamableHTTPClientTransport(endpoint);
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools(),names=listed.tools.map(t=>t.name).sort();
+    if(names.length!==R40_COMPACT_TOOL_LIMIT)throw new Error('R40 compact disarmed catalog must be exactly '+R40_COMPACT_TOOL_LIMIT+', got '+names.length);
+    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||
+       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));
+    const coding=structured(await client.callTool({name:'coding_session_status',arguments:{}}),'coding status');
+    const autonomous=structured(await client.callTool({name:'autonomous_session_status',arguments:{}}),'autonomous status');
+    const desktop=gateway(await client.callTool({name:'desktop_control',arguments:{op:'status'}}),'desktop status');
+    if(coding.armed!==false||autonomous.coding_armed!==false||autonomous.autonomous_armed!==false||desktop.armed!==false)throw new Error('R40 closure requires Coding/Autonomous/Desktop DISARMED');
+    const observed=gateway(await client.callTool({name:'desktop_control',arguments:{op:'observe',preview:false}}),'desktop observe');
+    await verifyDesktop(desktopPolicy,verifyKey,observed.receipt_id,observed.receipt_sha256,'desktop_observation');
+    const grounded=gateway(await client.callTool({name:'desktop_control',arguments:{op:'target',frame_id:observed.frame.frame_id,uia_query:{kind:'root',value:'',max_results:1,ordinal:0}}}),'desktop target');
+    await verifyDesktop(desktopPolicy,verifyKey,grounded.grounding.receipt_id,grounded.grounding.receipt_sha256,'desktop_grounding');
+    const machine=gateway(await client.callTool({name:'machine_observe',arguments:{op:'machine_status'}}),'machine status');
+    const nonce='r40-final-'+randomBytes(16).toString('hex');
+    const ping=gateway(await client.callTool({name:'machine_observe',arguments:{op:'machine_ping',nonce}}),'machine ping');
+    if(ping.nonce!==nonce||ping.release_id!==machine.release_id||ping.release_manifest_sha256!==machine.release_manifest_sha256)throw new Error('R40 machine ping binding mismatch');
+    return {status:'passed',profile:'compact',tool_count:names.length,tools:names,catalog_sha256:sha256(Buffer.from(JSON.stringify(names),'utf8')),
+      strict_output_schemas:true,ledger_sha256:manifest.ledger_sha256,capability_count:manifest.capabilities.length,
+      production_non_host_capabilities:required.length,capability_closure:true,coding_armed:false,autonomous_armed:false,desktop_armed:false,
+      desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true,
+      desktop_frame_id:observed.frame.frame_id,desktop_target_id:grounded.target.target_id,
+      release_id:machine.release_id,release_manifest_sha256:machine.release_manifest_sha256,machine_status:machine,machine_ping:ping,nonce,
+      protocol_revision:client.getNegotiatedProtocolVersion()};
+  }finally{await client.close().catch(()=>{});}
+}
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){const endpoint=process.argv[2];if(!endpoint)throw new Error('usage: node src/r40-compact-disarmed-probe.mjs https://host/mcp/path');
+probeR40CompactDisarmed(endpoint).then(v=>console.log(JSON.stringify(v,null,2))).catch(e=>{console.error(e instanceof Error?e.stack:String(e));process.exitCode=1;});}

package/src/r40-full-surface-probe.mjs

@@ -0,0 +1,34 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Client } from '@modelcontextprotocol/client';
+import { StdioClientTransport,getDefaultEnvironment } from '@modelcontextprotocol/client/stdio';
+import { fileURLToPath } from 'node:url';
+import { R40_EXPECTED_TOOLS } from './remote-mcp-r40-parity-client.mjs';
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+export async function probeR40FullSurface({packageRoot,generationRoot,stateRoot=path.join(os.homedir(),'.deadbyte-mcp')}={}){
+  const pkgRoot=packageRoot?path.resolve(packageRoot):path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+  const gen=path.resolve(generationRoot),semanticPath=path.join(gen,'semantic-lsp-config.json');
+  const semanticSha=sha256(await readFile(semanticPath));
+  const env={...getDefaultEnvironment(),DEADBYTE_STATE_ROOT:path.resolve(stateRoot),DEADBYTE_CORE_ROOT:pkgRoot,
+    DEADBYTE_WORKSPACE_ROOT:path.join(pkgRoot,'workspaces'),DEADBYTE_CAPABILITY_PROFILE:'full',DEADBYTE_AUDIT_RUNTIME:'0',
+    DEADBYTE_MACHINE_RUNTIME:'1',DEADBYTE_AGENT_RUNTIME:'1',DEADBYTE_PROCESS_RUNTIME:'1',DEADBYTE_PROCESS_POLICY:path.join(gen,'process-policy.json'),
+    DEADBYTE_CODING_RUNTIME:'1',DEADBYTE_MACHINE_FS_RUNTIME:'1',DEADBYTE_OBSERVATION_RUNTIME:'1',
+    DEADBYTE_DESKTOP_RUNTIME:'1',DEADBYTE_DESKTOP_POLICY:path.join(gen,'desktop-policy.json'),
+    DEADBYTE_CODING_POLICY:path.join(gen,'coding-policy.json'),DEADBYTE_SEMANTIC_LSP_CONFIG:semanticPath,DEADBYTE_SEMANTIC_LSP_CONFIG_SHA256:semanticSha,
+    DEADBYTE_AUTONOMOUS_RUNTIME:'1',DEADBYTE_AUTONOMOUS_POLICY:path.join(gen,'autonomous-policy.json'),
+    DEADBYTE_AUTONOMOUS_SUPERVISOR_MODE:'external',DEADBYTE_PRIVILEGED_POLICY:path.join(gen,'host-policy.json')};
+  const client=new Client({name:'deadbyte-r40-full-surface-probe',version:'0.12.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StdioClientTransport({command:process.execPath,args:[path.join(pkgRoot,'src','mcp-server.mjs')],cwd:pkgRoot,env,stderr:'pipe'});
+  try{
+    await client.connect(transport);const listed=await client.listTools(),names=listed.tools.map(t=>t.name).sort();
+    if(JSON.stringify(names)!==JSON.stringify(R40_EXPECTED_TOOLS))throw new Error('R40 full catalog mismatch count='+names.length);
+    for(const tool of listed.tools)if(tool.outputSchema?.type!=='object'||tool.outputSchema?.additionalProperties!==false||!tool.outputSchema?.properties)throw new Error('R40 full tool '+tool.name+' missing strict output schema');
+    return {status:'passed',profile:'full',tool_count:names.length,tools:names,catalog_sha256:sha256(Buffer.from(JSON.stringify(names),'utf8')),
+      strict_output_schemas:true,desktop_tools:['desktop_status','desktop_observe','desktop_target','desktop_action'],protocol_revision:client.getNegotiatedProtocolVersion()};
+  }finally{await client.close().catch(()=>{});}
+}
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){const [packageRoot,generationRoot]=process.argv.slice(2);
+if(!packageRoot||!generationRoot)throw new Error('usage: node src/r40-full-surface-probe.mjs <package-root> <generation-root>');
+probeR40FullSurface({packageRoot,generationRoot}).then(v=>console.log(JSON.stringify(v,null,2))).catch(e=>{console.error(e instanceof Error?e.stack:String(e));process.exitCode=1;});}

package/src/release-generation.mjs

@@ -118,7 +118,31 @@ async function rebindProcessPolicy(raw,{developmentRoot,stateRoot,releaseRoot}){
   return policy;
 }
 
-function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,codingPolicyPath,semanticConfigPath,semanticConfigSha256,autonomousPolicyPath,hostPolicyPath}){
+async function rebindDesktopPolicy(raw,{stateRoot,releaseRoot}){
+  if(!raw) return null;
+  const policy=clone(raw);
+  if(policy.schema!=='deadbyte.desktop-policy.v1'||policy.enabled!==true) throw new Error('desktop policy schema/enabled mismatch');
+  policy.grant_file=path.join(stateRoot,'runtime','desktop-grant.json');
+  policy.evidence_dir=path.join(stateRoot,'runtime','desktop-evidence');
+  const providers={
+    observer:'deadbyte-desktop-observer-r40.exe',
+    input:'deadbyte-desktop-input-r40.exe',
+    grounder:'deadbyte-desktop-uia-r40.exe'
+  };
+  for(const [name,file] of Object.entries(providers)){
+    const provider=policy[name];
+    if(!provider||typeof provider.sha256!=='string'||!HEX64.test(provider.sha256)) throw new Error(`desktop ${name} policy pin invalid`);
+    const providerPath=path.join(releaseRoot,'bin',file);
+    const stat=await lstat(providerPath);
+    if(!stat.isFile()||stat.isSymbolicLink()) throw new Error(`desktop ${name} helper invalid in release slot`);
+    const actual=sha256(await readFile(providerPath));
+    if(actual!==provider.sha256) throw new Error(`desktop ${name} helper SHA-256 mismatch: policy=${provider.sha256} release=${actual}`);
+    provider.executable=providerPath;
+  }
+  return policy;
+}
+
+function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,desktopPolicyPath,codingPolicyPath,semanticConfigPath,semanticConfigSha256,autonomousPolicyPath,hostPolicyPath}){
   const supervisor=currentConfig.Supervisor??{},bridge=currentConfig.Bridge??{},cloud=currentConfig.Cloud??{};
   return [
     '@{',"    Schema = 'deadbyte.controller.v1'",`    CoreRoot = ${psQuote(coreRoot)}`,
@@ -130,6 +154,8 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     `    CodingRuntimeEnabled = ${psBool(currentConfig.CodingRuntimeEnabled)}`,
     `    MachineFsRuntimeEnabled = ${psBool(currentConfig.MachineFsRuntimeEnabled)}`,
     `    ObservationRuntimeEnabled = ${psBool(currentConfig.ObservationRuntimeEnabled)}`,
+    `    DesktopRuntimeEnabled = ${psBool(currentConfig.DesktopRuntimeEnabled)}`,
+    `    DesktopPolicyFile = ${psQuote(desktopPolicyPath??'')}`,
     `    CodingPolicyFile = ${psQuote(codingPolicyPath)}`,
     `    SemanticLspConfigFile = ${psQuote(semanticConfigPath??'')}`,
     `    SemanticLspConfigSha256 = ${psQuote(semanticConfigSha256??'')}`,
@@ -172,7 +198,7 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     '}',''
   ].join('\r\n');
 }
-export async function createGenerationBundle({stateRoot,releaseRoot,developmentRoot,workspaceRoot,releaseId,currentConfig,processPolicy,codingPolicy,autonomousPolicy,hostPolicy}){
+export async function createGenerationBundle({stateRoot,releaseRoot,developmentRoot,workspaceRoot,releaseId,currentConfig,processPolicy,desktopPolicy,codingPolicy,autonomousPolicy,hostPolicy}){
   const state=path.resolve(stateRoot),release=path.resolve(releaseRoot),development=path.resolve(developmentRoot),workspace=path.resolve(workspaceRoot);
   if(typeof releaseId!=='string'||!/^[A-Za-z0-9._-]{1,96}$/.test(releaseId)) throw new Error('generation release id invalid');
   if(typeof currentConfig?.Bridge?.FileSha256!=='string'||!HEX64.test(currentConfig.Bridge.FileSha256)) throw new Error('generation Bridge FileSha256 invalid');
@@ -230,6 +256,9 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   const hostBytes=host?jsonBytes(host):null;
   const processBound=await rebindProcessPolicy(processPolicy,{developmentRoot:development,stateRoot:state,releaseRoot:release});
   const processBytes=processBound?jsonBytes(processBound):null;
+  const desktopBound=await rebindDesktopPolicy(desktopPolicy,{stateRoot:state,releaseRoot:release});
+  const desktopBytes=desktopBound?jsonBytes(desktopBound):null;
+  if(currentConfig.DesktopRuntimeEnabled===true&&!desktopBytes) throw new Error('DesktopRuntimeEnabled requires desktop policy');
   const seedBody=canonical({
     release_id:releaseId,core_root:release,development_root:development,workspace_root:workspace,
     machine_runtime_enabled:currentConfig.MachineRuntimeEnabled!==false,
@@ -238,6 +267,7 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     coding_runtime_enabled:currentConfig.CodingRuntimeEnabled===true,
     machine_fs_runtime_enabled:currentConfig.MachineFsRuntimeEnabled===true,
     observation_runtime_enabled:currentConfig.ObservationRuntimeEnabled===true,
+    desktop_runtime_enabled:currentConfig.DesktopRuntimeEnabled===true,
     autonomous_runtime_enabled:currentConfig.AutonomousRuntimeEnabled===true,
     autonomous_supervisor_enabled:currentConfig.AutonomousSupervisorEnabled===true,
     supervisor:currentConfig.AutonomousSupervisorEnabled===true?(currentConfig.Supervisor??{}):null,
@@ -247,6 +277,7 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     start_timeout_seconds:Number(currentConfig.StartTimeoutSeconds??30),probe_timeout_seconds:Number(currentConfig.ProbeTimeoutSeconds??3),
     semantic_lsp_config_sha256:semanticConfigSha256,
     process_policy_sha256:processBytes?sha256(processBytes):null,
+    desktop_policy_sha256:desktopBytes?sha256(desktopBytes):null,
     coding_policy_sha256:sha256(codingBytes),autonomous_policy_sha256:sha256(autonomousBytes),host_policy_sha256:hostBytes?sha256(hostBytes):null
   });
   const generationSeed=sha256(Buffer.from(JSON.stringify(seedBody),'utf8'));
@@ -254,6 +285,7 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   const generationsRoot=path.join(state,'generations');
   const generationRoot=path.join(generationsRoot,generationId);
   const processPath=processBytes?path.join(generationRoot,'process-policy.json'):null;
+  const desktopPath=desktopBytes?path.join(generationRoot,'desktop-policy.json'):null;
   const codingPath=path.join(generationRoot,'coding-policy.json');
   const semanticPath=semanticBytes?path.join(generationRoot,'semantic-lsp-config.json'):null;
   const autonomousPath=path.join(generationRoot,'autonomous-policy.json');
@@ -262,15 +294,16 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   const files=new Map([
     ['coding-policy.json',codingBytes],
     ['autonomous-policy.json',autonomousBytes],
-    ['controller-config.psd1',Buffer.from(renderControllerConfig({currentConfig,coreRoot:release,workspaceRoot:workspace,processPolicyPath:processPath,codingPolicyPath:codingPath,semanticConfigPath:semanticPath,semanticConfigSha256,autonomousPolicyPath:autonomousPath,hostPolicyPath:hostPath}),'utf8')]
+    ['controller-config.psd1',Buffer.from(renderControllerConfig({currentConfig,coreRoot:release,workspaceRoot:workspace,processPolicyPath:processPath,desktopPolicyPath:desktopPath,codingPolicyPath:codingPath,semanticConfigPath:semanticPath,semanticConfigSha256,autonomousPolicyPath:autonomousPath,hostPolicyPath:hostPath}),'utf8')]
   ]);
   if(semanticBytes) files.set('semantic-lsp-config.json',semanticBytes);
   if(processBytes) files.set('process-policy.json',processBytes);
+  if(desktopBytes) files.set('desktop-policy.json',desktopBytes);
   if(hostBytes) files.set('host-policy.json',hostBytes);
   const manifestBytes=generationManifest(files),manifestSha256=sha256(manifestBytes);
   if(existsSync(generationRoot)){
     const verified=await verifyGenerationBundle(generationRoot,manifestSha256);
-    return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:true,...verified};
+    return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,desktop_policy_path:desktopPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:true,...verified};
   }
   await mkdir(generationsRoot,{recursive:true});
   const staging=path.join(generationsRoot,`.staging-${generationId}-${process.pid}-${randomBytes(4).toString('hex')}`);
@@ -285,5 +318,5 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     throw error;
   }
   const verified=await verifyGenerationBundle(generationRoot,manifestSha256);
-  return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:false,...verified};
+  return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,desktop_policy_path:desktopPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:false,...verified};
 }

package/src/remote-console.mjs

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export const REMOTE_DISPLAY_MODES=Object.freeze(['unicode','ascii']);
+
+function checkedMode(mode){
+  if(!REMOTE_DISPLAY_MODES.includes(mode)) throw new Error(`remote display mode invalid: ${String(mode)}`);
+  return mode;
+}
+
+export function remoteDisplayText(value,mode='unicode'){
+  checkedMode(mode);
+  const text=String(value??'');
+  if(mode==='unicode') return text;
+  let out='';
+  for(const ch of text){
+    const cp=ch.codePointAt(0);
+    if(cp===9||cp===10||cp===13||(cp>=0x20&&cp<=0x7e)) out+=ch;
+    else out+=`\\u{${cp.toString(16).toUpperCase()}}`;
+  }
+  return out;
+}
+
+export function prepareRemoteConsole({
+  platform=process.platform,
+  isTTY=Boolean(process.stdout?.isTTY),
+  env=process.env,
+  spawnSyncFn=spawnSync
+}={}){
+  if(String(env?.DEADBYTE_REMOTE_ASCII??'')==='1') return Object.freeze({mode:'ascii',code_page:null,reason:'forced_ascii'});
+  if(platform!=='win32') return Object.freeze({mode:'unicode',code_page:null,reason:'non_windows'});
+  if(!isTTY) return Object.freeze({mode:'ascii',code_page:null,reason:'stdout_not_tty'});
+  const systemRoot=env?.SystemRoot||env?.WINDIR;
+  if(typeof systemRoot!=='string'||!systemRoot) return Object.freeze({mode:'ascii',code_page:null,reason:'system_root_missing'});
+  const chcp=path.win32.join(systemRoot,'System32','chcp.com');
+  let result;
+  try{ result=spawnSyncFn(chcp,['65001'],{stdio:'ignore',windowsHide:true,shell:false}); }
+  catch{ return Object.freeze({mode:'ascii',code_page:null,reason:'codepage_probe_threw'}); }
+  if(result?.error||result?.status!==0) return Object.freeze({mode:'ascii',code_page:null,reason:'codepage_65001_unavailable'});
+  return Object.freeze({mode:'unicode',code_page:65001,reason:'codepage_65001'});
+}