deadbyte-mcp 0.8.10 → 0.10.0

package/src/autonomous-runtime.mjs

@@ -4,8 +4,14 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { loadPrivateSigningKey, loadPublicVerifyKey } from './trust.mjs';
 import { assertAutonomousArmed, autonomousSessionStatus } from './autonomous-policy.mjs';
-import { buildPlannerPrompt, parsePlannerDecision, requestProviderDecision } from './autonomous-planner.mjs';
+import { buildPlannerPrompt, parsePlannerDecision, parseR34PlannerDecision, requestProviderDecision } from './autonomous-planner.mjs';
+import { actionIdentity, reconcileStartedAction } from './autonomous-action-reconcile.mjs';
+import { createPlan, replanPlan, completePlanStep, planIsComplete as r34PlanIsComplete } from './autonomous-plan.mjs';
+import { deriveLoopState, repairFingerprint } from './autonomous-loop-state.mjs';
+import { judgeProgress, stallDisposition } from './autonomous-progress.mjs';
+import { classifyProviderFailure, deriveCircuit, providerCallDisposition, providerCircuitId } from './provider-circuit.mjs';
 import { verifyObservationReceiptFile } from './observation-runtime.mjs';
+import { R36_CAPABILITY_LEDGER } from './capability-ledger.mjs';
 
 export const AUTONOMOUS_GOAL_SCHEMA = 'deadbyte.autonomous-goal.v1';
 export const AUTONOMOUS_EVENT_SCHEMA = 'deadbyte.autonomous-event.v1';
@@ -196,7 +202,8 @@ function profileOutcome(profile, checked) {
     ...(profile.kind === 'command' ? { exit_code:receipt.exit_code, timed_out:receipt.timed_out, elapsed_ms:receipt.elapsed_ms } :
       { median_ms:receipt.median_ms, p95_ms:receipt.p95_ms, regression_pct:receipt.regression_pct, verdict:receipt.verdict }) } };
 }
-async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch, policy, codingRuntime, signingKeyPath }) {
+async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch, policy, codingRuntime, signingKeyPath,
+  r34ResumePhase = null }) {
   const profile = policy.profiles[profileId];
   if (!profile) throw new Error(`autonomous profile '${profileId}' not found`);
   const prior = [...events].reverse().find(event => event.type === 'profile_completed' && event.payload?.action_key === actionKey && event.payload?.profile_id === profileId);
@@ -204,14 +211,38 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
   const receiptId = profileReceiptId(goalId, actionKey, profileId);
   const requestSha256 = profileRequestSha(codingRuntime, profile);
   const started = [...events].reverse().find(event => event.type === 'profile_started' && event.payload?.action_key === actionKey && event.payload?.profile_id === profileId);
+  async function pauseR34Ambiguous(detail) {
+    if (!r34ResumePhase) return null;
+    if (!events.some(event => event.type === 'waiting_entered' && event.payload?.action_key === actionKey)) {
+      await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{
+        reason:'ambiguous_interrupted_action',requires_approval:true,resume_phase:r34ResumePhase,
+        action_key:actionKey,profile_id:profileId,detail:truncated(detail,512)
+      });
+    }
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+      reason:'ambiguous_interrupted_action',action_key:actionKey,profile_id:profileId
+    });
+    return {status:'paused',reason:'ambiguous_interrupted_action',observation:null,existing:false};
+  }
   if (started) {
     const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
     if (!checked.ok) {
+      const r34Paused=await pauseR34Ambiguous(checked.reason ?? 'profile receipt verification failed');
+      if (r34Paused) return r34Paused;
       await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'interrupted_profile_without_receipt', profile_id:profileId, action_key:actionKey });
       return { status:'paused', observation:null, existing:false };
     }
-    if (checked.request_sha256 !== requestSha256) throw new Error(`profile '${profileId}' recovered receipt request mismatch`);
-    const outcome = profileOutcome(profile,checked); if (!outcome.valid) throw new Error(outcome.reason);
+    if (checked.request_sha256 !== requestSha256) {
+      const r34Paused=await pauseR34Ambiguous(`profile '${profileId}' recovered receipt request mismatch`);
+      if (r34Paused) return r34Paused;
+      throw new Error(`profile '${profileId}' recovered receipt request mismatch`);
+    }
+    const outcome = profileOutcome(profile,checked);
+    if (!outcome.valid) {
+      const r34Paused=await pauseR34Ambiguous(outcome.reason);
+      if (r34Paused) return r34Paused;
+      throw new Error(outcome.reason);
+    }
     const payload = { action_key:actionKey, profile_id:profileId, mutation_epoch:epoch, passed:outcome.passed,
       recovered:true, required_for_release:profile.required_for_release, run_after_mutation:profile.run_after_mutation, ...outcome.payload };
     await appendEvent(ctx,events,signingKeyPath,'profile_completed',payload);
@@ -232,6 +263,8 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
   } catch (error) {
     const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
     if (!checked.ok) {
+      const r34Paused=await pauseR34Ambiguous(checked.reason ?? error);
+      if (r34Paused) return r34Paused;
       await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'profile_execution_without_receipt', profile_id:profileId,
         action_key:actionKey, detail:truncated(error) });
       return { status:'paused', observation:null, existing:false };
