deadbyte-mcp 0.8.9 → 0.9.0

package/src/provider-circuit.mjs

@@ -0,0 +1,125 @@
+import { createHash } from 'node:crypto';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const PROVIDER_ID=/^[A-Za-z0-9._:/-]{1,160}$/;
+const FAILURE_CLASSES=new Set(['timeout','transport','rate_limit','auth','invalid_response','other']);
+export const PROVIDER_CIRCUIT_STATES=Object.freeze(['CLOSED','OPEN','HALF_OPEN','UNAVAILABLE']);
+
+function isoMs(value){
+  if(typeof value!=='string') return null;
+  const ms=Date.parse(value);
+  return Number.isFinite(ms)?ms:null;
+}
+function checkedPolicy(policy){
+  const threshold=policy?.failure_threshold;
+  const openMs=policy?.open_ms;
+  const probeLimit=policy?.half_open_probe_limit;
+  if(!Number.isInteger(threshold)||threshold<1||threshold>32) throw new Error('provider circuit failure_threshold invalid');
+  if(!Number.isInteger(openMs)||openMs<100||openMs>3_600_000) throw new Error('provider circuit open_ms invalid');
+  if(!Number.isInteger(probeLimit)||probeLimit<1||probeLimit>8) throw new Error('provider circuit half_open_probe_limit invalid');
+  return {failure_threshold:threshold,open_ms:openMs,half_open_probe_limit:probeLimit};
+}
+function publicState(state){
+  return Object.freeze({
+    state:state.state,
+    failure_count:state.failure_count,
+    opened_at_utc:state.opened_at_utc,
+    next_probe_at_utc:state.next_probe_at_utc,
+    last_success_at_utc:state.last_success_at_utc,
+    half_open_probes:state.half_open_probes
+  });
+}
+function unavailable(){
+  return publicState({state:'UNAVAILABLE',failure_count:0,opened_at_utc:null,next_probe_at_utc:null,last_success_at_utc:null,half_open_probes:0});
+}
+function advanceTime(state,ms){
+  if(state.state==='OPEN'&&state.next_probe_ms!==null&&ms>=state.next_probe_ms){
+    state.state='HALF_OPEN';
+    state.half_open_probes=0;
+  }
+}
+function openAt(state,ms,policy){
+  state.state='OPEN';
+  state.failure_count=Math.max(policy.failure_threshold,state.failure_count);
+  state.opened_at_utc=new Date(ms).toISOString();
+  state.next_probe_ms=ms+policy.open_ms;
+  state.next_probe_at_utc=new Date(state.next_probe_ms).toISOString();
+  state.half_open_probes=0;
+}
+
+export function providerCircuitId(planner){
+  if(planner?.backend!=='openai_compatible'||typeof planner.endpoint!=='string'||typeof planner.model!=='string') {
+    throw new Error('provider circuit planner identity invalid');
+  }
+  const digest=createHash('sha256').update(Buffer.from(`${planner.endpoint}\0${planner.model}`,'utf8')).digest('hex');
+  return `openai_compatible:${digest}`;
+}
+
+export function classifyProviderFailure(error){
+  const name=String(error?.name??'').toLowerCase();
+  const text=String(error?.message??error??'').toLowerCase();
+  if(name==='aborterror'||/\b(?:timed?\s*out|timeout|aborted)\b/.test(text)) return 'timeout';
+  if(/(?:http\s*429|rate[ _-]?limit|too many requests)/.test(text)) return 'rate_limit';
+  if(/(?:http\s*(?:401|403)|unauthori[sz]ed|forbidden|api key|authentication)/.test(text)) return 'auth';
+  if(/(?:not json|invalid json|missing choices|invalid response|response.*(?:schema|contract|content))/.test(text)) return 'invalid_response';
+  if(/(?:econnreset|econnrefused|enotfound|fetch failed|network|socket|transport|connection)/.test(text)) return 'transport';
+  return 'other';
+}
+
+export function deriveCircuit(events,providerId,rawPolicy,observedAtUtc){
+  if(typeof providerId!=='string'||!PROVIDER_ID.test(providerId)) throw new Error('provider circuit provider_id invalid');
+  if(!Array.isArray(events)) throw new Error('provider circuit events invalid');
+  const policy=checkedPolicy(rawPolicy);
+  const observedMs=isoMs(observedAtUtc);
+  if(observedMs===null) throw new Error('provider circuit observed time invalid');
+  const state={state:'CLOSED',failure_count:0,opened_at_utc:null,next_probe_at_utc:null,next_probe_ms:null,last_success_at_utc:null,half_open_probes:0};
+  for(const event of events){
+    const eventProvider=event?.payload?.provider_id;
+    if(eventProvider!==providerId) continue;
+    if(!HEX64.test(event?.event_sha256??'')) return unavailable();
+    const ms=isoMs(event?.created_at_utc);
+    if(ms===null||ms>observedMs) return unavailable();
+    advanceTime(state,ms);
+    if(event.type==='provider_call_failed'){
+      if(!FAILURE_CLASSES.has(event.payload?.failure_class)) return unavailable();
+      if(state.state==='HALF_OPEN'){
+        state.failure_count=policy.failure_threshold;
+        openAt(state,ms,policy);
+      }else if(state.state==='OPEN'){
+        return unavailable();
+      }else{
+        state.failure_count+=1;
+        if(state.failure_count>=policy.failure_threshold) openAt(state,ms,policy);
+      }
+    }else if(event.type==='provider_call_succeeded'){
+      if(state.state==='OPEN') return unavailable();
+      state.state='CLOSED';
+      state.failure_count=0;
+      state.opened_at_utc=null;
+      state.next_probe_at_utc=null;
+      state.next_probe_ms=null;
+      state.last_success_at_utc=new Date(ms).toISOString();
+      state.half_open_probes=0;
+    }else if(event.type==='provider_probe_started'){
+      if(state.state!=='HALF_OPEN'||state.half_open_probes>=policy.half_open_probe_limit) return unavailable();
+      state.half_open_probes+=1;
+    }else if(String(event.type??'').startsWith('provider_')){
+      return unavailable();
+    }
+  }
+  advanceTime(state,observedMs);
+  return publicState(state);
+}
+
+export function providerCallDisposition(circuit){
+  if(!circuit||!PROVIDER_CIRCUIT_STATES.includes(circuit.state)) return {allowed:false,probe:false,reason:'circuit_unavailable'};
+  if(circuit.state==='UNAVAILABLE') return {allowed:false,probe:false,reason:'circuit_unavailable'};
+  if(circuit.state==='OPEN') return {allowed:false,probe:false,reason:'circuit_open'};
+  if(circuit.state==='HALF_OPEN'){
+    if(!Number.isInteger(circuit.half_open_probes)||circuit.half_open_probes<0) return {allowed:false,probe:false,reason:'circuit_unavailable'};
+    return circuit.half_open_probes===0
+      ? {allowed:true,probe:true,reason:'half_open_probe'}
+      : {allowed:false,probe:false,reason:'half_open_probe_limit'};
+  }
+  return {allowed:true,probe:false,reason:'circuit_closed'};
+}

