deadbyte-mcp 0.8.9 → 0.9.0

package/src/autonomous-runtime.mjs

@@ -4,7 +4,12 @@ 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';
 
 export const AUTONOMOUS_GOAL_SCHEMA = 'deadbyte.autonomous-goal.v1';
@@ -196,7 +201,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 +210,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 +262,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 +272,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,
@@ -337,6 +376,106 @@ function validatePlanTransition(previous, next) {
 function planIsComplete(plan) {
   return Boolean(plan?.steps?.length) && plan.steps.every(step => step.status === 'completed');
 }
+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, signingKeyPath, plannerResponse }) {
   let currentState = state;
   let pending = currentState.pending_request ?? await requestPlanner(ctx,goal,events,currentState,policy,codingRuntime,signingKeyPath);
@@ -345,7 +484,9 @@ async function acceptPlannerDecision({ ctx, events, goal, state, policy, codingR
   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 +498,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' &&
@@ -405,7 +546,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
@@ -546,34 +689,142 @@ 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;
+  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:action.paths, 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 runRequiredReleaseProfiles({ ctx, events, goal, state, policy, codingRuntime, signingKeyPath }) {
   const requiredIds = Object.entries(policy.profiles)
@@ -696,10 +947,251 @@ 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,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:{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:decision.action.kind === 'patch' && 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' && 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,
   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,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,6 +1249,24 @@ 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 }) {
@@ -773,6 +1283,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 +1329,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 +1370,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,35 +1455,60 @@ 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,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;
         }
@@ -964,18 +1517,18 @@ export function createAutonomousRuntime({ policy, codingRuntime, nativeDiffRunti
         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 +1541,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 });
 }