deadbyte-mcp 0.14.0 → 0.15.1

package/src/process-smoke-client.mjs

@@ -55,7 +55,7 @@ try {
   await client.connect(transport);
   const listed = await client.listTools();
   const names = listed.tools.map(tool => tool.name).sort();
-  const expected = ['contained_transform','evidence_verify','file_read','proof_execute','workspace_open',
+  const expected = ['contained_transform','evidence_verify','file_read','proof_execute','skill_catalog','workspace_open',
     'process_session_action','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate'].sort();
   if (JSON.stringify(names) !== JSON.stringify(expected)) throw new Error(`process smoke catalog mismatch: ${JSON.stringify(names)}`);
   const started = structured(await client.callTool({ name: 'process_session_start', arguments: {
@@ -114,7 +114,7 @@ try {
   }
   if (sequence < 3 || previous !== finalHead) throw new Error('process journal head mismatch');
   if ((await readFile(journalPath, 'utf8')).includes('DEADBYTE_ACTION_PING')) throw new Error('process journal leaked action payload');
-  console.log(JSON.stringify({ status: 'passed', protocol_revision: '2026-07-28', tool_count: 11,
+  console.log(JSON.stringify({ status: 'passed', protocol_revision: '2026-07-28', tool_count: 12,
     profile_id: 'ping_hold', session_id: sessionId, observed_output_bytes: read.stream_head,
     action_id: action.action_id, logical_bytes: action.logical_bytes, logical_sha256: action.logical_sha256,
     final_state: terminated.session.state, event_count: sequence, journal_head_sha256: previous,

package/src/provider-circuit.mjs

@@ -48,10 +48,16 @@ function openAt(state,ms,policy){
 }
 
 export function providerCircuitId(planner){
-  if(!['openai_compatible','openai_responses'].includes(planner?.backend)||typeof planner.endpoint!=='string'||typeof planner.model!=='string') {
+  if(!planner||typeof planner.model!=='string') throw new Error('provider circuit planner identity invalid');
+  let identity;
+  if(['openai_compatible','openai_responses'].includes(planner.backend)&&typeof planner.endpoint==='string') {
+    identity=`${planner.backend}\0${planner.endpoint}\0${planner.model}`;
+  } else if(planner.backend==='codex_app_server'&&HEX64.test(planner.executable_sha256??'')&&typeof planner.root_id==='string') {
+    identity=`${planner.backend}\0${planner.executable_sha256}\0${planner.model}\0${planner.root_id}`;
+  } else {
     throw new Error('provider circuit planner identity invalid');
   }
-  const digest=createHash('sha256').update(Buffer.from(`${planner.backend}\0${planner.endpoint}\0${planner.model}`,'utf8')).digest('hex');
+  const digest=createHash('sha256').update(Buffer.from(identity,'utf8')).digest('hex');
   return `${planner.backend}:${digest}`;
 }
 

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/r45-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 { R45_COMPACT_GATEWAYS,R45_COMPACT_TOOL_LIMIT } from './remote-mcp-r45-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('R45 desktop '+kind+' receipt verification failed');
+}
+export async function probeR45CompactDisarmed(endpointText){
+  const endpoint=new URL(endpointText);if(endpoint.protocol!=='https:')throw new Error('R45 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-r45-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!==R45_COMPACT_TOOL_LIMIT)throw new Error('R45 compact disarmed catalog must be exactly '+R45_COMPACT_TOOL_LIMIT+', got '+names.length);
+    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||
+       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));
+    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('R45 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('R45 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='r45-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('R45 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/r45-compact-disarmed-probe.mjs https://host/mcp/path');
+probeR45CompactDisarmed(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/r45-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 { R45_EXPECTED_TOOLS } from './remote-mcp-r45-parity-client.mjs';
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+export async function probeR45FullSurface({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-r45-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(R45_EXPECTED_TOOLS))throw new Error('R45 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('R45 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/r45-full-surface-probe.mjs <package-root> <generation-root>');
+probeR45FullSurface({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

@@ -84,6 +84,7 @@ async function rebindAutonomousPolicy(raw,{stateRoot,codingPolicy,codingPolicyBy
     if(id==='windows-release'){
       if(profile.kind!=='command'||rootId!=='core'||profile.command_id!=='powershell_script') throw new Error('windows release profile shape invalid');
       profile.script_path=await currentWindowsGateScript(rootPath);
+      profile.timeout_ms=600000;
       profile.description='Full Windows target release gate; runs only when finish is requested.';
     }
     const rel=safeRel(String(profile.script_path).replaceAll('\\','/'));

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