package/src/release-generation.mjs

@@ -101,8 +101,8 @@ async function rebindProcessPolicy(raw,{developmentRoot,stateRoot,releaseRoot}){
   return policy;
 }
 
-function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,codingPolicyPath,autonomousPolicyPath,hostPolicyPath}){
-  const bridge=currentConfig.Bridge??{},cloud=currentConfig.Cloud??{};
+function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPolicyPath,codingPolicyPath,semanticConfigPath,semanticConfigSha256,autonomousPolicyPath,hostPolicyPath}){
+  const supervisor=currentConfig.Supervisor??{},bridge=currentConfig.Bridge??{},cloud=currentConfig.Cloud??{};
   return [
     '@{',"    Schema = 'deadbyte.controller.v1'",`    CoreRoot = ${psQuote(coreRoot)}`,
     `    WorkspaceRoot = ${psQuote(workspaceRoot)}`,
@@ -114,9 +114,22 @@ function renderControllerConfig({currentConfig,coreRoot,workspaceRoot,processPol
     `    MachineFsRuntimeEnabled = ${psBool(currentConfig.MachineFsRuntimeEnabled)}`,
     `    ObservationRuntimeEnabled = ${psBool(currentConfig.ObservationRuntimeEnabled)}`,
     `    CodingPolicyFile = ${psQuote(codingPolicyPath)}`,
+    `    SemanticLspConfigFile = ${psQuote(semanticConfigPath??'')}`,
+    `    SemanticLspConfigSha256 = ${psQuote(semanticConfigSha256??'')}`,
     `    AutonomousRuntimeEnabled = ${psBool(currentConfig.AutonomousRuntimeEnabled)}`,
     `    AutonomousPolicyFile = ${psQuote(autonomousPolicyPath)}`,
+    `    AutonomousSupervisorEnabled = ${psBool(currentConfig.AutonomousSupervisorEnabled===true)}`,
     `    HostPolicyFile = ${psQuote(hostPolicyPath??'')}`,
+    ...(currentConfig.AutonomousSupervisorEnabled===true?[
+      '    Supervisor = @{',
+      `        FilePath = ${psQuote(supervisor.FilePath)}`,
+      `        FileSha256 = ${psQuote(supervisor.FileSha256)}`,
+      `        Arguments = ${psQuote(supervisor.Arguments)}`,
+      `        WorkingDirectory = ${psQuote(supervisor.WorkingDirectory)}`,
+      `        ScriptPath = ${psQuote(supervisor.ScriptPath)}`,
+      `        ScriptSha256 = ${psQuote(supervisor.ScriptSha256)}`,
+      '    }'
+    ]:[]),
     '    Bridge = @{',
     `        FilePath = ${psQuote(bridge.FilePath)}`,
     `        FileSha256 = ${psQuote(bridge.FileSha256)}`,
@@ -147,6 +160,13 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   if(typeof releaseId!=='string'||!/^[A-Za-z0-9._-]{1,96}$/.test(releaseId)) throw new Error('generation release id invalid');
   if(typeof currentConfig?.Bridge?.FileSha256!=='string'||!HEX64.test(currentConfig.Bridge.FileSha256)) throw new Error('generation Bridge FileSha256 invalid');
   if(typeof currentConfig?.Cloud?.FileSha256!=='string'||!HEX64.test(currentConfig.Cloud.FileSha256)) throw new Error('generation Cloud FileSha256 invalid');
+  if(currentConfig.AutonomousSupervisorEnabled===true){
+    if(currentConfig.AutonomousRuntimeEnabled!==true) throw new Error('generation autonomous supervisor requires AutonomousRuntimeEnabled');
+    const supervisor=currentConfig.Supervisor;
+    if(!supervisor||typeof supervisor!=='object') throw new Error('generation Supervisor launch specification missing');
+    for(const key of ['FilePath','Arguments','WorkingDirectory','ScriptPath']) if(typeof supervisor[key]!=='string'||supervisor[key].length<1) throw new Error(`generation Supervisor ${key} invalid`);
+    if(!HEX64.test(String(supervisor.FileSha256??''))||!HEX64.test(String(supervisor.ScriptSha256??''))) throw new Error('generation Supervisor hash invalid');
+  }
   if(currentConfig.Cloud.Transport!==undefined){
     const transport=String(currentConfig.Cloud.Transport);
     const expectedDependencies=transport==='deadbyte.named-tunnel.v1'?3:transport==='deadbyte.named-tunnel.v2'?2:null;
@@ -167,6 +187,20 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   }
   if(typeof currentConfig?.Bridge?.ScriptPath!=='string'||!path.isAbsolute(currentConfig.Bridge.ScriptPath)) throw new Error('generation Bridge ScriptPath must be absolute');
   if(typeof currentConfig?.Bridge?.ScriptSha256!=='string'||!HEX64.test(currentConfig.Bridge.ScriptSha256)) throw new Error('generation Bridge ScriptSha256 invalid');
+  const semanticSource=String(currentConfig.SemanticLspConfigFile??'');
+  const semanticExpected=String(currentConfig.SemanticLspConfigSha256??'').toLowerCase();
+  if(Boolean(semanticSource)!==Boolean(semanticExpected)) throw new Error('generation semantic LSP config path/SHA must be supplied together');
+  let semanticBytes=null,semanticConfigSha256=null;
+  if(semanticSource){
+    if(currentConfig.CodingRuntimeEnabled!==true) throw new Error('generation semantic LSP config requires CodingRuntimeEnabled');
+    if(!path.isAbsolute(semanticSource)) throw new Error('generation semantic LSP config path must be absolute');
+    if(!HEX64.test(semanticExpected)) throw new Error('generation semantic LSP config SHA-256 invalid');
+    const semanticStat=await lstat(semanticSource);
+    if(!semanticStat.isFile()||semanticStat.isSymbolicLink()) throw new Error('generation semantic LSP config source must be a regular file');
+    semanticBytes=await readFile(semanticSource);
+    semanticConfigSha256=sha256(semanticBytes);
+    if(semanticConfigSha256!==semanticExpected) throw new Error(`generation semantic LSP config SHA-256 mismatch: expected ${semanticExpected}, found ${semanticConfigSha256}`);
+  }
   const parityScratchRoot=path.join(state,'runtime','r33-parity-scratch');
   await mkdir(parityScratchRoot,{recursive:true});
   const parityScratchStat=await lstat(parityScratchRoot);
@@ -188,10 +222,13 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     machine_fs_runtime_enabled:currentConfig.MachineFsRuntimeEnabled===true,
     observation_runtime_enabled:currentConfig.ObservationRuntimeEnabled===true,
     autonomous_runtime_enabled:currentConfig.AutonomousRuntimeEnabled===true,
+    autonomous_supervisor_enabled:currentConfig.AutonomousSupervisorEnabled===true,
+    supervisor:currentConfig.AutonomousSupervisorEnabled===true?(currentConfig.Supervisor??{}):null,
     bridge:currentConfig.Bridge??{},cloud:currentConfig.Cloud??{},
     local_ready_uri:currentConfig.LocalReadyUri??'',url_regex:currentConfig.UrlRegex??'',
     mcp_url_file:currentConfig.McpUrlFile??'',mcp_url_file_sha256:currentConfig.McpUrlFileSha256??'',mcp_path_file:currentConfig.McpPathFile??'',
     start_timeout_seconds:Number(currentConfig.StartTimeoutSeconds??30),probe_timeout_seconds:Number(currentConfig.ProbeTimeoutSeconds??3),
+    semantic_lsp_config_sha256:semanticConfigSha256,
     process_policy_sha256:processBytes?sha256(processBytes):null,
     coding_policy_sha256:sha256(codingBytes),autonomous_policy_sha256:sha256(autonomousBytes),host_policy_sha256:hostBytes?sha256(hostBytes):null
   });
@@ -201,20 +238,22 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
   const generationRoot=path.join(generationsRoot,generationId);
   const processPath=processBytes?path.join(generationRoot,'process-policy.json'):null;
   const codingPath=path.join(generationRoot,'coding-policy.json');
+  const semanticPath=semanticBytes?path.join(generationRoot,'semantic-lsp-config.json'):null;
   const autonomousPath=path.join(generationRoot,'autonomous-policy.json');
   const hostPath=host?path.join(generationRoot,'host-policy.json'):null;
   const configPath=path.join(generationRoot,'controller-config.psd1');
   const files=new Map([
     ['coding-policy.json',codingBytes],
     ['autonomous-policy.json',autonomousBytes],
-    ['controller-config.psd1',Buffer.from(renderControllerConfig({currentConfig,coreRoot:release,workspaceRoot:workspace,processPolicyPath:processPath,codingPolicyPath:codingPath,autonomousPolicyPath:autonomousPath,hostPolicyPath:hostPath}),'utf8')]
+    ['controller-config.psd1',Buffer.from(renderControllerConfig({currentConfig,coreRoot:release,workspaceRoot:workspace,processPolicyPath:processPath,codingPolicyPath:codingPath,semanticConfigPath:semanticPath,semanticConfigSha256,autonomousPolicyPath:autonomousPath,hostPolicyPath:hostPath}),'utf8')]
   ]);
+  if(semanticBytes) files.set('semantic-lsp-config.json',semanticBytes);
   if(processBytes) files.set('process-policy.json',processBytes);
   if(hostBytes) files.set('host-policy.json',hostBytes);
   const manifestBytes=generationManifest(files),manifestSha256=sha256(manifestBytes);
   if(existsSync(generationRoot)){
     const verified=await verifyGenerationBundle(generationRoot,manifestSha256);
-    return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:true,...verified};
+    return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:true,...verified};
   }
   await mkdir(generationsRoot,{recursive:true});
   const staging=path.join(generationsRoot,`.staging-${generationId}-${process.pid}-${randomBytes(4).toString('hex')}`);
