deadbyte-mcp 0.13.0 → 0.15.0

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

@@ -0,0 +1,74 @@
+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 { R44_COMPACT_GATEWAYS,R44_COMPACT_TOOL_LIMIT } from './remote-mcp-r44-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('R44 desktop '+kind+' receipt verification failed');
+}
+export async function probeR44CompactDisarmed(endpointText){
+  const endpoint=new URL(endpointText);if(endpoint.protocol!=='https:')throw new Error('R44 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-r44-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!==R44_COMPACT_TOOL_LIMIT)throw new Error('R44 compact disarmed catalog must be exactly '+R44_COMPACT_TOOL_LIMIT+', got '+names.length);
+    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||
+       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));
+    const skillCatalog=structured(await client.callTool({name:'skill_catalog',arguments:{op:'list'}}),'skill_catalog');
+    if(skillCatalog.status!=='ok'||skillCatalog.op!=='list'||!skillCatalog.result||!Array.isArray(skillCatalog.result.skills)||
+       !/^[0-9a-f]{64}$/.test(String(skillCatalog.result.registry_sha256??'')))throw new Error('R44 skill catalog verification failed');
+    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('R44 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='r44-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('R44 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,skill_catalog_verified:true,skill_count:skillCatalog.result.skills.length,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/r44-compact-disarmed-probe.mjs https://host/mcp/path');
+probeR44CompactDisarmed(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/r44-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 { R44_EXPECTED_TOOLS } from './remote-mcp-r44-parity-client.mjs';
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+export async function probeR44FullSurface({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-r44-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(R44_EXPECTED_TOOLS))throw new Error('R44 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('R44 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/r44-full-surface-probe.mjs <package-root> <generation-root>');
+probeR44FullSurface({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/remote-device-r44.mjs

@@ -0,0 +1,205 @@
+import { createHash, createPublicKey, randomBytes } from 'node:crypto';
+import { lstat, mkdir, open, readFile, realpath, rename } from 'node:fs/promises';
+import path from 'node:path';
+
+const STATE_SCHEMA='deadbyte.remote-device-state.v1';
+const CREDENTIAL_SCHEMA='deadbyte.remote-credential.v1';
+const HEX64=/^[0-9a-f]{64}$/;
+const CAP=/^[A-Za-z0-9._-]{1,128}$/;
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort((a,b)=>a.localeCompare(b,'en')).map(k=>[k,canonical(value[k])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+function insist(ok,message){if(!ok)throw new Error(message);}
+function now(){return new Date().toISOString();}
+async function atomicJson(file,value){
+  await mkdir(path.dirname(file),{recursive:true});
+  const bytes=Buffer.from(`${JSON.stringify(value,null,2)}\n`,'utf8');
+  const temp=`${file}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+  const h=await open(temp,'wx');
+  try{await h.writeFile(bytes);await h.sync();}finally{await h.close();}
+  await rename(temp,file);
+  return sha(bytes);
+}
+function validateState(value){
+  insist(value&&typeof value==='object'&&!Array.isArray(value),'remote state must be object');
+  insist(value.schema===STATE_SCHEMA,'remote state schema mismatch');
+  insist(value.devices&&typeof value.devices==='object'&&!Array.isArray(value.devices),'remote devices invalid');
+  insist(value.requests&&typeof value.requests==='object'&&!Array.isArray(value.requests),'remote requests invalid');
+  for(const [id,d] of Object.entries(value.devices)){
+    insist(HEX64.test(id)&&d.device_id===id,'remote device identity invalid');
+    insist(Number.isInteger(d.epoch)&&d.epoch>=1,'remote device epoch invalid');
+    insist(typeof d.public_key_spki_base64==='string','remote device SPKI invalid');
+    insist(typeof d.revoked==='boolean'&&typeof d.reported_online==='boolean'&&typeof d.reachable==='boolean','remote device state flags invalid');
+  }
+  for(const [id,r] of Object.entries(value.requests)){
+    insist(HEX64.test(id)&&r.request_id===id,'remote request identity invalid');
+    insist(HEX64.test(r.request_sha256??''),'remote request hash invalid');
+    insist(['accepted','executing','completed','failed'].includes(r.state),'remote request state invalid');
+  }
+  return value;
+}
+async function loadState(file){
+  try{
+    const st=await lstat(file);insist(st.isFile()&&!st.isSymbolicLink(),'remote state must be real file');
+    let parsed;try{parsed=JSON.parse(await readFile(file,'utf8'));}catch(error){throw new Error(`remote state JSON invalid: ${error.message}`);}
+    return validateState(parsed);
+  }catch(error){
+    if(error?.code!=='ENOENT')throw error;
+    return {schema:STATE_SCHEMA,devices:{},requests:{},updated_at_utc:now()};
+  }
+}
+function parseDeviceKey(spki){
+  insist(typeof spki==='string'&&spki.length>=1&&spki.length<=4096,'device SPKI invalid');
+  let der;try{der=Buffer.from(spki,'base64');}catch{throw new Error('device SPKI base64 invalid');}
+  insist(der.length>0&&der.toString('base64')===spki,'device SPKI base64 non-canonical');
+  const key=createPublicKey({key:der,format:'der',type:'spki'});
+  insist(key.asymmetricKeyType==='ed25519','remote device key must be Ed25519');
+  return {deviceId:sha(der),spki};
+}
+function publicDevice(d){
+  return {device_id:d.device_id,display_name:d.display_name,epoch:d.epoch,revoked:d.revoked,
+    reported_online:d.reported_online,reachable:d.reachable,connection_id:d.connection_id,updated_at_utc:d.updated_at_utc};
+}
+function payloadHash({deviceId,epoch,capabilityId,payload}){
+  return sha(Buffer.from(canonicalJson({device_id:deviceId,epoch,capability_id:capabilityId,payload}),'utf8'));
+}
+
+export async function createRemoteDevicePlaneR44({stateDir,relay,authorizeCapability,onCredentialSuperseded=null}={}){
+  insist(typeof stateDir==='string'&&path.isAbsolute(stateDir),'remote stateDir must be absolute');
+  insist(relay&&typeof relay.probe==='function'&&typeof relay.request==='function','remote relay contract invalid');
+  insist(typeof authorizeCapability==='function','remote capability authorizer required');
+  insist(onCredentialSuperseded===null||typeof onCredentialSuperseded==='function','remote credential supersede callback invalid');
+  await mkdir(stateDir,{recursive:true});const root=await realpath(stateDir);
+  const stateFile=path.join(root,'remote-devices.json'),credentialsDir=path.join(root,'credentials');
+  await mkdir(credentialsDir,{recursive:true});
+  let state=await loadState(stateFile);
+  let lock=Promise.resolve();
+  const withLock=fn=>{
+    const run=lock.then(fn,fn);lock=run.catch(()=>{});return run;
+  };
+  const persist=()=>{state.updated_at_utc=now();return atomicJson(stateFile,state);};
+  const getDevice=(deviceId,epoch=null)=>{
+    insist(HEX64.test(deviceId??''),'device id invalid');
+    const d=state.devices[deviceId];insist(d,'unknown remote device');
+    if(epoch!==null)insist(d.epoch===epoch,'remote device epoch mismatch');
+    insist(!d.revoked,'remote device revoked');
+    return d;
+  };
+
+  async function pair({publicKeySpkiBase64,displayName}={}){
+    const {deviceId,spki}=parseDeviceKey(publicKeySpkiBase64);
+    insist(typeof displayName==='string'&&displayName.length>=1&&displayName.length<=128,'device display name invalid');
+    return withLock(async()=>{
+      const existing=state.devices[deviceId];
+      if(existing){
+        insist(!existing.revoked,'remote device revoked');
+        insist(existing.public_key_spki_base64===spki,'remote device key drift');
+        return publicDevice(existing);
+      }
+      const d={device_id:deviceId,public_key_spki_base64:spki,display_name:displayName,epoch:1,revoked:false,
+        reported_online:false,reachable:false,connection_id:null,last_probe_nonce:null,updated_at_utc:now()};
+      state.devices[deviceId]=d;await persist();return publicDevice(d);
+    });
+  }
+  async function status({deviceId}={}){
+    const d=getDevice(deviceId);return publicDevice(d);
+  }
+  async function reportOnline({deviceId,epoch,connectionId}={}){
+    insist(typeof connectionId==='string'&&connectionId.length>=1&&connectionId.length<=256,'connection id invalid');
+    return withLock(async()=>{
+      const d=getDevice(deviceId,epoch);d.reported_online=true;d.reachable=false;d.connection_id=connectionId;
+      d.last_probe_nonce=null;d.updated_at_utc=now();await persist();return publicDevice(d);
+    });
+  }
+  async function probe({deviceId,epoch}={}){
+    const nonce=randomBytes(32).toString('hex');
+    let connectionId;
+    await withLock(async()=>{
+      const d=getDevice(deviceId,epoch);insist(d.reported_online&&d.connection_id,'remote device is not reported online');
+      connectionId=d.connection_id;d.reachable=false;d.last_probe_nonce=nonce;d.updated_at_utc=now();await persist();
+    });
+    const response=await relay.probe({device_id:deviceId,epoch,connection_id:connectionId,nonce});
+    return withLock(async()=>{
+      const d=getDevice(deviceId,epoch);
+      insist(response&&response.device_id===deviceId&&response.epoch===epoch&&response.nonce===nonce&&response.ready===true,'remote readiness probe acknowledgment invalid');
+      insist(d.connection_id===connectionId&&d.last_probe_nonce===nonce,'remote connection changed during readiness probe');
+      d.reachable=true;d.updated_at_utc=now();await persist();return {...publicDevice(d),probe_nonce:nonce};
+    });
+  }
+  async function dispatch({deviceId,epoch,capabilityId,payload={},requestId}={}){
+    insist(HEX64.test(requestId??''),'remote request id invalid');
+    insist(typeof capabilityId==='string'&&CAP.test(capabilityId),'remote capability id invalid');
+    insist(payload&&typeof payload==='object','remote payload must be JSON object');
+    let payloadJson;try{payloadJson=canonicalJson(payload);}catch{throw new Error('remote payload is not JSON serializable');}
+    const requestSha=payloadHash({deviceId,epoch,capabilityId,payload});
+    const existing=state.requests[requestId];
+    if(existing){
+      insist(existing.request_sha256===requestSha,'remote request id conflict');
+      return {...structuredClone(existing),replay:true};
+    }
+    const allowed=await authorizeCapability({deviceId,epoch,capabilityId});
+    insist(allowed===true,'remote capability denied by local policy');
+    await withLock(async()=>{
+      const d=getDevice(deviceId,epoch);insist(d.reported_online&&d.reachable,'remote device not reachable');
+      const again=state.requests[requestId];
+      if(again){insist(again.request_sha256===requestSha,'remote request id conflict');return;}
+      state.requests[requestId]={request_id:requestId,request_sha256:requestSha,device_id:deviceId,epoch,capability_id:capabilityId,
+        payload_sha256:sha(Buffer.from(payloadJson,'utf8')),state:'accepted',created_at_utc:now(),updated_at_utc:now()};
+      await persist();
+    });
+    if(state.requests[requestId].state!=='accepted')return {...structuredClone(state.requests[requestId]),replay:true};
+    let response=null;
+    try{response=await relay.request({device_id:deviceId,epoch,capability_id:capabilityId,payload,request_id:requestId,request_sha256:requestSha});}
+    catch(error){
+      return withLock(async()=>{const rec=state.requests[requestId];rec.state='failed';rec.error_code='transport_error';rec.error=String(error?.message??error);rec.updated_at_utc=now();await persist();return structuredClone(rec);});
+    }
+    if(!response||response.ack!=='accepted'||response.request_id!==requestId){
+      return withLock(async()=>{const rec=state.requests[requestId];rec.state='failed';rec.error_code='transport_no_ack';rec.updated_at_utc=now();await persist();return structuredClone(rec);});
+    }
+    await withLock(async()=>{const rec=state.requests[requestId];rec.state='executing';rec.acknowledged_at_utc=now();rec.updated_at_utc=now();await persist();});
+    const terminal=response.terminal;
+    if(!terminal||!['completed','failed'].includes(terminal.status)){
+      return withLock(async()=>{const rec=state.requests[requestId];rec.state='failed';rec.error_code='transport_no_terminal';rec.updated_at_utc=now();await persist();return structuredClone(rec);});
+    }
+    return withLock(async()=>{
+      const rec=state.requests[requestId];rec.state=terminal.status;
+      if(terminal.status==='completed'){insist(HEX64.test(terminal.result_sha256??''),'remote terminal result hash invalid');rec.result_sha256=terminal.result_sha256;}
+      else {rec.error_code=typeof terminal.error_code==='string'?terminal.error_code:'remote_failed';}
+      rec.updated_at_utc=now();rec.completed_at_utc=now();await persist();return structuredClone(rec);
+    });
+  }
+  async function revoke({deviceId,epoch}={}){
+    return withLock(async()=>{
+      const d=getDevice(deviceId,epoch);d.revoked=true;d.reported_online=false;d.reachable=false;d.connection_id=null;d.updated_at_utc=now();await persist();
+      return {...publicDevice(d),revoked:true};
+    });
+  }
+  async function rotateCredential({deviceId,epoch,encryptedBundleBase64,expectedPreviousSha256}={}){
+    const d=getDevice(deviceId,epoch);void d;
+    insist(typeof encryptedBundleBase64==='string'&&encryptedBundleBase64.length>=1&&encryptedBundleBase64.length<=1024*1024,'encrypted credential bundle invalid');
+    const encrypted=Buffer.from(encryptedBundleBase64,'base64');
+    insist(encrypted.length>0&&encrypted.toString('base64')===encryptedBundleBase64,'encrypted credential base64 non-canonical');
+    const credentialSha=sha(encrypted),file=path.join(credentialsDir,`${deviceId}.json`);
+    let previous=null;
+    try{
+      const st=await lstat(file);insist(st.isFile()&&!st.isSymbolicLink(),'credential state must be real file');
+      previous=JSON.parse(await readFile(file,'utf8'));
+      insist(previous.schema===CREDENTIAL_SCHEMA&&previous.device_id===deviceId,'credential state identity invalid');
+    }catch(error){if(error?.code!=='ENOENT')throw error;}
+    if(expectedPreviousSha256===null)insist(previous===null,'credential precondition failed: expected absent');
+    else {
+      insist(HEX64.test(expectedPreviousSha256??''),'credential previous hash invalid');
+      insist(previous?.credential_sha256===expectedPreviousSha256,'credential precondition failed');
+    }
+    const value={schema:CREDENTIAL_SCHEMA,device_id:deviceId,epoch,credential_sha256:credentialSha,
+      encrypted_bundle_base64:encryptedBundleBase64,rotated_at_utc:now()};
+    await atomicJson(file,value);
+    if(previous&&previous.credential_sha256!==credentialSha&&onCredentialSuperseded){
+      await onCredentialSuperseded({device_id:deviceId,epoch,previous_credential_sha256:previous.credential_sha256,new_credential_sha256:credentialSha});
+    }
+    return {status:'committed',device_id:deviceId,epoch,credential_sha256:credentialSha,previous_credential_sha256:previous?.credential_sha256??null};
+  }
+  async function list(){return {status:'ok',devices:Object.values(state.devices).map(publicDevice).sort((a,b)=>a.device_id.localeCompare(b.device_id)),requests:structuredClone(state.requests)};}
+  return Object.freeze({pair,status,reportOnline,probe,dispatch,revoke,rotateCredential,list,state_file:stateFile});
+}

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

@@ -3,7 +3,7 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
-import { R36_COMPACT_GATEWAYS, R36_COMPACT_TOOL_LIMIT } from './remote-mcp-r36-parity-client.mjs';
+import { R44_COMPACT_GATEWAYS, R44_COMPACT_TOOL_LIMIT } from './remote-mcp-r44-parity-client.mjs';
 import { promptContexts, promptObservations, promptMutationEpoch } from './autonomous-live-state.mjs';
 import { classifyAutonomousTimeoutRecovery } from './autonomous-timeout-recovery.mjs';
 
@@ -113,10 +113,10 @@ try {
   await client.connect(transport);
   const listed = await client.listTools();
   const names = listed.tools.map(tool => tool.name).sort();
-  if (names.length > R36_COMPACT_TOOL_LIMIT) throw new Error(`R36 compact public catalog exceeds ${R36_COMPACT_TOOL_LIMIT}: ${names.length}`);
-  for (const name of R36_COMPACT_GATEWAYS) if (!names.includes(name)) throw new Error(`R36 compact public gateway missing ${name}`);
+  if (names.length > R44_COMPACT_TOOL_LIMIT) throw new Error(`R44 compact public catalog exceeds ${R44_COMPACT_TOOL_LIMIT}: ${names.length}`);
+  for (const name of R44_COMPACT_GATEWAYS) if (!names.includes(name)) throw new Error(`R44 compact public gateway missing ${name}`);
   for (const name of ['autonomous_goal_submit','autonomous_goal_run','autonomous_goal_status','autonomous_goal_events','autonomous_goal_verify','autonomous_release_gate','autonomous_session_status','native_diff_apply','native_diff_preview','native_diff_verify']) {
-    if (!names.includes(name)) throw new Error(`R36 compact autonomous control missing ${name}`);
+    if (!names.includes(name)) throw new Error(`R44 compact autonomous control missing ${name}`);
   }
   for (const tool of listed.tools) {
     if (tool.outputSchema?.type !== 'object' || tool.outputSchema?.additionalProperties !== false || !tool.outputSchema?.properties) {

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

@@ -0,0 +1,203 @@
+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 { R34_EXPECTED_TOOLS } from './remote-mcp-r34-parity-client.mjs';
+import { loadCodingPolicy } from './coding-plane.mjs';
+import { verifyMachineFsReceiptFile } from './machine-fs.mjs';
+import { verifyObservationReceiptFile } from './observation-runtime.mjs';
+import { loadDesktopPolicy } from './desktop-policy-r40.mjs';
+import { verifyDesktopReceiptObject } from './desktop-runtime-r40.mjs';
+import { loadPublicVerifyKey } from './trust.mjs';
+
+export const R44_EXPECTED_TOOLS=Object.freeze([...new Set([
+  ...R34_EXPECTED_TOOLS,
+  'coding_symbol_diagnostics','coding_symbol_implementations','coding_symbol_rename_preview',
+  'desktop_status','desktop_observe','desktop_target','desktop_action','skill_catalog'
+])].sort());
+if(R44_EXPECTED_TOOLS.length !== 81) throw new Error(`R44 full catalog identity mismatch: ${R44_EXPECTED_TOOLS.length}`);
+export const R44_COMPACT_GATEWAYS=Object.freeze(['capability_manifest','coding_inspect','machine_fs','machine_observe','process_session','desktop_control'].sort());
+export const R44_COMPACT_TOOL_LIMIT=43;
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const repoRoot=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const verifyKeyPath=path.join(stateRoot,'trust','ed25519-public.pem');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+
+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)} error=${String(value.error??'')}`);
+  return value.result;
+}
+async function fileSha(relative){return sha256(await readFile(path.join(repoRoot,...relative.split('/'))));}
+async function verifyMachineReceipt(policy,receiptId,operation){
+  const checked=await verifyMachineFsReceiptFile({policy,verifyKeyPath,receiptId});
+  if(!checked.ok||checked.signature_valid!==true||checked.operation!==operation) throw new Error(`machine-fs receipt verification failed for ${operation}`);
+  return checked;
+}
+async function verifyObservationReceipt(policy,receiptId){
+  const checked=await verifyObservationReceiptFile({policy,verifyKeyPath,receiptId});
+  if(!checked.ok||checked.signature_valid!==true) throw new Error('observation receipt verification failed');
+  return checked;
+}
+async function verifyDesktopReceipt(policy,verifyKey,receiptId,receiptSha256,kind){
+  const file=path.join(policy.evidence_dir,`${receiptId}.json`);
+  const receipt=JSON.parse(await readFile(file,'utf8'));
+  const checked=verifyDesktopReceiptObject(receipt,{policySha256:policy.policy_sha256,publicKey:verifyKey.publicKey,keyId:verifyKey.keyId});
+  if(!checked.ok||checked.receipt_sha256!==receiptSha256||checked.kind!==kind) throw new Error(`desktop receipt verification failed for ${kind}`);
+  return checked;
+}
+async function waitSearch(client,searchId){
+  for(let attempt=0;attempt<200;attempt+=1){
+    const status=gateway(await client.callTool({name:'machine_observe',arguments:{op:'search_status',search_id:searchId}}),'search_status');
+    if(['completed','cancelled','failed'].includes(status.state)) return status;
+    await sleep(25);
+  }
+  throw new Error('R44 compact search timeout');
+}
+async function waitProcessOutput(client,sessionId){
+  for(let attempt=0;attempt<100;attempt+=1){
+    const page=gateway(await client.callTool({name:'process_session',arguments:{op:'read',session_id:sessionId,offset:0,max_bytes:65536}}),'process read');
+    if(Buffer.from(page.data_base64??'','base64').toString('utf8').includes('DEADBYTE_ACTION_PING')) return page;
+    await sleep(50);
+  }
+  throw new Error('R44 compact process output timeout');
+}
+
+export async function runR44CompactParity(endpointText){
+  const endpoint=new URL(endpointText);
+  if(endpoint.protocol!=='https:') throw new Error('R44 compact parity requires HTTPS');
+  const pointer=JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));
+  const policy=await loadCodingPolicy(path.join(pointer.generation_root,'coding-policy.json'));
+  const desktopPolicy=await loadDesktopPolicy(path.join(pointer.generation_root,'desktop-policy.json'));
+  const desktopVerifyKey=await loadPublicVerifyKey(verifyKeyPath);
+  const client=new Client({name:'deadbyte-r44-compact-parity',version:'0.12.0'},{versionNegotiation:{mode:{pin:'2026-07-28'}}});
+  const transport=new StreamableHTTPClientTransport(endpoint);
+  const tag=randomBytes(8).toString('hex');
+  const scratchRoot='parity_scratch';
+  const target=`.deadbyte-r44-parity-${tag}.txt`;
+  let processSession=null,targetPresent=false;
+  const machineReceipts=[],observationReceipts=[];
+  try{
+    await client.connect(transport);
+    const listed=await client.listTools();
+    const names=listed.tools.map(tool=>tool.name).sort();
+    if(names.length>R44_COMPACT_TOOL_LIMIT) throw new Error(`R44 compact catalog exceeds ${R44_COMPACT_TOOL_LIMIT}: ${names.length}`);
+    if(names.length!==R44_COMPACT_TOOL_LIMIT) throw new Error(`R44 compact catalog must be exactly ${R44_COMPACT_TOOL_LIMIT}, got ${names.length}`);
+    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'||!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);
+    for(const item of required){
+      if(typeof item.compact_tool!=='string'||!names.includes(item.compact_tool)) throw new Error(`compact capability route missing: ${String(item.id)}`);
+    }
+    const skillCatalog=structured(await client.callTool({name:'skill_catalog',arguments:{op:'list'}}),'skill_catalog');
+    if(skillCatalog.status!=='ok'||skillCatalog.op!=='list'||!skillCatalog.result||!Array.isArray(skillCatalog.result.skills)||
+       !/^[0-9a-f]{64}$/.test(String(skillCatalog.result.registry_sha256??''))) throw new Error('R44 skill catalog verification failed');
+    const coding=structured(await client.callTool({name:'coding_session_status',arguments:{}}),'coding_session_status');
+    const autonomous=structured(await client.callTool({name:'autonomous_session_status',arguments:{}}),'autonomous_session_status');
+    if(coding.armed!==true||autonomous.coding_armed!==true||autonomous.autonomous_armed!==true) throw new Error('R44 compact parity requires coding and autonomous standing grants');
+    const desktopStatus=gateway(await client.callTool({name:'desktop_control',arguments:{op:'status'}}),'desktop status');
+    if(desktopStatus.configured!==true||desktopStatus.armed!==false) throw new Error('R44 compact parity requires Desktop configured and DISARMED');
+    const desktopObserved=gateway(await client.callTool({name:'desktop_control',arguments:{op:'observe',preview:false}}),'desktop observe');
+    await verifyDesktopReceipt(desktopPolicy,desktopVerifyKey,desktopObserved.receipt_id,desktopObserved.receipt_sha256,'desktop_observation');
+    const desktopTarget=gateway(await client.callTool({name:'desktop_control',arguments:{op:'target',frame_id:desktopObserved.frame.frame_id,uia_query:{kind:'root',value:'',max_results:1,ordinal:0}}}),'desktop target');
+    await verifyDesktopReceipt(desktopPolicy,desktopVerifyKey,desktopTarget.grounding.receipt_id,desktopTarget.grounding.receipt_sha256,'desktop_grounding');
+    if(desktopTarget.target?.source!=='uia') throw new Error('R44 compact UIA root grounding missing');
+    const tree=structured(await client.callTool({name:'coding_tree',arguments:{root_id:'core',path:'workspaces/demo',max_depth:2,max_entries:128}}),'coding_tree');
+    if(tree.status!=='ok'||!Array.isArray(tree.entries)) throw new Error('coding_tree malformed');
+    const stat=gateway(await client.callTool({name:'coding_inspect',arguments:{op:'stat',root_id:'core',path:'package.json',hash:true}}),'coding stat');
+    if(stat.type!=='file'||!/^[0-9a-f]{64}$/.test(String(stat.sha256??''))||!/^[0-9a-f]{64}$/.test(String(stat.observation_sha256??''))) throw new Error('coding stat identity missing');
+    const search=gateway(await client.callTool({name:'coding_inspect',arguments:{op:'search',root_id:'core',path:'src',pattern:'R36_CAPABILITY_LEDGER',target:'content',mode:'literal',case_sensitive:true,max_results:20,max_file_bytes:262144,max_scan_bytes:4194304,page_size:20,cursor:null}}),'coding search');
+    if(!Array.isArray(search.matches)||search.matches.length<1) throw new Error('coding search returned no canonical ledger match');
+
+    const buildScript='scripts/autonomous-build.ps1';
+    const testScript='scripts/release-parity-tests-r40.ps1';
+    const build=structured(await client.callTool({name:'coding_command_run',arguments:{root_id:'core',command_id:'powershell_script',script_path:buildScript,script_sha256:await fileSha(buildScript),args:[],cwd:'.',timeout_ms:120000}},{timeout:180000,maxTotalTimeout:180000}),'coding build');
+    if(build.status!=='passed'||build.exit_code!==0) throw new Error('R44 coding build failed');
+    const buildVerify=structured(await client.callTool({name:'coding_receipt_verify',arguments:{receipt_id:build.receipt_id}}),'coding build receipt');
+    if(buildVerify.ok!==true||buildVerify.signature_valid!==true) throw new Error('R44 coding build receipt invalid');
+    const tests=structured(await client.callTool({name:'coding_command_run',arguments:{root_id:'core',command_id:'powershell_script',script_path:testScript,script_sha256:await fileSha(testScript),args:[],cwd:'.',timeout_ms:300000}},{timeout:360000,maxTotalTimeout:360000}),'coding tests');
+    if(tests.status!=='passed'||tests.exit_code!==0) throw new Error('R44 coding tests failed');
+    const testVerify=structured(await client.callTool({name:'coding_receipt_verify',arguments:{receipt_id:tests.receipt_id}}),'coding test receipt');
+    if(testVerify.ok!==true||testVerify.signature_valid!==true) throw new Error('R44 coding test receipt invalid');
+
+    const initial=`needle-${tag}\n`;
+    const write=gateway(await client.callTool({name:'machine_fs',arguments:{op:'write',root_id:scratchRoot,path:target,content:initial,encoding:'utf8',expected_sha256:'absent'}}),'machine_fs write');
+    targetPresent=true;machineReceipts.push(write.receipt_id);await verifyMachineReceipt(policy,write.receipt_id,'machine_fs_write');
+    const bounded=gateway(await client.callTool({name:'machine_fs',arguments:{op:'read',root_id:scratchRoot,path:target,offset:0,max_bytes:128,hash_file:true}}),'machine_fs read');
+    if(Buffer.from(bounded.data_base64,'base64').toString('utf8')!==initial||bounded.file_sha256!==write.sha256) throw new Error('R44 bounded machine read mismatch');
+    const edit=gateway(await client.callTool({name:'machine_fs',arguments:{op:'edit_exact',root_id:scratchRoot,path:target,expected_sha256:write.sha256,old_string:'needle',new_string:'beta',expected_replacements:1}}),'machine_fs edit');
+    machineReceipts.push(edit.receipt_id);await verifyMachineReceipt(policy,edit.receipt_id,'machine_fs_edit_exact');
+    const stale=await client.callTool({name:'machine_fs',arguments:{op:'edit_exact',root_id:scratchRoot,path:target,expected_sha256:write.sha256,old_string:'beta',new_string:'bad',expected_replacements:1}});
+    const staleValue=stale.structuredContent;
+    if(!staleValue||typeof staleValue!=='object') throw new Error('R44 stale machine-fs denial missing structured output');
+    if(stale.isError!==true||staleValue.status!=='denied'||!/precondition mismatch/i.test(String(staleValue.error??''))) {
+      throw new Error(`R44 stale machine-fs precondition was not denied: ${JSON.stringify(staleValue)}`);
+    }
+
+    const searchStart=gateway(await client.callTool({name:'machine_observe',arguments:{op:'search_start',root_id:scratchRoot,path:'.',pattern:tag,case_sensitive:true,max_results:20,max_files:200,max_bytes:262144,max_file_bytes:16384}}),'observe search start');
+    const searchStatus=await waitSearch(client,searchStart.search_id);
+    if(searchStatus.state!=='completed'||!searchStatus.receipt_id) throw new Error('R44 compact observation search failed');
+    observationReceipts.push(searchStatus.receipt_id);await verifyObservationReceipt(policy,searchStatus.receipt_id);
+    const page=gateway(await client.callTool({name:'machine_observe',arguments:{op:'search_page',search_id:searchStart.search_id,limit:20,cursor:null}}),'observe search page');
+    if(!page.results.some(item=>item.path===target)) throw new Error('R44 compact search did not return parity file');
+    const system=gateway(await client.callTool({name:'machine_observe',arguments:{op:'system_status'}}),'system status');
+    observationReceipts.push(system.receipt_id);await verifyObservationReceipt(policy,system.receipt_id);
+    const machineStatus=gateway(await client.callTool({name:'machine_observe',arguments:{op:'machine_status'}}),'machine status');
+    if(machineStatus.release_id!==pointer.release_id||machineStatus.release_manifest_sha256!==pointer.manifest_sha256) throw new Error('R44 compact machine status release mismatch');
+
+    const started=gateway(await client.callTool({name:'process_session',arguments:{op:'start',profile_id:'ping_hold',root_id:'core',cwd:'.',args:[]}}),'process start');
+    processSession=started.session_id??started.session?.session_id;
+    if(!/^[0-9a-f]{64}$/.test(String(processSession??''))) throw new Error('R44 compact process session id missing');
+    const action=gateway(await client.callTool({name:'process_session',arguments:{op:'action',session_id:processSession,action_id:'ping'}}),'process action');
+    const processRead=await waitProcessOutput(client,processSession);
+    const terminated=gateway(await client.callTool({name:'process_session',arguments:{op:'terminate',session_id:processSession}}),'process terminate');
+    const terminalState=terminated.state??terminated.session?.state;
+    if(action.action_id!=='ping'||terminalState!=='terminated') throw new Error('R44 compact process lifecycle failed');
+
+    const fsStat=gateway(await client.callTool({name:'machine_fs',arguments:{op:'stat',root_id:scratchRoot,path:target,hash:true}}),'machine_fs stat');
+    const deleted=gateway(await client.callTool({name:'machine_fs',arguments:{op:'delete',root_id:scratchRoot,path:target,expected_source_identity:fsStat.identity_sha256}}),'machine_fs delete');
+    machineReceipts.push(deleted.receipt_id);await verifyMachineReceipt(policy,deleted.receipt_id,'machine_fs_delete');targetPresent=false;
+
+    return {status:'passed',protocol_revision:client.getNegotiatedProtocolVersion(),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,
+      gateway_count:R44_COMPACT_GATEWAYS.length,skill_catalog_verified:true,skill_count:skillCatalog.result.skills.length,tree_entries:tree.entries.length,coding_stat_verified:true,coding_search_result_count:search.matches.length,
+      desktop_armed:false,desktop_observation_receipt_verified:true,desktop_grounding_receipt_verified:true,
+      desktop_frame_id:desktopObserved.frame.frame_id,desktop_target_id:desktopTarget.target.target_id,
+      machine_fs_receipts_verified:machineReceipts.length,observation_receipts_verified:observationReceipts.length,
+      observation_search_result_count:page.results.length,process_session_id:processSession,process_output_bytes:processRead.stream_head,
+      process_journal_head_sha256:terminated.journal_head_sha256??terminated.session?.journal_head_sha256,
+      build_receipt_id:build.receipt_id,test_receipt_id:tests.receipt_id,coding_receipts_verified:2,
+      execution_provider:'deadbyte_mcp',rdc_operation_count:0};
+  } finally {
+    if(processSession) await client.callTool({name:'process_session',arguments:{op:'terminate',session_id:processSession}}).catch(()=>{});
+    if(targetPresent){
+      try{const fsStat=gateway(await client.callTool({name:'machine_fs',arguments:{op:'stat',root_id:scratchRoot,path:target,hash:false}}),'cleanup stat');
+        if(fsStat.identity_sha256) await client.callTool({name:'machine_fs',arguments:{op:'delete',root_id:scratchRoot,path:target,expected_source_identity:fsStat.identity_sha256}}).catch(()=>{});
+      }catch{}
+    }
+    await client.close().catch(()=>{});
+  }
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  const endpoint=process.argv[2];
+  if(!endpoint) throw new Error('usage: node src/remote-mcp-r44-parity-client.mjs https://host/mcp/path');
+  runR44CompactParity(endpoint).then(result=>console.log(JSON.stringify(result,null,2))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

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

@@ -8,7 +8,7 @@ if (!['smoke', 'full'].includes(mode)) throw new Error('mode must be smoke or fu
 const endpoint = new URL(endpointText);
 if (endpoint.protocol !== 'https:') throw new Error('remote MCP gate requires HTTPS');
 
-const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'workspace_open'];
+const baseTools = ['contained_transform', 'evidence_verify', 'file_read', 'proof_execute', 'skill_catalog', 'workspace_open'];
 const privilegedTools = ['host_exec', 'host_file_read', 'host_file_write'];
 const machineTools = ['machine_list', 'machine_ping', 'machine_revoke', 'machine_status'];
 const processTools = [
@@ -53,6 +53,8 @@ const r36CompactTools = [
 if (r36CompactTools.length !== 41) throw new Error(`R36 compact catalog constant drift: ${r36CompactTools.length}`);
 const r40CompactTools = [...r36CompactTools, 'desktop_control'].sort();
 if (r40CompactTools.length !== 42) throw new Error(`R40 compact catalog constant drift: ${r40CompactTools.length}`);
+const r44CompactTools = [...r40CompactTools, 'skill_catalog'].sort();
+if (r44CompactTools.length !== 43) throw new Error(`R44 compact catalog constant drift: ${r44CompactTools.length}`);
 const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
 const allowedCatalogs = [];
 for (const machine of [false, true]) for (const host of [false, true]) for (const agent of [false, true]) {
@@ -98,7 +100,8 @@ try {
   const names = listed.tools.map(t => t.name).sort();
   const exactR36Compact = JSON.stringify(names) === JSON.stringify(r36CompactTools);
   const exactR40Compact = JSON.stringify(names) === JSON.stringify(r40CompactTools);
-  const compactProfile = exactR36Compact || exactR40Compact;
+  const exactR44Compact = JSON.stringify(names) === JSON.stringify(r44CompactTools);
+  const compactProfile = exactR36Compact || exactR40Compact || exactR44Compact;
   const catalogOk = compactProfile || allowedCatalogs.some(expected => JSON.stringify(names) === JSON.stringify(expected));
   if (!catalogOk) throw new Error(`tool catalog mismatch: ${JSON.stringify(names)}`);
   for (const tool of listed.tools) {
@@ -123,7 +126,7 @@ try {
   if (compactProfile) {
     const manifest = gateway(await client.callTool({ name: 'capability_manifest', arguments: {} }), 'capability_manifest');
     const manifestV1 = manifest.schema === 'deadbyte.capability-manifest.v1' && exactR36Compact;
-    const manifestV2 = manifest.schema === 'deadbyte.capability-manifest.v2' && exactR40Compact;
+    const manifestV2 = manifest.schema === 'deadbyte.capability-manifest.v2' && (exactR40Compact || exactR44Compact);
     if ((!manifestV1 && !manifestV2) || manifest.profile !== 'compact' ||
         !Array.isArray(manifest.capabilities) || !/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256 ?? ''))) {
       throw new Error('compact capability manifest malformed');
@@ -132,7 +135,7 @@ try {
       const expectedCatalogSha = sha256(Buffer.from(JSON.stringify(names), 'utf8'));
       if (manifest.tool_count !== names.length || JSON.stringify(manifest.tool_catalog) !== JSON.stringify(names) ||
           manifest.catalog_sha256 !== expectedCatalogSha) {
-        throw new Error('R40 compact capability manifest catalog attestation mismatch');
+        throw new Error('compact v2 capability manifest catalog attestation mismatch');
       }
     }
     const required = manifest.capabilities.filter(item => item?.production === true && item?.host_only !== true);