deadbyte-mcp 0.8.10 → 0.10.0

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

@@ -3,7 +3,8 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
-import { R33_EXPECTED_TOOLS } from './remote-mcp-r33-parity-client.mjs';
+import { R36_COMPACT_GATEWAYS, R36_COMPACT_TOOL_LIMIT } from './remote-mcp-r36-parity-client.mjs';
+import { promptContexts, promptObservations, promptMutationEpoch } from './autonomous-live-state.mjs';
 
 const endpointText = process.argv[2];
 if (!endpointText) throw new Error('usage: node src/remote-mcp-autonomous-smoke-client.mjs https://host/mcp/path');
@@ -14,11 +15,34 @@ const coreRoot = path.resolve(here, '..');
 const fixtureRelative = 'workspaces/autonomous-live/fixture.txt';
 const fixtureAbsolute = path.join(coreRoot, ...fixtureRelative.split('/'));
 const expectedFinal = 'READY\n';
+const AUTONOMOUS_RUN_MAX_CYCLES_PER_REQUEST = 1;
+const AUTONOMOUS_RUN_REQUEST_TIMEOUT_MS = 100000;
+const AUTONOMOUS_RUN_MAX_REQUESTS = 64;
+const AUTONOMOUS_TIMEOUT_RECOVERY_POLL_MS = 2000;
+const AUTONOMOUS_TIMEOUT_RECOVERY_MAX_POLLS = 120;
+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} returned no structured object`);
   return result.structuredContent;
 }
+async function recoverTimedOutGoal(client, goalId) {
+  for (let poll = 0; poll < AUTONOMOUS_TIMEOUT_RECOVERY_MAX_POLLS; poll += 1) {
+    const status = structured(await client.callTool(
+      { name:'autonomous_goal_status', arguments:{ goal_id:goalId } },
+      { timeout:30000, maxTotalTimeout:30000 }
+    ), 'autonomous_goal_status');
+    if (status.state === 'succeeded') return status;
+    if (status.state === 'cancelled' || status.state === 'paused') {
+      throw new Error(`autonomous goal became terminal after request timeout: ${JSON.stringify(status)}`);
+    }
+    if (status.state !== 'pending' && status.state !== 'running') {
+      throw new Error(`autonomous goal returned unexpected recovery state: ${JSON.stringify(status)}`);
+    }
+    await sleep(AUTONOMOUS_TIMEOUT_RECOVERY_POLL_MS);
+  }
+  throw new Error('autonomous goal did not reach a durable terminal state after request timeout');
+}
 function messageText(content) {
   if (typeof content === 'string') return content;
   if (Array.isArray(content)) return content.map(messageText).join('\n');
@@ -37,41 +61,42 @@ function parseState(prompt) {
   return JSON.parse(end >= 0 ? tail.slice(0, end) : tail);
 }
 function latestFixtureContext(state) {
-  return [...(state.contexts ?? [])].reverse().find(item => item.path === fixtureRelative) ?? null;
+  return [...promptContexts(state)].reverse().find(item => item.path === fixtureRelative) ?? null;
 }
 function latestTestObservation(state) {
-  return [...(state.observations ?? [])].reverse().find(item => item.profile_id === 'quick-test') ?? null;
+  return [...promptObservations(state)].reverse().find(item => item.profile_id === 'quick-test') ?? null;
 }let samplingRounds = 0;
 let sawFailureEvidence = false;
 function plannerDecision(prompt) {
   const state = parseState(prompt);
   samplingRounds += 1;
+  const mutationEpoch = promptMutationEpoch(state);
   const context = latestFixtureContext(state);
   const testObservation = latestTestObservation(state);
   if (testObservation?.passed === false) sawFailureEvidence = true;
   if (!context) return { schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'inspect live fixture before mutation',
     reads:[{ path:fixtureRelative, max_bytes:4096 }] };
-  if (state.mutation_epoch === 0 && context.content === expectedFinal) {
+  if (mutationEpoch === 0 && context.content === expectedFinal) {
     return { schema:'deadbyte.autonomous-decision.v1', action:'patch', summary:'deliberately introduce a failing state to prove diagnosis and replanning',
       operations:[{ kind:'replace', path:fixtureRelative, expected_sha256:context.sha256,
         old_string:'READY', new_string:'ALMOST', expected_replacements:1 }] };
   }
-  if (state.mutation_epoch === 1 && context.content !== 'ALMOST\n') {
+  if (mutationEpoch === 1 && context.content !== 'ALMOST\n') {
     return { schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'refresh fixture after observed test failure before corrective patch',
       reads:[{ path:fixtureRelative, max_bytes:4096 }] };
   }
-  if (state.mutation_epoch === 1 && context.content === 'ALMOST\n' && sawFailureEvidence) {
+  if (mutationEpoch === 1 && context.content === 'ALMOST\n' && sawFailureEvidence) {
     return { schema:'deadbyte.autonomous-decision.v1', action:'patch', summary:'repair the diagnosed fixture failure using the refreshed SHA precondition',
       operations:[{ kind:'replace', path:fixtureRelative, expected_sha256:context.sha256,
         old_string:'ALMOST', new_string:'READY', expected_replacements:1 }] };
   }
-  if (state.mutation_epoch >= 2 && testObservation?.passed === true) {
+  if (mutationEpoch >= 2 && testObservation?.passed === true) {
     return { schema:'deadbyte.autonomous-decision.v1', action:'finish', summary:'acceptance restored and current-epoch quick test evidence passes' };
   }
   return { schema:'deadbyte.autonomous-decision.v1', action:'inspect', summary:'gather current fixture state before deciding next action',
     reads:[{ path:fixtureRelative, max_bytes:4096 }] };
 }const client = new Client(
-  { name:'deadbyte-r24-public-autonomous-gate', version:'0.8.0' },
+  { name:'deadbyte-r36-public-autonomous-gate', version:'0.10.0' },
   { capabilities:{ sampling:{} }, versionNegotiation:{ mode:{ pin:'2026-07-28' } },
     inputRequired:{ autoFulfill:true, maxRounds:16 } }
 );
@@ -88,7 +113,11 @@ try {
   await client.connect(transport);
   const listed = await client.listTools();
   const names = listed.tools.map(tool => tool.name).sort();
-  if (JSON.stringify(names) !== JSON.stringify(R33_EXPECTED_TOOLS)) throw new Error(`R33 public catalog mismatch: ${JSON.stringify(names)}`);
+  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}`);
+  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}`);
+  }
   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`);