@@ -229,5 +268,5 @@ export async function createGenerationBundle({stateRoot,releaseRoot,developmentR
     throw error;
   }
   const verified=await verifyGenerationBundle(generationRoot,manifestSha256);
-  return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:false,...verified};
+  return {generation_id:generationId,generation_seed_sha256:generationSeed,generation_root:generationRoot,generation_manifest_sha256:manifestSha256,config_path:configPath,process_policy_path:processPath,coding_policy_path:codingPath,semantic_config_path:semanticPath,autonomous_policy_path:autonomousPath,host_policy_path:hostPath,adopted:false,...verified};
 }

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 { R34_EXPECTED_TOOLS } from './remote-mcp-r34-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,35 +61,36 @@ 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',
@@ -88,7 +113,7 @@ 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 (JSON.stringify(names) !== JSON.stringify(R34_EXPECTED_TOOLS)) throw new Error(`R34 public 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`);
@@ -105,12 +130,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_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'
 ];
 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-r33-parity-client.mjs

@@ -67,7 +67,7 @@ export async function runR33Parity(endpointText) {
   if (endpoint.protocol !== 'https:') throw new Error('R33 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-r33-parity', version:'0.8.9' },
+  const client = new Client({ name:'deadbyte-r33-parity', version:'0.8.10' },
     { versionNegotiation:{ mode:{ pin:'2026-07-28' } } });
   const transport = new StreamableHTTPClientTransport(endpoint);
   const tag = randomBytes(8).toString('hex');

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-smoke-client.mjs

@@ -28,8 +28,9 @@ const agentTools = [
   'agent_task_status', 'agent_task_submit', 'agent_task_verify'
 ];
 const codingTools = [
-  'coding_benchmark_run', 'coding_command_run', 'coding_file_read', 'coding_file_write',
+  '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'
 ];