@@ -240,9 +273,16 @@ async function executeProfile({ ctx, events, goalId, actionKey, profileId, epoch
   }
   const checked = await codingRuntime.verifyReceiptDetailed(receiptId);
   if (!checked.ok || checked.request_sha256 !== requestSha256 || (result && result.receipt_sha256 !== checked.receipt_sha256)) {
+    const r34Paused=await pauseR34Ambiguous(`profile '${profileId}' post-execution receipt verification failed`);
+    if (r34Paused) return r34Paused;
     throw new Error(`profile '${profileId}' post-execution receipt verification failed`);
   }
-  const outcome = profileOutcome(profile,checked); if (!outcome.valid) throw new Error(outcome.reason);
+  const outcome = profileOutcome(profile,checked);
+  if (!outcome.valid) {
+    const r34Paused=await pauseR34Ambiguous(outcome.reason);
+    if (r34Paused) return r34Paused;
+    throw new Error(outcome.reason);
+  }
   const payload = { action_key:actionKey, profile_id:profileId, mutation_epoch:epoch, passed:outcome.passed,
     recovered:result === null, required_for_release:profile.required_for_release,
     run_after_mutation:profile.run_after_mutation,
@@ -279,17 +319,38 @@ function normalizeGoal(policy, { submissionId, rootId, title = '', goal, accepta
   return Object.freeze({ ...body, goal_sha256:sha256Object(body) });
 }
 
-async function plannerView(goal, state, codingRuntime) {
+function configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime}) {
+  const plannerReachable=id => id === 'coding.stat' || id === 'coding.search' || id === 'coding.files_read' ||
+    id.startsWith('semantic.') || id.startsWith('native_diff.') || id.startsWith('process.') ||
+    id.startsWith('machine_fs.') || id.startsWith('observation.') || id === 'autonomous.release_gate';
+  const runtimeEnabled=entry => {
+    if (entry.runtime_flag === 'DEADBYTE_CODING_RUNTIME' || entry.runtime_flag === 'DEADBYTE_AUTONOMOUS_RUNTIME') return true;
+    if (entry.runtime_flag === 'DEADBYTE_MACHINE_FS_RUNTIME') return Boolean(machineFsRuntime);
+    if (entry.runtime_flag === 'DEADBYTE_PROCESS_RUNTIME') return Boolean(processRuntime);
+    if (entry.runtime_flag === 'DEADBYTE_OBSERVATION_RUNTIME') return Boolean(observationRuntime);
+    return entry.runtime_flag === null;
+  };
+  const entries=R36_CAPABILITY_LEDGER.entries
+    .filter(entry=>entry.production && !entry.host_only && plannerReachable(entry.id) && runtimeEnabled(entry))
+    .filter(entry=>!entry.id.startsWith('semantic.') || Boolean(semanticRuntime))
+    .map(entry=>({id:entry.id,authority:entry.authority,mutating:entry.mutating,full_tool:entry.full_tool,
+      compact_tool:entry.compact_tool,compact_op:entry.compact_op}));
+  return Object.freeze({schema:'deadbyte.capability-manifest.v1',ledger_sha256:R36_CAPABILITY_LEDGER.ledger_sha256,
+    entries:Object.freeze(entries)});
+}
+
+async function plannerView(goal, state, codingRuntime, capabilityManifest) {
   const tree = await codingRuntime.tree({ rootId:goal.root_id, path:'.', maxDepth:4, maxEntries:600 });
   return { mutation_epoch:state.mutation_epoch, planner_round:state.planner_round, tree:tree.entries,
     contexts:state.contexts.slice(-16), observations:state.observations.slice(-24), active_plan:state.active_plan,
+    capabilities:capabilityManifest,
     recent_decisions:state.decisions.slice(-8).map(item => ({ planner_round:item.planner_round,
       action:item.decision?.action, summary:item.decision?.summary })) };
 }
 function requestIdFor(goalId, plannerRound, journalHead) {
   return sha256Object({ schema:'deadbyte.autonomous-planner-request.v1', goal_id:goalId, planner_round:plannerRound, journal_head_sha256:journalHead });
 }
-async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, signingKeyPath) {
+async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, capabilityManifest, signingKeyPath) {
   if (state.pending_request) return state.pending_request;
   const round = state.planner_round + 1;
   if (round > goal.max_iterations) {
@@ -300,7 +361,7 @@ async function requestPlanner(ctx, goal, events, state, policy, codingRuntime, s
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'wall_time_limit', max_wall_ms:policy.limits.max_wall_ms });
     return null;
   }
-  const view = await plannerView(goal,state,codingRuntime);
+  const view = await plannerView(goal,state,codingRuntime,capabilityManifest);
   let prompt = buildPlannerPrompt({ goal:{ title:goal.title, goal:goal.goal, acceptance:goal.acceptance }, policy, view });
   const repair = [...(state.planner_rejections ?? [])].reverse().find(item => item.planner_round === round) ?? null;
   if (repair) {
@@ -337,15 +398,117 @@ function validatePlanTransition(previous, next) {
 function planIsComplete(plan) {
   return Boolean(plan?.steps?.length) && plan.steps.every(step => step.status === 'completed');
 }
-async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath, plannerResponse }) {
+function parseRuntimePlannerDecision(rawText,policy) {
+  let candidate;
+  try { candidate = JSON.parse(rawText); }
+  catch { return parsePlannerDecision(rawText,policy); }
+  return candidate?.schema === 'deadbyte.autonomous-decision.v2'
+    ? parseR34PlannerDecision(rawText,policy)
+    : parsePlannerDecision(rawText,policy);
+}
+function hasR34Loop(events) {
+  return events.some(event => event.type === 'plan_created' || event.type === 'plan_replanned' ||
+    event.type === 'waiting_entered' || event.payload?.decision?.schema === 'deadbyte.autonomous-decision.v2');
+}
+function loopStateOrNull(goal,events) {
+  return hasR34Loop(events) ? deriveLoopState(goal,events) : null;
+}
+function legacyPublicLoopPhase(phase) {
+  return ({PLAN:'PLANNING',INSPECT:'INSPECTING',ACT:'ACTING',VERIFY:'VERIFYING',CRITIC:'REPLANNING',
+    REPAIR:'REPLANNING',RELEASE:'VERIFYING',WAITING:'WAITING',SUCCEEDED:'COMPLETE',FAILED:'WAITING'})[phase] ?? 'WAITING';
+}
+function publicLoopState(loop) {
+  if (!loop) return null;
+  const currentStep=loop.current_step ? {
+    step_id:loop.current_step.step_id,intent:loop.current_step.intent,status:loop.current_step.status
+  } : null;
+  const progress=loop.progress ? {
+    verdict:loop.progress.verdict,score:loop.progress.score,
+    reason_codes:[...(loop.progress.reason_codes ?? [])],fingerprint:loop.progress.fingerprint
+  } : null;
+  const actionKind=loop.pending_action?.action?.kind ?? loop.pending_action?.kind ?? null;
+  const pendingAction=loop.pending_action && actionKind ? {
+    action_id:loop.pending_action.action_id,request_sha256:loop.pending_action.request_sha256,kind:actionKind
+  } : null;
+  return {
+    schema:'deadbyte.autonomous-loop-state.v1',phase:legacyPublicLoopPhase(loop.phase),plan_id:loop.plan_id,plan_version:loop.plan_version,
+    current_step:currentStep,replan_count:loop.replan_count,progress,
+    pending_action:pendingAction,pending_approval:loop.pending_approval,wait_reason:loop.wait_reason
+  };
+}
+function withLoopResult(goal,events,result) {
+  const loop=publicLoopState(loopStateOrNull(goal,events));
+  return loop ? {...result,loop} : result;
+}
+function providerCircuitSnapshot(policy,events,observedAtUtc=new Date().toISOString()) {
+  if (policy.planner.backend !== 'openai_compatible') return null;
+  return deriveCircuit(events,providerCircuitId(policy.planner),policy.planner.circuit,observedAtUtc);
+}
+async function enterProviderCircuitWait({ctx,events,goal,policy,signingKeyPath,reason,circuit}) {
+  const loop=deriveLoopState(goal,events);
+  if (loop.phase !== 'WAITING') {
+    await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{
+      reason,requires_approval:false,resume_phase:loop.phase,
+      provider_id:providerCircuitId(policy.planner),circuit_state:circuit.state,
+      next_probe_at_utc:circuit.next_probe_at_utc
+    });
+  }
+  await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+    reason,provider_id:providerCircuitId(policy.planner),circuit_state:circuit.state,
+    next_probe_at_utc:circuit.next_probe_at_utc
+  });
+  return {status:'paused',reason,circuit};
+}
+async function requestProviderWithCircuit({ctx,events,goal,policy,pending,signingKeyPath}) {
+  const providerId=providerCircuitId(policy.planner);
+  let circuit=providerCircuitSnapshot(policy,events);
+  let disposition=providerCallDisposition(circuit);
+  if (!disposition.allowed && disposition.reason==='half_open_probe_limit') {
+    await appendEvent(ctx,events,signingKeyPath,'provider_call_failed',{
+      provider_id:providerId,request_id:pending.request_id,failure_class:'transport',interrupted_probe:true
+    });
+    circuit=providerCircuitSnapshot(policy,events);
+    disposition=providerCallDisposition(circuit);
+  }
+  if (!disposition.allowed) {
+    const reason=disposition.reason==='circuit_unavailable'?'provider_circuit_unavailable':'provider_circuit_open';
+    return {waiting:await enterProviderCircuitWait({ctx,events,goal,policy,signingKeyPath,reason,circuit})};
+  }
+  if (disposition.probe) {
+    await appendEvent(ctx,events,signingKeyPath,'provider_probe_started',{
+      provider_id:providerId,request_id:pending.request_id
+    });
+  }
+  try {
+    const response=await requestProviderDecision(policy,pending.prompt);
+    await appendEvent(ctx,events,signingKeyPath,'provider_call_succeeded',{
+      provider_id:providerId,request_id:pending.request_id,probe:disposition.probe===true
+    });
+    return {response};
+  } catch (error) {
+    await appendEvent(ctx,events,signingKeyPath,'provider_call_failed',{
+      provider_id:providerId,request_id:pending.request_id,failure_class:classifyProviderFailure(error),
+      probe:disposition.probe===true
+    });
+    circuit=providerCircuitSnapshot(policy,events);
+    if (circuit.state==='OPEN'||circuit.state==='UNAVAILABLE') {
+      const reason=circuit.state==='UNAVAILABLE'?'provider_circuit_unavailable':'provider_circuit_open';
+      return {waiting:await enterProviderCircuitWait({ctx,events,goal,policy,signingKeyPath,reason,circuit})};
+    }
+    throw error;
+  }
+}
+async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingRuntime, capabilityManifest, signingKeyPath, plannerResponse }) {
   let currentState = state;
-  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,signingKeyPath);
+  let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,signingKeyPath);
   if (!pending) return null;
   let suppliedResponse = plannerResponse;
   while (pending) {
     let response;
     if (policy.planner.backend === 'openai_compatible') {
-      response = await requestProviderDecision(policy,pending.prompt);
+      const provider=await requestProviderWithCircuit({ctx,events,goal,policy,pending,signingKeyPath});
+      if (provider.waiting) return {needs_planner:false,rejected:false,paused:true,provider_waiting:true};
+      response=provider.response;
     } else {
       if (!suppliedResponse) return { needs_planner:true, request:pending };
       if (suppliedResponse.request_id !== pending.request_id) throw new Error('planner response request_id mismatch');
@@ -357,8 +520,8 @@ async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingR
     }
     let decision;
     try {
-      decision = parsePlannerDecision(response.raw_text,policy);
-      validatePlanTransition(currentState.active_plan,decision.plan);
+      decision = parseRuntimePlannerDecision(response.raw_text,policy);
+      if (decision.schema !== 'deadbyte.autonomous-decision.v2') validatePlanTransition(currentState.active_plan,decision.plan);
     } catch (error) {
       const reason = truncated(error,512);
       const attempt = 1 + events.filter(event => event.type === 'planner_rejected' &&
@@ -376,7 +539,7 @@ async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingR
         return { needs_planner:false, rejected:true, paused:true };
       }
       currentState = deriveState(goal,events);
-      pending = await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,signingKeyPath);
+      pending = await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,capabilityManifest,signingKeyPath);
       if (!pending) return null;
       if (policy.planner.backend === 'client_sampling') return { needs_planner:true, request:pending };
       continue;