@@ -105,12 +134,26 @@ try {
   } }), 'autonomous_goal_submit');
   goalId = submitted.goal_id;
   if (!goalId || submitted.state !== 'pending') throw new Error(`autonomous submit failed: ${JSON.stringify(submitted)}`);
-  const ran = structured(await client.callTool(
-    { name:'autonomous_goal_run', arguments:{ goal_id:goalId, max_cycles:32 } },
-    { timeout:900000, maxTotalTimeout:900000 }
-  ), 'autonomous_goal_run');
-  if (ran.status !== 'completed' || ran.state !== 'succeeded' || ran.release?.ready !== true) {
-    throw new Error(`autonomous goal did not release: ${JSON.stringify(ran)}`);
+  let ran = null;
+  let recoveredRequestTimeout = false;
+  for (let requestRound = 0; requestRound < AUTONOMOUS_RUN_MAX_REQUESTS; requestRound += 1) {
+    try {
+      ran = structured(await client.callTool(
+        { name:'autonomous_goal_run', arguments:{ goal_id:goalId, max_cycles:AUTONOMOUS_RUN_MAX_CYCLES_PER_REQUEST } },
+        { timeout:AUTONOMOUS_RUN_REQUEST_TIMEOUT_MS, maxTotalTimeout:AUTONOMOUS_RUN_REQUEST_TIMEOUT_MS }
+      ), 'autonomous_goal_run');
+    } catch (error) {
+      if (String(error?.code ?? '') !== 'REQUEST_TIMEOUT') throw error;
+      const recovered = await recoverTimedOutGoal(client, goalId);
+      ran = { status:'completed', state:recovered.state, goal_id:goalId, recovered_from_timeout:true };
+      recoveredRequestTimeout = true;
+    }
+    if (ran.status === 'completed' && ran.state === 'succeeded') break;
+    if (ran.status === 'yielded') continue;
+    throw new Error(`autonomous goal did not make resumable progress: ${JSON.stringify(ran)}`);
+  }
+  if (!ran || ran.status !== 'completed' || ran.state !== 'succeeded') {
+    throw new Error(`autonomous goal did not release within ${AUTONOMOUS_RUN_MAX_REQUESTS} bounded requests: ${JSON.stringify(ran)}`);
   }
   if (!sawFailureEvidence || samplingRounds < 5) throw new Error(`autonomous replanning proof missing: failure=${sawFailureEvidence} rounds=${samplingRounds}`);
   const verified = structured(await client.callTool({ name:'autonomous_goal_verify', arguments:{ goal_id:goalId } }), 'autonomous_goal_verify');

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

@@ -17,10 +17,11 @@ const tag = randomBytes(8).toString('hex');
 const editPath = `workspaces/demo/.deadbyte-coding-smoke-${tag}.txt`;
 const taskPath = `workspaces/demo/.deadbyte-coding-task-${tag}.txt`;
 const codingTools = [
-  'coding_benchmark_run', 'coding_command_run', 'coding_file_read', 'coding_file_write',
-  'coding_receipt_verify', 'coding_session_status', 'coding_task_approve', 'coding_task_cancel',
-  'coding_task_events', 'coding_task_run', 'coding_task_status', 'coding_task_submit',
-  'coding_task_verify', 'coding_text_replace', 'coding_tree'
+  'coding_benchmark_run', 'coding_command_run', 'coding_file_read', 'coding_file_write', 'coding_files_read',
+  'coding_receipt_verify', 'coding_search', 'coding_session_status', 'coding_stat',
+  'coding_symbol_definition', 'coding_symbol_diagnostics', 'coding_symbol_implementations', 'coding_symbol_outline', 'coding_symbol_references', 'coding_symbol_rename_preview', 'coding_symbol_replace',
+  'coding_task_approve', 'coding_task_cancel', 'coding_task_events', 'coding_task_run', 'coding_task_status',
+  'coding_task_submit', 'coding_task_verify', 'coding_text_replace', 'coding_tree'
 ];
 const client = new Client(
   { name: 'deadbyte-coding-remote-gate', version: '0.8.0' },

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

@@ -3,6 +3,7 @@ import { stat } from 'node:fs/promises';
 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';
 const endpointText = process.argv[2];
 if (!endpointText) throw new Error('usage: node src/remote-mcp-r24-disarmed-smoke-client.mjs https://host/mcp/path');
 const endpoint = new URL(endpointText);
@@ -18,7 +19,8 @@ let exists = false;
 try {
   await client.connect(transport);
   const listed = await client.listTools();
-  if (listed.tools.length !== 68) throw new Error(`expected 68 tools, got ${listed.tools.length}`);
+  const names=listed.tools.map(tool=>tool.name).sort();
+  if (JSON.stringify(names) !== JSON.stringify(R34_EXPECTED_TOOLS)) throw new Error(`R34 disarmed catalog mismatch: ${JSON.stringify(names)}`);
   const session = await client.callTool({ name:'autonomous_session_status', arguments:{} });
   const status = session.structuredContent;
   if (!status || status.coding_armed !== false || status.autonomous_armed !== false) throw new Error(`authority still armed: ${JSON.stringify(status)}`);  const deniedWrite = await client.callTool({ name:'coding_file_write', arguments:{
@@ -31,7 +33,7 @@ try {
   if (deniedGoal.isError !== true) throw new Error(`autonomous submit unexpectedly allowed: ${JSON.stringify(deniedGoal.structuredContent)}`);
   try { await stat(targetAbsolute); exists = true; } catch (error) { if (error?.code !== 'ENOENT') throw error; }
   if (exists) throw new Error('disarmed coding mutation created a file');
-  console.log(JSON.stringify({ status:'passed', protocol_revision:client.getNegotiatedProtocolVersion(), tool_count:68,
+  console.log(JSON.stringify({ status:'passed', protocol_revision:client.getNegotiatedProtocolVersion(), tool_count:R34_EXPECTED_TOOLS.length,
     coding_armed:false, autonomous_armed:false, coding_mutation_denied:true, autonomous_submit_denied:true, target_absent:true }));
 } finally {
   await client.close().catch(() => {});

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

@@ -0,0 +1,177 @@
+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 { loadCodingPolicy } from './coding-plane.mjs';
+import { verifyMachineFsReceiptFile } from './machine-fs.mjs';
+import { verifyObservationReceiptFile } from './observation-runtime.mjs';
+
+const groups = [
+  ['contained_transform','evidence_verify','file_read','proof_execute','workspace_open'],
+  ['machine_list','machine_ping','machine_revoke','machine_status'],
+  ['host_exec','host_file_read','host_file_write'],
+  ['agent_task_approve','agent_task_cancel','agent_task_events','agent_task_run','agent_task_status','agent_task_submit','agent_task_verify'],
+  ['process_session_action','process_session_list','process_session_read','process_session_start','process_session_status','process_session_terminate'],
+  ['machine_fs_delete','machine_fs_edit_exact','machine_fs_list','machine_fs_mkdir','machine_fs_move','machine_fs_read','machine_fs_stat','machine_fs_write'],
+  ['machine_search_cancel','machine_search_page','machine_search_start','machine_search_status','machine_process_list','machine_system_status'],
+  ['coding_benchmark_run','coding_command_run','coding_file_read','coding_file_write','coding_files_read','coding_receipt_verify','coding_search','coding_session_status','coding_stat','coding_symbol_definition','coding_symbol_outline','coding_symbol_references','coding_symbol_replace','coding_task_approve','coding_task_cancel','coding_task_events','coding_task_run','coding_task_status','coding_task_submit','coding_task_verify','coding_text_replace','coding_tree'],
+  ['autonomous_goal_approve','autonomous_goal_cancel','autonomous_goal_events','autonomous_goal_run','autonomous_goal_status','autonomous_goal_submit','autonomous_goal_verify','autonomous_release_gate','autonomous_session_status','native_diff_apply','native_diff_preview','native_diff_verify']
+];
+export const R34_EXPECTED_TOOLS = groups.flat().sort();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;
+}
+async function verifyMachineReceipt(policy, receiptId, operation) {
+  const verified = await verifyMachineFsReceiptFile({ policy, verifyKeyPath, receiptId });
+  if (!verified.ok || verified.signature_valid !== true || verified.operation !== operation) {
+    throw new Error(`machine-fs receipt verification failed for ${operation}`);
+  }
+  return verified;
+}
+async function verifyObservationReceipt(policy, receiptId) {
+  const verified = await verifyObservationReceiptFile({ policy, verifyKeyPath, receiptId });
+  if (!verified.ok || verified.signature_valid !== true) throw new Error('observation receipt verification failed');
+  return verified;
+}
+async function fileSha(relative) {
+  return sha256(await readFile(path.join(repoRoot, ...relative.split('/'))));
+}async function waitSearch(client, searchId) {
+  for (let attempt = 0; attempt < 200; attempt++) {
+    const status = structured(await client.callTool({ name:'machine_search_status', arguments:{ search_id:searchId } }), 'machine_search_status');
+    if (['completed','cancelled','failed'].includes(status.state)) return status;
+    await sleep(25);
+  }
+  throw new Error('machine search timeout');
+}
+async function waitProcessOutput(client, sessionId) {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const read = structured(await client.callTool({ name:'process_session_read', arguments:{ session_id:sessionId, offset:0, max_bytes:65536 } }), 'process_session_read');
+    if (Buffer.from(read.data_base64 ?? '', 'base64').toString('utf8').includes('DEADBYTE_ACTION_PING')) return read;
+    await sleep(50);
+  }
+  throw new Error('process action output timeout');
+}
+
+export async function runR34Parity(endpointText) {
+  const endpoint = new URL(endpointText);
+  if (endpoint.protocol !== 'https:') throw new Error('R34 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 client = new Client({ name:'deadbyte-r34-parity', version:'0.9.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-r34-parity-${tag}.txt`;
+  let processSession = null;
+  let targetPresent = false;
+  const machineReceipts = [];
+  const observationReceipts = [];
+  try {    await client.connect(transport);
+    const listed = await client.listTools();
+    const names = listed.tools.map(tool => tool.name).sort();
+    if (JSON.stringify(names) !== JSON.stringify(R34_EXPECTED_TOOLS)) throw new Error(`R34 catalog mismatch: ${JSON.stringify(names)}`);
+    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 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('R34 parity requires coding and autonomous standing grants');
+    }
+    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 buildScript = 'scripts/autonomous-build.ps1';
+    const testScript = 'scripts/autonomous-tests.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('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('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('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('coding test receipt invalid');
+
+    const initial = `needle-${tag}\n`;
+    const write = structured(await client.callTool({ name:'machine_fs_write', arguments:{ 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 = structured(await client.callTool({ name:'machine_fs_read', arguments:{ 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('bounded read mismatch');
+    const edit = structured(await client.callTool({ name:'machine_fs_edit_exact', arguments:{ root_id:scratchRoot, path:target, expected_sha256:write.sha256, old_string:'needle', new_string:'beta', expected_replacements:1 } }), 'machine_fs_edit_exact');
+    machineReceipts.push(edit.receipt_id);
+    await verifyMachineReceipt(policy, edit.receipt_id, 'machine_fs_edit_exact');    const stale = await client.callTool({ name:'machine_fs_edit_exact', arguments:{ root_id:scratchRoot, path:target, expected_sha256:write.sha256, old_string:'beta', new_string:'bad', expected_replacements:1 } });
+    if (stale.isError !== true) throw new Error('stale machine-fs precondition was not denied');
+
+    const searchStart = structured(await client.callTool({ name:'machine_search_start', arguments:{ root_id:scratchRoot, path:'.', pattern:tag, case_sensitive:true, max_results:20, max_files:200, max_bytes:262144, max_file_bytes:16384 } }), 'machine_search_start');
+    const searchStatus = await waitSearch(client, searchStart.search_id);
+    if (searchStatus.state !== 'completed' || !searchStatus.receipt_id) throw new Error(`search failed: ${JSON.stringify(searchStatus)}`);
+    observationReceipts.push(searchStatus.receipt_id);
+    await verifyObservationReceipt(policy, searchStatus.receipt_id);
+    const page = structured(await client.callTool({ name:'machine_search_page', arguments:{ search_id:searchStart.search_id, limit:20, cursor:null } }), 'machine_search_page');
+    if (!page.results.some(item => item.path === target)) throw new Error('search did not return parity file');
+    const system = structured(await client.callTool({ name:'machine_system_status', arguments:{} }), 'machine_system_status');
+    observationReceipts.push(system.receipt_id);
+    await verifyObservationReceipt(policy, system.receipt_id);
+    const processes = structured(await client.callTool({ name:'machine_process_list', arguments:{ limit:32, include_external:false, cursor:null } }), 'machine_process_list');
+    observationReceipts.push(processes.receipt_id);
+    await verifyObservationReceipt(policy, processes.receipt_id);
+
+    const started = structured(await client.callTool({ name:'process_session_start', arguments:{ profile_id:'ping_hold', root_id:'core', cwd:'.', args:[] } }), 'process_session_start');
+    processSession = started.session.session_id;
+    const action = structured(await client.callTool({ name:'process_session_action', arguments:{ session_id:processSession, action_id:'ping' } }), 'process_session_action');
+    const processRead = await waitProcessOutput(client, processSession);
+    const terminated = structured(await client.callTool({ name:'process_session_terminate', arguments:{ session_id:processSession } }), 'process_session_terminate');
+    if (action.action_id !== 'ping' || terminated.session.state !== 'terminated') throw new Error('owned process lifecycle failed');
+
+    const stat = structured(await client.callTool({ name:'machine_fs_stat', arguments:{ root_id:scratchRoot, path:target, hash:true } }), 'machine_fs_stat');
+    const deleted = structured(await client.callTool({ name:'machine_fs_delete', arguments:{ root_id:scratchRoot, path:target, expected_source_identity:stat.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(), tool_count:names.length,
+      strict_output_schemas:true, rdc_operation_count:0, execution_provider:'deadbyte_mcp',
+      tree_entries:tree.entries.length, bounded_read_verified:true, stale_precondition_denied:true,
+      machine_fs_receipts_verified:machineReceipts.length, observation_receipts_verified:observationReceipts.length,
+      search_result_count:page.results.length, process_session_id:processSession,
+      process_output_bytes:processRead.stream_head, process_journal_head_sha256:terminated.session.journal_head_sha256,
+      build_receipt_id:build.receipt_id, test_receipt_id:tests.receipt_id, coding_receipts_verified:2
+    };  } finally {
+    if (processSession) {
+      await client.callTool({ name:'process_session_terminate', arguments:{ session_id:processSession } }).catch(() => {});
+    }
+    if (targetPresent) {
+      try {
+        const stat = structured(await client.callTool({ name:'machine_fs_stat', arguments:{ root_id:scratchRoot, path:target, hash:false } }), 'cleanup stat');
+        if (stat.kind === 'file' && stat.identity_sha256) {
+          await client.callTool({ name:'machine_fs_delete', arguments:{ root_id:scratchRoot, path:target, expected_source_identity:stat.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-r34-parity-client.mjs https://host/mcp/path');
+  runR34Parity(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-r36-parity-client.mjs

@@ -0,0 +1,175 @@
+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';
+
+export const R36_EXPECTED_TOOLS=Object.freeze([...new Set([
+  ...R34_EXPECTED_TOOLS,
+  'coding_symbol_diagnostics','coding_symbol_implementations','coding_symbol_rename_preview'
+])].sort());
+if(R36_EXPECTED_TOOLS.length !== 76) throw new Error(`R36 full catalog identity mismatch: ${R36_EXPECTED_TOOLS.length}`);
+export const R36_COMPACT_GATEWAYS=Object.freeze(['capability_manifest','coding_inspect','machine_fs','machine_observe','process_session'].sort());
+export const R36_COMPACT_TOOL_LIMIT=42;
+
+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 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('R36 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('R36 compact process output timeout');
+}
+
+export async function runR36CompactParity(endpointText){
+  const endpoint=new URL(endpointText);
+  if(endpoint.protocol!=='https:') throw new Error('R36 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 client=new Client({name:'deadbyte-r36-compact-parity',version:'0.10.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-r36-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>R36_COMPACT_TOOL_LIMIT) throw new Error(`R36 compact catalog exceeds ${R36_COMPACT_TOOL_LIMIT}: ${names.length}`);
+    for(const name of R36_COMPACT_GATEWAYS) if(!names.includes(name)) throw new Error(`R36 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.v1'||manifest.profile!=='compact'||!Array.isArray(manifest.capabilities)||!/^[0-9a-f]{64}$/.test(String(manifest.ledger_sha256??''))) throw new Error('R36 compact capability manifest malformed');
+    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 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('R36 compact parity requires coding and autonomous standing grants');
+    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 R36 ledger match');
+
+    const buildScript='scripts/autonomous-build.ps1';
+    const testScript='scripts/release-parity-tests.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('R36 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('R36 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('R36 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('R36 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('R36 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('R36 stale machine-fs denial missing structured output');
+    if(stale.isError!==true||staleValue.status!=='denied'||!/precondition mismatch/i.test(String(staleValue.error??''))) {
+      throw new Error(`R36 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('R36 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('R36 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('R36 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('R36 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('R36 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:R36_COMPACT_GATEWAYS.length,tree_entries:tree.entries.length,coding_stat_verified:true,coding_search_result_count:search.matches.length,
+      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-r36-parity-client.mjs https://host/mcp/path');
+  runR36CompactParity(endpoint).then(result=>console.log(JSON.stringify(result,null,2))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}