@@ -405,7 +568,9 @@ async function executeInspect({ ctx, events, goal, decisionEvent, decision, codi
     const read = await codingRuntime.fileRead({ rootId:goal.root_id, relativePath:item.path, encoding:'utf8' });
     const bytes = Buffer.byteLength(read.content,'utf8');
     if (bytes > item.max_bytes) throw new Error(`planner inspect '${item.path}' exceeds requested max_bytes`);
-    contexts.push({ path:item.path, sha256:read.sha256, bytes:read.bytes, content:read.content });
+    contexts.push({ path:item.path, sha256:read.sha256, bytes:read.bytes, content:read.content,
+      observed_at_utc:new Date().toISOString(), trust_class:'workspace_read',
+      relevance_epoch:Number.isInteger(decisionEvent.mutation_epoch) ? decisionEvent.mutation_epoch : 0 });
   }
   await appendEvent(ctx,events,signingKeyPath,'inspect_completed',{
     decision_event_sha256:decisionEvent.event_sha256, contexts
@@ -414,6 +579,18 @@ async function executeInspect({ ctx, events, goal, decisionEvent, decision, codi
 }
 
 const DELEGATED_MUTATIONS = new Set(['process_start','process_action','process_terminate','observation_search_cancel']);
+const CAPABILITY_BY_ACTION=Object.freeze({
+  search:'coding.search',stat:'coding.stat',multi_read:'coding.files_read',
+  semantic_outline:'semantic.outline',semantic_definition:'semantic.definition',semantic_references:'semantic.references',
+  semantic_diagnostics:'semantic.diagnostics',semantic_implementations:'semantic.implementations',semantic_rename_preview:'semantic.rename_preview',
+  native_diff_apply:'native_diff.apply',native_diff_verify:'native_diff.verify',
+  process_start:'process.start',process_read:'process.read',process_status:'process.status',process_list:'process.list',process_action:'process.action',process_terminate:'process.terminate',
+  machine_fs_stat:'machine_fs.stat',machine_fs_list:'machine_fs.list',machine_fs_read:'machine_fs.read',machine_fs_mkdir:'machine_fs.mkdir',machine_fs_move:'machine_fs.move',machine_fs_delete:'machine_fs.delete',
+  machine_stat:'machine_fs.stat',machine_list:'machine_fs.list',machine_read:'machine_fs.read',
+  observation_search_start:'observation.search_start',observation_search_status:'observation.search_status',observation_search_page:'observation.search_page',observation_search_cancel:'observation.search_cancel',
+  observation_process_list:'observation.process_list',observation_system_status:'observation.system_status'
+});
+function capabilityIdForOperation(operation){return CAPABILITY_BY_ACTION[operation?.kind]??null;}
 function assertDelegatedIdentity(events, operation) {
   if (['observation_search_status','observation_search_page','observation_search_cancel'].includes(operation.kind)) {
     const owned = events.some(event => event.type === 'delegated_action_completed' &&
@@ -427,8 +604,45 @@ function assertDelegatedIdentity(events, operation) {
   }
 }
 async function invokeDelegatedOperation(goal, operation, runtimes) {
-  const { machineFsRuntime, observationRuntime, processRuntime } = runtimes;
+  const { codingRuntime, semanticRuntime, nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime } = runtimes;
   switch (operation.kind) {
+    case 'stat':
+      return codingRuntime.stat({rootId:goal.root_id,relativePath:operation.path,hash:operation.hash});
+    case 'search':
+      return codingRuntime.search({rootId:goal.root_id,path:operation.path,pattern:operation.pattern,target:operation.target,mode:operation.mode,
+        caseSensitive:operation.case_sensitive,maxResults:operation.max_results,maxFileBytes:operation.max_file_bytes,
+        maxScanBytes:operation.max_scan_bytes,pageSize:operation.page_size,cursor:operation.cursor});
+    case 'multi_read':
+      return codingRuntime.filesRead({rootId:goal.root_id,files:operation.files,maxTotalBytes:operation.max_total_bytes});
+    case 'semantic_outline':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.outline({rootId:goal.root_id,relativePath:operation.path,maxSymbols:operation.max_symbols});
+    case 'semantic_definition':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.definition({rootId:goal.root_id,relativePath:operation.path,line:operation.line,column:operation.column,maxResults:operation.max_results});
+    case 'semantic_references':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.references({rootId:goal.root_id,relativePath:operation.path,line:operation.line,column:operation.column,maxResults:operation.max_results});
+    case 'semantic_diagnostics':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.diagnostics({rootId:goal.root_id,relativePath:operation.path,maxResults:operation.max_results});
+    case 'semantic_implementations':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.implementations({rootId:goal.root_id,relativePath:operation.path,line:operation.line,column:operation.column,maxResults:operation.max_results});
+    case 'semantic_rename_preview':
+      if (!semanticRuntime) throw new Error('semantic runtime unavailable');
+      return semanticRuntime.renamePreview({rootId:goal.root_id,relativePath:operation.path,line:operation.line,column:operation.column,newName:operation.new_name});
+    case 'native_diff_verify':
+      return nativeDiffRuntime.verify({diffId:operation.diff_id});
+    case 'machine_fs_stat':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.stat({rootId:goal.root_id,relativePath:operation.path,hash:operation.hash});
+    case 'machine_fs_list':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.list({rootId:goal.root_id,relativePath:operation.path,cursor:operation.cursor,limit:operation.limit,hashFiles:operation.hash_files});
+    case 'machine_fs_read':
+      if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      return machineFsRuntime.read({rootId:goal.root_id,relativePath:operation.path,offset:operation.offset,maxBytes:operation.max_bytes,hashFile:operation.hash_file});
     case 'machine_stat':
       if (!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
       return machineFsRuntime.stat({ rootId:goal.root_id, relativePath:operation.path, hash:operation.hash });
@@ -462,7 +676,7 @@ async function invokeDelegatedOperation(goal, operation, runtimes) {
       return observationRuntime.systemStatus();
     case 'process_start':
       if (!processRuntime) throw new Error('process runtime unavailable');
-      return processRuntime.start({ profileId:operation.profile_id, rootId:goal.root_id, cwd:operation.cwd, args:[] });
+      return processRuntime.start({ profileId:operation.profile_id, rootId:goal.root_id, cwd:operation.cwd, args:operation.args??[] });
     case 'process_read':
       if (!processRuntime) throw new Error('process runtime unavailable');
       return processRuntime.read({ sessionId:operation.session_id, offset:operation.offset, maxBytes:operation.max_bytes });
@@ -504,7 +718,9 @@ async function verifyDelegatedEvidence(operation, result, runtimes, verifyKeyPat
 }
 async function executeDelegate({ ctx, events, goal, decisionEvent, decision, policy, runtimes, assertRunAuthority,
   signingKeyPath, verifyKeyPath }) {
-  const actionKey = `delegate-${decisionEvent.event_sha256}`;
+  const capabilityId=capabilityIdForOperation(decision.operation);
+  if(!capabilityId) throw new Error(`unsupported typed capability action '${String(decision.operation?.kind)}'`);
+  const actionKey = `capability-${decisionEvent.event_sha256}`;
   const prior = [...events].reverse().find(event => event.type === 'delegated_action_completed' && event.payload?.action_key === actionKey);
   if (prior) return { status:'completed', result:prior.payload.result, existing:true };
   const started = [...events].reverse().find(event => event.type === 'delegated_action_started' && event.payload?.action_key === actionKey);
@@ -513,7 +729,7 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
       operation_kind:decision.operation.kind });
     return { status:'paused' };
   }
-  await appendEvent(ctx,events,signingKeyPath,'delegated_action_started',{ action_key:actionKey,
+  await appendEvent(ctx,events,signingKeyPath,'delegated_action_started',{ action_key:actionKey, capability_id:capabilityId,
     decision_event_sha256:decisionEvent.event_sha256, operation:decision.operation });
   try {
     assertDelegatedIdentity(events,decision.operation);
@@ -523,7 +739,7 @@ async function executeDelegate({ ctx, events, goal, decisionEvent, decision, pol
       throw new Error('delegated result exceeds autonomous context bound');
     }
     const evidence = await verifyDelegatedEvidence(decision.operation,result,runtimes,verifyKeyPath);
-    await appendEvent(ctx,events,signingKeyPath,'delegated_action_completed',{ action_key:actionKey,
+    await appendEvent(ctx,events,signingKeyPath,'delegated_action_completed',{ action_key:actionKey, capability_id:capabilityId,
       decision_event_sha256:decisionEvent.event_sha256, operation:decision.operation, result, evidence });
     return { status:'completed', result, evidence };
   } catch (error) {
@@ -546,34 +762,209 @@ async function runMutationProfiles({ ctx, events, goal, epoch, actionKey, policy
   }
   return results;
 }
+function patchActionCoordinates(state) {
+  const plan = state.active_plan ?? null;
+  const planId = SHA256_RE.test(plan?.plan_id ?? '')
+    ? plan.plan_id
+    : sha256Object({ schema:'deadbyte.autonomous-plan-coordinate.v1', plan });
+  const planVersion = Number.isInteger(plan?.plan_version) && plan.plan_version >= 1
+    ? plan.plan_version
+    : Math.max(1,Number(state.planner_round) || 1);
+  const activeStep = plan?.steps?.find(step => ['active','running','failed'].includes(step.status))
+    ?? plan?.steps?.find(step => step.status === 'pending')
+    ?? null;
+  const stepId = ID_RE.test(activeStep?.step_id ?? '')
+    ? activeStep.step_id
+    : `decision-${Math.max(1,Number(state.planner_round) || 1)}`;
+  return { planId,planVersion,stepId };
+}
+function patchStartedForDecision(events, decisionEventSha) {
+  return [...events].reverse().find(event => event.type === 'action_started' &&
+    event.payload?.decision_event_sha256 === decisionEventSha && event.payload?.action?.kind === 'patch') ?? null;
+}
+function patchCommitForAction(events, actionId) {
+  return [...events].reverse().find(event => event.type === 'native_diff_committed' &&
+    event.payload?.action_id === actionId) ?? null;
+}
+function patchCompletionForAction(events, actionId) {
+  return [...events].reverse().find(event => event.type === 'action_completed' &&
+    event.payload?.action_id === actionId) ?? null;
+}
+async function verifyPatchDiff(nativeDiffRuntime,diffId) {
+  const verified = await nativeDiffRuntime.verify({ diffId });
+  if (!verified.ok || verified.current_state_matches !== true) {
+    throw new Error(`autonomous native diff verification failed: ${verified.reason ?? 'state mismatch'}`);
+  }
+  return verified;
+}
+async function appendPatchCommit({ctx,events,signingKeyPath,started,decisionEvent,verified,recovered=false}) {
+  const actionId = started.payload.action_id;
+  const prior = patchCommitForAction(events,actionId);
+  if (prior) return prior;
+  const action = started.payload.action;
+  const verifiedPaths=[...new Set((verified.final_states??[]).flatMap(item=>[
+    typeof item?.path==='string'?item.path:null,
+    typeof item?.source_path==='string'?item.source_path:null,
+    typeof item?.destination_path==='string'?item.destination_path:null
+  ].filter(Boolean)))].sort((a,b)=>a.localeCompare(b,'en'));
+  return appendEvent(ctx,events,signingKeyPath,'native_diff_committed',{
+    action_id:actionId, decision_event_sha256:decisionEvent.event_sha256, diff_id:action.diff_id,
+    diff_receipt_sha256:verified.receipt_sha256, mutation_epoch:started.payload.target_mutation_epoch,
+    mutation_count:started.payload.mutation_count, operation_count:action.operation_count,
+    paths:Array.isArray(action.paths)&&action.paths.length>0?action.paths:verifiedPaths,
+    coding_receipts_verified:verified.coding_receipts_verified,
+    ...(recovered ? { recovered:true } : {})
+  });
+}
 async function executePatch({ ctx, events, goal, state, decisionEvent, decision, nativeDiffRuntime,
-  policy, codingRuntime, signingKeyPath }) {
-  if (state.mutation_count + decision.operations.length > policy.limits.max_mutations) {
+  policy, codingRuntime, signingKeyPath, actionCoordinatesOverride = null }) {
+  let started = patchStartedForDecision(events,decisionEvent.event_sha256);
+  if (!started && state.mutation_count + decision.operations.length > policy.limits.max_mutations) {
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
       reason:'mutation_limit', max_mutations:policy.limits.max_mutations
     });
     return { status:'paused' };
   }
-  const applicationScope = sha256Object({ schema:'deadbyte.autonomous-native-diff-scope.v1',
-    goal_id:goal.goal_id, decision_event_sha256:decisionEvent.event_sha256 });
-  const preview = await nativeDiffRuntime.preview({ rootId:goal.root_id,
-    operations:decision.operations, title:decision.summary, applicationScope });
-  const applied = await nativeDiffRuntime.apply({ diffId:preview.diff_id });
-  const verified = await nativeDiffRuntime.verify({ diffId:preview.diff_id });
-  if (!verified.ok || verified.current_state_matches !== true) {
-    throw new Error(`autonomous native diff verification failed: ${verified.reason ?? 'state mismatch'}`);
+
+  if (!started) {
+    const applicationScope = sha256Object({ schema:'deadbyte.autonomous-native-diff-scope.v1',
+      goal_id:goal.goal_id, decision_event_sha256:decisionEvent.event_sha256 });
+    const preview = await nativeDiffRuntime.preview({ rootId:goal.root_id,
+      operations:decision.operations, title:decision.summary, applicationScope });
+    const coordinates = actionCoordinatesOverride ?? patchActionCoordinates(state);
+    const action = { kind:'patch', diff_id:preview.diff_id,
+      operation_count:preview.operation_count, paths:preview.paths };
+    const identity = actionIdentity({ goalId:goal.goal_id, planId:coordinates.planId,
+      planVersion:coordinates.planVersion, stepId:coordinates.stepId, mutationEpoch:state.mutation_epoch,
+      decisionEventSha:decisionEvent.event_sha256, action });
+    started = await appendEvent(ctx,events,signingKeyPath,'action_started',{
+      ...identity, decision_event_sha256:decisionEvent.event_sha256,
+      plan_id:coordinates.planId, plan_version:coordinates.planVersion, step_id:coordinates.stepId,
+      mutation_epoch:state.mutation_epoch, target_mutation_epoch:state.mutation_epoch + 1,
+      mutation_count:decision.operations.length, action
+    });
   }
-  const epoch = state.mutation_epoch + 1;
-  await appendEvent(ctx,events,signingKeyPath,'native_diff_committed',{
-    decision_event_sha256:decisionEvent.event_sha256, diff_id:preview.diff_id,
-    diff_receipt_sha256:verified.receipt_sha256, mutation_epoch:epoch,
-    mutation_count:decision.operations.length, operation_count:preview.operation_count,
-    paths:preview.paths, coding_receipts_verified:verified.coding_receipts_verified
-  });
+
+  const actionId = started.payload.action_id;
+  const diffId = started.payload.action.diff_id;
+  const existingCompletion = patchCompletionForAction(events,actionId);
+  if (existingCompletion) {
+    const committed = patchCommitForAction(events,actionId);
+    if (!committed) throw new Error('completed patch action missing native diff commit');
+    const epoch = committed.payload.mutation_epoch;
+    const profiles = await runMutationProfiles({ ctx,events,goal,epoch,
+      actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath });
+    return { status:profiles.some(item => item.status === 'paused') ? 'paused' : 'completed',
+      diff_id:diffId, mutation_epoch:epoch, profiles, recovered:true };
+  }
+
+  const reconciliation = await reconcileStartedAction({ startedEvent:started, journal:events,
+    runtimes:{ nativeDiffRuntime,codingRuntime } });
+  if (reconciliation.classification === 'ambiguous') {
+    if (!events.some(event => event.type === 'waiting_entered' && event.payload?.action_id === actionId)) {
+      await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{
+        reason:'ambiguous_interrupted_action', action_id:actionId,
+        decision_event_sha256:decisionEvent.event_sha256, detail:truncated(reconciliation.reason,512)
+      });
+    }
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{
+      reason:'ambiguous_interrupted_action', action_id:actionId,
+      decision_event_sha256:decisionEvent.event_sha256
+    });
+    return { status:'paused', reason:'ambiguous_interrupted_action' };
+  }
+
+  let verified;
+  let recovered = false;
+  if (reconciliation.classification === 'executed_verified') {
+    recovered = true;
+    verified = await verifyPatchDiff(nativeDiffRuntime,diffId);
+    if (!events.some(event => event.type === 'action_reconciled' && event.payload?.action_id === actionId)) {
+      await appendEvent(ctx,events,signingKeyPath,'action_reconciled',{
+        action_id:actionId, request_sha256:started.payload.request_sha256,
+        decision_event_sha256:decisionEvent.event_sha256,
+        classification:reconciliation.classification, evidence:reconciliation.evidence
+      });
+    }
+  } else {
+    await nativeDiffRuntime.apply({ diffId });
+    verified = await verifyPatchDiff(nativeDiffRuntime,diffId);
+  }
+
+  const committed = await appendPatchCommit({ctx,events,signingKeyPath,started,decisionEvent,verified,recovered});
+  if (!patchCompletionForAction(events,actionId)) {
+    await appendEvent(ctx,events,signingKeyPath,'action_completed',{
+      action_id:actionId, request_sha256:started.payload.request_sha256,
+      decision_event_sha256:decisionEvent.event_sha256, classification:'executed_verified',
+      diff_id:diffId, receipt_sha256:verified.receipt_sha256, recovered
+    });
+  }
+  const epoch = committed.payload.mutation_epoch;
   const profiles = await runMutationProfiles({ ctx,events,goal,epoch,
     actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath });
   return { status:profiles.some(item => item.status === 'paused') ? 'paused' : 'completed',
-    diff_id:preview.diff_id, mutation_epoch:epoch, profiles };
+    diff_id:diffId, mutation_epoch:epoch, profiles, recovered };
+}
+async function executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId,expectedOperationCount,
+  policy,codingRuntime,nativeDiffRuntime,signingKeyPath}) {
+  let started=patchStartedForDecision(events,decisionEvent.event_sha256);
+  if(!started&&state.mutation_count+expectedOperationCount>policy.limits.max_mutations){
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{reason:'mutation_limit',max_mutations:policy.limits.max_mutations});
+    return {status:'paused'};
+  }
+  if(!started){
+    const coordinates=patchActionCoordinates(state);
+    const action={kind:'patch',diff_id:diffId,operation_count:expectedOperationCount,paths:[]};
+    const identity=actionIdentity({goalId:goal.goal_id,planId:coordinates.planId,planVersion:coordinates.planVersion,
+      stepId:coordinates.stepId,mutationEpoch:state.mutation_epoch,decisionEventSha:decisionEvent.event_sha256,action});
+    started=await appendEvent(ctx,events,signingKeyPath,'action_started',{
+      ...identity,decision_event_sha256:decisionEvent.event_sha256,plan_id:coordinates.planId,
+      plan_version:coordinates.planVersion,step_id:coordinates.stepId,mutation_epoch:state.mutation_epoch,
+      target_mutation_epoch:state.mutation_epoch+1,mutation_count:expectedOperationCount,action
+    });
+  }
+  const actionId=started.payload.action_id;
+  const existingCompletion=patchCompletionForAction(events,actionId);
+  if(existingCompletion){
+    const committed=patchCommitForAction(events,actionId);
+    if(!committed) throw new Error('completed prepared diff action missing native diff commit');
+    const epoch=committed.payload.mutation_epoch;
+    const profiles=await runMutationProfiles({ctx,events,goal,epoch,actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath});
+    return {status:profiles.some(item=>item.status==='paused')?'paused':'completed',diff_id:diffId,mutation_epoch:epoch,profiles,recovered:true};
+  }
+  const reconciliation=await reconcileStartedAction({startedEvent:started,journal:events,runtimes:{nativeDiffRuntime,codingRuntime}});
+  if(reconciliation.classification==='ambiguous'){
+    if(!events.some(event=>event.type==='waiting_entered'&&event.payload?.action_id===actionId)){
+      await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{reason:'ambiguous_interrupted_action',action_id:actionId,
+        decision_event_sha256:decisionEvent.event_sha256,detail:truncated(reconciliation.reason,512)});
+    }
+    await appendEvent(ctx,events,signingKeyPath,'goal_paused',{reason:'ambiguous_interrupted_action',action_id:actionId,
+      decision_event_sha256:decisionEvent.event_sha256});
+    return {status:'paused',reason:'ambiguous_interrupted_action'};
+  }
+  let verified; let recovered=false;
+  if(reconciliation.classification==='executed_verified'){
+    recovered=true;
+    verified=await verifyPatchDiff(nativeDiffRuntime,diffId);
+    if(verified.operation_count!==expectedOperationCount) throw new Error(`prepared native diff operation count mismatch: expected ${expectedOperationCount}, verified ${verified.operation_count}`);
+    if(!events.some(event=>event.type==='action_reconciled'&&event.payload?.action_id===actionId)){
+      await appendEvent(ctx,events,signingKeyPath,'action_reconciled',{action_id:actionId,request_sha256:started.payload.request_sha256,
+        decision_event_sha256:decisionEvent.event_sha256,classification:reconciliation.classification,evidence:reconciliation.evidence});
+    }
+  }else{
+    await nativeDiffRuntime.apply({diffId,expectedOperationCount});
+    verified=await verifyPatchDiff(nativeDiffRuntime,diffId);
+    if(verified.operation_count!==expectedOperationCount) throw new Error(`prepared native diff operation count mismatch: expected ${expectedOperationCount}, verified ${verified.operation_count}`);
+  }
+  const committed=await appendPatchCommit({ctx,events,signingKeyPath,started,decisionEvent,verified,recovered});
+  if(!patchCompletionForAction(events,actionId)){
+    await appendEvent(ctx,events,signingKeyPath,'action_completed',{action_id:actionId,request_sha256:started.payload.request_sha256,
+      decision_event_sha256:decisionEvent.event_sha256,classification:'executed_verified',diff_id:diffId,
+      receipt_sha256:verified.receipt_sha256,recovered});
+  }
+  const epoch=committed.payload.mutation_epoch;
+  const profiles=await runMutationProfiles({ctx,events,goal,epoch,actionKey:`mutation-${epoch}`,policy,codingRuntime,signingKeyPath});
+  return {status:profiles.some(item=>item.status==='paused')?'paused':'completed',diff_id:diffId,mutation_epoch:epoch,profiles,recovered};
 }
 async function runRequiredReleaseProfiles({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath }) {
   const requiredIds = Object.entries(policy.profiles)
@@ -696,10 +1087,280 @@ async function verifyReleaseReceipt({ ctx, goal, events, policy, verifyKeyPath,
     journal_head_sha256:completion.event_sha256 };
 }
 
+function r34CompletedSteps(plan) {
+  return Array.isArray(plan?.steps) ? plan.steps.filter(step => step.status === 'completed').length : 0;
+}
+function r34ProgressHistory(events) {
+  const history=[];
+  for (const event of events) {
+    if (event.type === 'plan_replanned') history.push('replan');
+    if (event.type === 'progress_judged' && ['progress','stalled','regressed'].includes(event.payload?.verdict)) {
+      history.push(event.payload.verdict);
+    }
+  }
+  return history;
+}
+async function r34PhaseChange({ctx,events,goal,signingKeyPath,to,reason}) {
+  const loop=deriveLoopState(goal,events);
+  if (loop.phase === to) return loop;
+  await appendEvent(ctx,events,signingKeyPath,'phase_changed',{from:loop.phase,to,reason});
+  return deriveLoopState(goal,events);
+}
+async function r35EnterCritic({ctx,events,goal,signingKeyPath,failureClass,evidenceFingerprint,detail}) {
+  let loop=deriveLoopState(goal,events);
+  const fingerprint=SHA256_RE.test(evidenceFingerprint ?? '') ? evidenceFingerprint : sha256Object({
+    schema:'deadbyte.autonomous-critic-evidence.v1',failure_class:failureClass,detail:String(detail ?? '')
+  });
+  await appendEvent(ctx,events,signingKeyPath,'critic_classified',{
+    failure_class:failureClass,evidence_fingerprint:fingerprint,detail:truncated(detail ?? failureClass,1024)
+  });
+  loop=deriveLoopState(goal,events);
+  if (loop.phase !== 'CRITIC') loop=await r34PhaseChange({ctx,events,goal,signingKeyPath,to:'CRITIC',reason:failureClass});
+  return loop;
+}
+async function r35BeginRepair({ctx,events,goal,signingKeyPath,hypothesis}) {
+  let loop=deriveLoopState(goal,events);
+  if (loop.phase !== 'CRITIC' && loop.phase !== 'REPAIR') throw new Error(`R35 repair requires CRITIC/REPAIR phase, got ${loop.phase}`);
+  if (loop.phase === 'CRITIC') loop=await r34PhaseChange({ctx,events,goal,signingKeyPath,to:'REPAIR',reason:'critic_ready'});
+  const priorHypothesis=loop.critic?.detail ?? hypothesis;
+  const previousFingerprint=repairFingerprint({plan:loop.plan,hypothesis:priorHypothesis});
+  await appendEvent(ctx,events,signingKeyPath,'repair_started',{
+    previous_fingerprint:previousFingerprint,hypothesis:priorHypothesis
+  });
+  return {loop:deriveLoopState(goal,events),previousFingerprint};
+}
+async function r35CompleteRepair({ctx,events,goal,signingKeyPath,previousFingerprint,hypothesis}) {
+  const loop=deriveLoopState(goal,events);
+  const nextFingerprint=repairFingerprint({plan:loop.plan,hypothesis});
+  await appendEvent(ctx,events,signingKeyPath,'repair_completed',{
+    previous_fingerprint:previousFingerprint,repair_fingerprint:nextFingerprint,hypothesis
+  });
+  return deriveLoopState(goal,events);
+}
+async function r34EnterWaiting({ctx,events,goal,signingKeyPath,reason,resumePhase}) {
+  const loop=deriveLoopState(goal,events);
+  if (loop.phase !== 'WAITING') {
+    await appendEvent(ctx,events,signingKeyPath,'waiting_entered',{
+      reason,requires_approval:true,resume_phase:resumePhase ?? loop.phase
+    });
+  }
+  await appendEvent(ctx,events,signingKeyPath,'goal_paused',{reason});
+  return {status:'paused',reason};
+}
+function r34ReasonHash(goal,decisionEvent,reason) {
+  return sha256Object({schema:'deadbyte.autonomous-plan-reason.v1',goal_id:goal.goal_id,
+    decision_event_sha256:decisionEvent.event_sha256,reason:String(reason ?? '')});
+}
+async function executeR34Decision({ctx,events,goal,state,decisionEvent,decision,policy,codingRuntime,
+  nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,
+  signingKeyPath,verifyKeyPath}) {
+  let loop=deriveLoopState(goal,events);
+  if (decision.kind === 'plan_create') {
+    if (loop.phase !== 'PLAN' || loop.plan) throw new Error('R34 plan_create requires empty PLANNING state');
+    const plan=createPlan({goalId:goal.goal_id,title:decision.title,steps:decision.steps,
+      reasonHash:r34ReasonHash(goal,decisionEvent,decision.reason ?? 'initial_plan')});
+    await appendEvent(ctx,events,signingKeyPath,'plan_created',{decision_event_sha256:decisionEvent.event_sha256,plan});
+    await r34PhaseChange({ctx,events,goal,signingKeyPath,to:'INSPECT',reason:'plan_ready'});
+    return {status:'completed',plan};
+  }
+  if (!loop.plan) throw new Error(`R34 ${decision.kind} requires a durable plan`);
+
+  if (decision.kind === 'inspect') {
+    if (loop.phase !== 'INSPECT') throw new Error(`R34 inspect requires INSPECTING phase, got ${loop.phase}`);
+    const contexts=[];
+    for (const item of decision.reads) {
+      const read=await codingRuntime.fileRead({rootId:goal.root_id,relativePath:item.path,encoding:'utf8'});
+      const bytes=Buffer.byteLength(read.content,'utf8');
+      if (bytes > item.max_bytes) throw new Error(`R34 inspect '${item.path}' exceeds requested max_bytes`);
+      contexts.push({path:item.path,sha256:read.sha256,bytes:read.bytes,content:read.content,
+        observed_at_utc:new Date().toISOString(),trust_class:'workspace_read',relevance_epoch:state.mutation_epoch});
+    }
+    const evidenceHead=sha256Object({schema:'deadbyte.autonomous-inspection-evidence.v1',contexts});
+    await appendEvent(ctx,events,signingKeyPath,'inspection_completed',{
+      decision_event_sha256:decisionEvent.event_sha256,evidence_head_sha256:evidenceHead,contexts
+    });
+    await r34PhaseChange({ctx,events,goal,signingKeyPath,to:'ACT',reason:'inspection_complete'});
+    return {status:'completed',contexts,evidence_head_sha256:evidenceHead};
+  }
+
+  if (decision.kind === 'act') {
+    if (loop.phase !== 'ACT') throw new Error(`R34 act requires ACTING phase, got ${loop.phase}`);
+    const before={mutation_epoch:state.mutation_epoch,completed_steps:r34CompletedSteps(loop.plan),
+      evidence_head:loop.evidence_head_sha256,release_ready:false,
+      acceptance_failures:state.observations.filter(item=>item?.passed===false).length};
+    let outcome;
+    if (decision.action.kind === 'patch') {
+      await assertRunAuthority(goal.root_id);
+      const currentStep=loop.current_step;
+      if (!currentStep) throw new Error('R34 patch requires active plan step');
+      try {
+        outcome=await executePatch({ctx,events,goal,state,decisionEvent,
+          decision:{operations:decision.action.operations,summary:`R34 ${currentStep.step_id}`},nativeDiffRuntime,
+          policy,codingRuntime,signingKeyPath,actionCoordinatesOverride:{planId:loop.plan_id,
+            planVersion:loop.plan_version,stepId:currentStep.step_id}});
+      } catch (error) {
+        const detail=truncated(error,512);
+        if (!/^native diff precondition '.+' (?:mismatch|expected absent, found [0-9a-f]{64})$/i.test(detail)) throw error;
+        await appendEvent(ctx,events,signingKeyPath,'action_precondition_failed',{
+          decision_event_sha256:decisionEvent.event_sha256,reason:'stale_sha',detail
+        });
+        await r35EnterCritic({ctx,events,goal,signingKeyPath,failureClass:'stale_precondition',detail});
+        return {status:'blocked',reason:'stale_sha'};
+      }
+    } else if (decision.action.kind === 'run_profile') {
+      await assertRunAuthority(goal.root_id);
+      outcome=await executeProfile({ctx,events,goalId:goal.goal_id,
+        actionKey:`r34-${decisionEvent.event_sha256}`,profileId:decision.action.profile_id,
+        epoch:state.mutation_epoch,policy,codingRuntime,signingKeyPath,r34ResumePhase:loop.phase});
+    } else if (decision.action.kind === 'delegate') {
+      outcome=await executeDelegate({ctx,events,goal,decisionEvent,
+        decision:{operation:decision.action.operation},policy,
+        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
+    } else if (decision.action.kind === 'native_diff_apply') {
+      await assertRunAuthority(goal.root_id);
+      outcome=await executePreparedDiff({ctx,events,goal,state,decisionEvent,diffId:decision.action.diff_id,
+        expectedOperationCount:decision.action.expected_operation_count,policy,codingRuntime,nativeDiffRuntime,signingKeyPath});
+    } else if (['machine_fs_mkdir','machine_fs_move','machine_fs_delete'].includes(decision.action.kind)) {
+      await assertRunAuthority(goal.root_id);
+      if(!machineFsRuntime) throw new Error('machine filesystem runtime unavailable');
+      let operations;
+      if(decision.action.kind==='machine_fs_mkdir') {
+        operations=[{kind:'mkdir',path:decision.action.path}];
+      } else if(decision.action.kind==='machine_fs_move') {
+        operations=[{kind:'move',source_path:decision.action.source_path,destination_path:decision.action.destination_path,
+          expected_source_identity:decision.action.expected_source_identity}];
+      } else {
+        const topology=await machineFsRuntime.state({rootId:goal.root_id,relativePath:decision.action.path});
+        if(!topology.exists||topology.identity_sha256!==decision.action.expected_source_identity) throw new Error(`machine fs delete identity precondition mismatch '${decision.action.path}'`);
+        if(topology.kind==='directory') operations=[{kind:'rmdir',path:decision.action.path,expected_source_identity:decision.action.expected_source_identity}];
+        else {
+          const file=await codingRuntime.fileState({rootId:goal.root_id,relativePath:decision.action.path});
+          if(!file.exists||!SHA256_RE.test(file.sha256??'')) throw new Error(`machine fs delete file precondition unavailable '${decision.action.path}'`);
+          operations=[{kind:'delete',path:decision.action.path,expected_sha256:file.sha256}];
+        }
+      }
+      outcome=await executePatch({ctx,events,goal,state,decisionEvent,decision:{operations,summary:`R36 ${decision.action.kind}`},
+        nativeDiffRuntime,policy,codingRuntime,signingKeyPath});
+    } else if (capabilityIdForOperation(decision.action)) {
+      outcome=await executeDelegate({ctx,events,goal,decisionEvent,
+        decision:{operation:decision.action},policy,
+        runtimes:{codingRuntime,semanticRuntime,nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime},assertRunAuthority,signingKeyPath,verifyKeyPath});
+    } else {
+      throw new Error(`unsupported R34 action '${String(decision.action.kind)}'`);
+    }
+    if (outcome.status === 'paused') return outcome;
+    await r34PhaseChange({ctx,events,goal,signingKeyPath,to:'VERIFY',reason:'action_observed'});
+    const afterState=deriveState(goal,events);
+    loop=deriveLoopState(goal,events);
+    const after={mutation_epoch:afterState.mutation_epoch,completed_steps:r34CompletedSteps(loop.plan),
+      evidence_head:loop.evidence_head_sha256,release_ready:false,
+      acceptance_failures:afterState.observations.filter(item=>item?.passed===false).length};
+    const evidence={
+      native_diff_verified:['patch','native_diff_apply','machine_fs_mkdir','machine_fs_move','machine_fs_delete'].includes(decision.action.kind) && afterState.mutation_epoch > state.mutation_epoch,
+      new_profile_evidence:decision.action.kind === 'run_profile' && outcome.status === 'passed' &&
+        afterState.observations.length > state.observations.length,
+      diagnostic_narrowed:(decision.action.kind === 'delegate' || capabilityIdForOperation(decision.action)) && afterState.observations.length > state.observations.length,
+      interrupted_action_recovered:outcome.recovered === true
+    };
+    const progress=judgeProgress({before,after,decision,evidence});
+    await appendEvent(ctx,events,signingKeyPath,'progress_judged',{
+      decision_event_sha256:decisionEvent.event_sha256,...progress
+    });
+    if (progress.verdict === 'regressed') {
+      await r35EnterCritic({ctx,events,goal,signingKeyPath,failureClass:'verification_failure',
+        evidenceFingerprint:progress.fingerprint,detail:'verification regressed against observed acceptance evidence'});
+    } else if (progress.verdict === 'stalled') {
+      const disposition=stallDisposition({history:r34ProgressHistory(events),limits:policy.limits});
+      if (disposition.action === 'replan') {
+        await r35EnterCritic({ctx,events,goal,signingKeyPath,failureClass:'no_progress',
+          evidenceFingerprint:progress.fingerprint,detail:disposition.reason});
+      } else if (disposition.action === 'wait') {
+        await r35EnterCritic({ctx,events,goal,signingKeyPath,failureClass:'no_progress',
+          evidenceFingerprint:progress.fingerprint,detail:disposition.reason});
+        return r34EnterWaiting({ctx,events,goal,signingKeyPath,reason:'no_progress_after_replan',resumePhase:'CRITIC'});
+      }
+    }
+    return outcome;
+  }
+
+  if (decision.kind === 'step_complete') {
+    if (loop.phase !== 'VERIFY') throw new Error(`R34 step_complete requires VERIFYING phase, got ${loop.phase}`);
+    const beforeCount=r34CompletedSteps(loop.plan);
+    const plan=completePlanStep(loop.plan,{stepId:decision.step_id,evidence:decision.evidence});
+    await appendEvent(ctx,events,signingKeyPath,'step_completed',{
+      decision_event_sha256:decisionEvent.event_sha256,step_id:decision.step_id,evidence:decision.evidence,plan
+    });
+    const progress=judgeProgress({
+      before:{mutation_epoch:state.mutation_epoch,completed_steps:beforeCount},
+      after:{mutation_epoch:state.mutation_epoch,completed_steps:r34CompletedSteps(plan)},
+      decision,evidence:{step_evidence_verified:true}
+    });
+    await appendEvent(ctx,events,signingKeyPath,'progress_judged',{
+      decision_event_sha256:decisionEvent.event_sha256,...progress
+    });
+    const target=r34PlanIsComplete(plan)?'PLAN':'INSPECT';
+    await r34PhaseChange({ctx,events,goal,signingKeyPath,to:target,reason:r34PlanIsComplete(plan)?'plan_complete':'next_plan_step'});
+    return {status:'completed',plan};
+  }
+
+  if (decision.kind === 'replan') {
+    if (!['CRITIC','REPAIR'].includes(loop.phase)) {
+      if (!['VERIFY','PLAN'].includes(loop.phase)) throw new Error(`R35 replan invalid from ${loop.phase}`);
+      loop=await r35EnterCritic({ctx,events,goal,signingKeyPath,failureClass:'insufficient_proof',
+        evidenceFingerprint:loop.progress?.fingerprint,detail:decision.reason});
+    }
+    const repair=await r35BeginRepair({ctx,events,goal,signingKeyPath,hypothesis:decision.reason});
+    loop=repair.loop;
+    const completed=loop.plan.steps.filter(step=>step.status==='completed').map(step=>structuredClone(step));
+    const plan=replanPlan(loop.plan,{steps:[...completed,...decision.steps],
+      reasonHash:r34ReasonHash(goal,decisionEvent,decision.reason)});
+    await appendEvent(ctx,events,signingKeyPath,'plan_replanned',{
+      decision_event_sha256:decisionEvent.event_sha256,reason:decision.reason,plan
+    });
+    await r35CompleteRepair({ctx,events,goal,signingKeyPath,previousFingerprint:repair.previousFingerprint,
+      hypothesis:decision.reason});
+    await r34PhaseChange({ctx,events,goal,signingKeyPath,to:'INSPECT',reason:'repair_ready'});
+    return {status:'completed',plan};
+  }
+
+  if (decision.kind === 'pause') {
+    return r34EnterWaiting({ctx,events,goal,signingKeyPath,reason:decision.reason,resumePhase:loop.phase});
+  }
+
+  if (decision.kind === 'finish') {
+    if (!r34PlanIsComplete(loop.plan)) {
+      await appendEvent(ctx,events,signingKeyPath,'plan_guard_blocked',{
+        decision_event_sha256:decisionEvent.event_sha256,action:'finish',
+        reason:'plan_incomplete_blocks_finish',plan_id:loop.plan_id,plan_version:loop.plan_version
+      });
+      return {status:'blocked',reason:'plan_incomplete_blocks_finish'};
+    }
+    if (loop.phase !== 'PLAN') throw new Error(`R34 finish requires PLANNING phase, got ${loop.phase}`);
+    await appendEvent(ctx,events,signingKeyPath,'finish_requested',{
+      decision_event_sha256:decisionEvent.event_sha256,mutation_epoch:state.mutation_epoch,
+      planner_summary:decision.summary ?? 'R34 finish'
+    });
+    await r34PhaseChange({ctx,events,goal,signingKeyPath,to:'RELEASE',reason:'finish_requested'});
+    return {status:'finish_requested'};
+  }
+
+  throw new Error(`unsupported R34 decision '${String(decision.kind)}'`);
+}
+
 async function executeDecision({ ctx, events, goal, state, decisionEvent, policy, codingRuntime,
-  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, assertRunAuthority,
+  nativeDiffRuntime, machineFsRuntime, observationRuntime, processRuntime, semanticRuntime, assertRunAuthority,
   signingKeyPath, verifyKeyPath }) {
   const decision = decisionEvent.decision;
+  if (decision?.schema === 'deadbyte.autonomous-decision.v2') {
+    const outcome=await executeR34Decision({ctx,events,goal,state,decisionEvent,decision,policy,codingRuntime,
+      nativeDiffRuntime,machineFsRuntime,observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,
+      signingKeyPath,verifyKeyPath});
+    await appendEvent(ctx,events,signingKeyPath,'decision_completed',{
+      decision_event_sha256:decisionEvent.event_sha256,action:decision.kind,
+      outcome_status:outcome.status ?? 'completed'
+    });
+    return outcome;
+  }
   if (repeatedDecisionCount(state,decision) >= 3) {
     await appendEvent(ctx,events,signingKeyPath,'goal_paused',{ reason:'no_progress_repeated_decision' });
     return { status:'paused' };
@@ -757,11 +1418,30 @@ function terminalState(state) {
   return ['succeeded','cancelled'].includes(state.state);
 }
 function pauseState(state) { return state.state === 'paused'; }
+async function resumeProviderWaitIfReady({ctx,journal,goal,state,policy,signingKeyPath}) {
+  if (state.state!=='paused'||state.reason!=='provider_circuit_open'||policy.planner.backend!=='openai_compatible') return state;
+  const circuit=providerCircuitSnapshot(policy,journal);
+  const disposition=providerCallDisposition(circuit);
+  if (!disposition.allowed||circuit.state!=='HALF_OPEN') return state;
+  const waiting=[...journal].reverse().find(event=>event.type==='waiting_entered'&&event.payload?.reason==='provider_circuit_open')??null;
+  const resumePhase=typeof waiting?.payload?.resume_phase==='string'?waiting.payload.resume_phase:'PLAN';
+  await appendEvent(ctx,journal,signingKeyPath,'waiting_resumed',{
+    to:resumePhase,reason:'provider_circuit_half_open',approved_at_utc:new Date().toISOString()
+  });
+  await appendEvent(ctx,journal,signingKeyPath,'goal_resumed',{
+    previous_reason:'provider_circuit_open',approved_at_utc:new Date().toISOString()
+  });
+  return deriveState(goal,journal);
+}
+function isAuthorityUnavailable(error) {
+  return /(?:disarmed|lease|outside active lease|authority unavailable)/i.test(String(error?.message ?? error));
+}
 
 export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRuntime, machineFsRuntime = null,
-  observationRuntime = null, processRuntime = null, signingKeyPath, verifyKeyPath }) {
+  observationRuntime = null, processRuntime = null, semanticRuntime = null, signingKeyPath, verifyKeyPath }) {
   if (!policy || !codingRuntime || !nativeDiffRuntime) throw new Error('autonomous runtime requires policy/coding/native-diff runtimes');
   if (!signingKeyPath || !verifyKeyPath) throw new Error('autonomous runtime requires trust keys');
+  const capabilityManifest=configuredCapabilityManifest({machineFsRuntime,observationRuntime,processRuntime,semanticRuntime});
   async function sessionStatus() {
     const autonomous = await autonomousSessionStatus(policy);
     const coding = await codingRuntime.sessionStatus();
@@ -773,6 +1453,13 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
       profile_ids:Object.keys(policy.profiles), policy_sha256:policy.policy_sha256,
       coding_policy_sha256:policy.coding_policy_sha256 };
   }
+  async function providerCircuitStatus({goalId}) {
+    if (policy.planner.backend!=='openai_compatible') return null;
+    const ctx=goalContext(policy,goalId);
+    await loadGoal(ctx,policy,verifyKeyPath);
+    const journal=await readEvents(ctx,verifyKeyPath);
+    return providerCircuitSnapshot(policy,journal);
+  }
 
   async function assertRunAuthority(rootId) {
     const autonomous = await assertAutonomousArmed(policy,rootId);
@@ -812,8 +1499,10 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     const goal = await loadGoal(ctx,policy,verifyKeyPath);
     const journal = await readEvents(ctx,verifyKeyPath);
     const derived = deriveState(goal,journal);
+    const loop = publicLoopState(loopStateOrNull(goal,journal));
     return { status:'ok', goal_id:goalId, goal_sha256:goal.goal_sha256,
-      title:goal.title, root_id:goal.root_id, journal_verified:true, ...derived };
+      title:goal.title, root_id:goal.root_id, journal_verified:true, ...derived,
+      ...(loop ? {loop} : {}) };
   }
 
   async function events({ goalId, fromSeq = 1, limit = 100 }) {
@@ -851,16 +1540,25 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
       const goal = await loadGoal(ctx,policy,verifyKeyPath);
       const journal = await readEvents(ctx,verifyKeyPath);
       const current = deriveState(goal,journal);
-      if (terminalState(current)) return { status:'terminal', goal_id:goalId, state:current.state };
+      if (terminalState(current)) return withLoopResult(goal,journal,{ status:'terminal', goal_id:goalId, state:current.state });
       if (!pauseState(current)) throw new Error('autonomous goal is not paused');
       if (decision === 'reject') {
         await appendEvent(ctx,journal,signingKeyPath,'goal_cancelled',{ reason:'resume_rejected' });
-        return { status:'rejected', goal_id:goalId, state:'cancelled' };
+        return withLoopResult(goal,journal,{ status:'rejected', goal_id:goalId, state:'cancelled' });
+      }
+      if (hasR34Loop(journal)) {
+        await assertRunAuthority(goal.root_id);
+        const waiting=[...journal].reverse().find(event=>event.type==='waiting_entered') ?? null;
+        const resumePhase=typeof waiting?.payload?.resume_phase === 'string' ? waiting.payload.resume_phase : 'PLAN';
+        await appendEvent(ctx,journal,signingKeyPath,'waiting_resumed',{
+          to:resumePhase,reason:waiting?.payload?.reason ?? current.reason ?? 'operator_approved',
+          approved_at_utc:new Date().toISOString()
+        });
       }
       await appendEvent(ctx,journal,signingKeyPath,'goal_resumed',{
         previous_reason:current.reason, approved_at_utc:new Date().toISOString()
       });
-      return { status:'approved', goal_id:goalId, state:'running' };
+      return withLoopResult(goal,journal,{ status:'approved', goal_id:goalId, state:'running' });
     } finally {
       await releaseLock(ctx);
     }
@@ -927,55 +1625,80 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     if (!Number.isInteger(maxCycles) || maxCycles < 1 || maxCycles > 32) throw new Error('autonomous max_cycles must be in [1,32]');
     const ctx = goalContext(policy,goalId);
     const goal = await loadGoal(ctx,policy,verifyKeyPath);
-    await assertRunAuthority(goal.root_id);
     await acquireLock(ctx);
     try {
       const journal = await readEvents(ctx,verifyKeyPath);
       let state = deriveState(goal,journal);
-      if (terminalState(state)) return { status:'terminal', goal_id:goalId, ...state };
-      if (pauseState(state)) return { status:'paused', goal_id:goalId, ...state };
+      if (terminalState(state)) return withLoopResult(goal,journal,{ status:'terminal', goal_id:goalId, ...state });
+      state=await resumeProviderWaitIfReady({ctx,journal,goal,state,policy,signingKeyPath});
+      if (pauseState(state)) return withLoopResult(goal,journal,{ status:'paused', goal_id:goalId, ...state });
+      const loopBeforeAuthority = loopStateOrNull(goal,journal);
+      try {
+        await assertRunAuthority(goal.root_id);
+      } catch (error) {
+        if (!loopBeforeAuthority || !isAuthorityUnavailable(error)) throw error;
+        const waiting=await r34EnterWaiting({ctx,events:journal,goal,signingKeyPath,
+          reason:'authority_unavailable',resumePhase:loopBeforeAuthority.phase});
+        state=deriveState(goal,journal);
+        return withLoopResult(goal,journal,{...waiting,goal_id:goalId,...state});
+      }
       if (await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)) {
-        state = deriveState(goal,journal); return { status:'cancelled', goal_id:goalId, ...state };
+        state = deriveState(goal,journal); return withLoopResult(goal,journal,{ status:'cancelled', goal_id:goalId, ...state });
       }
       await appendEvent(ctx,journal,signingKeyPath,'goal_run_started',{ max_cycles:maxCycles });
       let cycles = 0; let suppliedResponse = plannerResponse;
       while (cycles < maxCycles) {
         state = deriveState(goal,journal);
-        if (terminalState(state) || pauseState(state)) return { status:state.state, goal_id:goalId, ...state };
+        if (terminalState(state) || pauseState(state)) return withLoopResult(goal,journal,{ status:state.state, goal_id:goalId, ...state });
         if (await consumeCancel(ctx,journal,signingKeyPath,verifyKeyPath)) {
-          state = deriveState(goal,journal); return { status:'cancelled', goal_id:goalId, ...state };
+          state = deriveState(goal,journal); return withLoopResult(goal,journal,{ status:'cancelled', goal_id:goalId, ...state });
         }
         if (state.pending_decision) {
-          const outcome = await executeDecision({ ctx,events:journal,goal,state,
-            decisionEvent:state.pending_decision,policy,codingRuntime,nativeDiffRuntime,machineFsRuntime,
-            observationRuntime,processRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath });
+          let outcome;
+          try {
+            outcome = await executeDecision({ ctx,events:journal,goal,state,
+              decisionEvent:state.pending_decision,policy,codingRuntime,nativeDiffRuntime,machineFsRuntime,
+              observationRuntime,processRuntime,semanticRuntime,assertRunAuthority,signingKeyPath,verifyKeyPath });
+          } catch (error) {
+            const loop=loopStateOrNull(goal,journal);
+            if (!loop || loop.pending_action || !isAuthorityUnavailable(error)) throw error;
+            outcome=await r34EnterWaiting({ctx,events:journal,goal,signingKeyPath,
+              reason:'authority_unavailable',resumePhase:loop.phase});
+          }
           cycles += 1; state = deriveState(goal,journal);
-          if (outcome.status === 'paused' || pauseState(state)) return { status:'paused', goal_id:goalId, ...state };
+          if (outcome.status === 'paused' || pauseState(state)) return withLoopResult(goal,journal,{ status:'paused', goal_id:goalId, ...state });
           if (outcome.status === 'finish_requested') {
             const gate = await releaseGateLocked(ctx,goal,journal);
             state = deriveState(goal,journal);
-            if (gate.status === 'passed') return { status:'completed', goal_id:goalId, release:gate, ...state };
-            if (gate.status === 'paused') return { status:'paused', goal_id:goalId, release:gate, ...state };
+            if (gate.status === 'passed') return withLoopResult(goal,journal,{ status:'completed', goal_id:goalId, release:gate, ...state });
+            if (gate.status === 'paused') return withLoopResult(goal,journal,{ status:'paused', goal_id:goalId, release:gate, ...state });
+            const releaseLoop=loopStateOrNull(goal,journal);
+            if (releaseLoop?.phase === 'RELEASE') {
+              await r35EnterCritic({ctx,events:journal,goal,signingKeyPath,failureClass:'verification_failure',
+                evidenceFingerprint:sha256Object({schema:'deadbyte.autonomous-release-failure.v1',gate}),
+                detail:`release gate ${gate.status}: ${gate.reason ?? 'required profile failure'}`});
+              state=deriveState(goal,journal);
+            }
           }
           continue;
         }
-        const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,
+        const accepted = await acceptPlannerDecision({ ctx,events:journal,goal,state,policy,codingRuntime,capabilityManifest,
           signingKeyPath,plannerResponse:suppliedResponse });
         suppliedResponse = null;
         if (accepted?.needs_planner) {
           state = deriveState(goal,journal);
-          return { status:'input_required', goal_id:goalId,
+          return withLoopResult(goal,journal,{ status:'input_required', goal_id:goalId,
             planner_request:{ request_id:accepted.request.request_id,
               planner_round:accepted.request.planner_round,
               mutation_epoch:accepted.request.mutation_epoch,
               prompt:accepted.request.prompt,
-              prompt_sha256:accepted.request.prompt_sha256 }, ...state };
+              prompt_sha256:accepted.request.prompt_sha256 }, ...state });
         }
         state = deriveState(goal,journal);
-        if (pauseState(state)) return { status:'paused', goal_id:goalId, ...state };
+        if (pauseState(state)) return withLoopResult(goal,journal,{ status:'paused', goal_id:goalId, ...state });
       }
       state = deriveState(goal,journal);
-      return { status:'yielded', goal_id:goalId, cycles, ...state };
+      return withLoopResult(goal,journal,{ status:'yielded', goal_id:goalId, cycles, ...state });
     } finally { await releaseLock(ctx); }
   }
 
@@ -988,6 +1711,6 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
     return verifyReleaseReceipt({ ctx,goal,events:journal,policy,verifyKeyPath,nativeDiffRuntime,codingRuntime });
   }
 
-  return Object.freeze({ policy, sessionStatus, submit, run, status, events, cancel, approve,
+  return Object.freeze({ policy, sessionStatus, providerCircuitStatus, submit, run, status, events, cancel, approve,
     releaseGate, verify });
 }