@riddledc/riddle-proof 0.5.47 → 0.5.49

package/dist/engine-harness.cjs

@@ -1747,9 +1747,27 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     }
     return "inspect the ship gate details, repair the missing invariant, then resume the run";
   };
+  const shipGateRecoveryStage = (shipGate) => {
+    const reasons = shipGate.reasons || [];
+    if (reasons.some((reason) => reason.includes("before_cdn") || reason.includes("prod_cdn") || reason.includes("prod_url"))) {
+      return "recon";
+    }
+    if (reasons.some((reason) => reason.includes("implementation"))) {
+      return "implement";
+    }
+    if (reasons.some((reason) => reason.includes("after_cdn") || reason.includes("verify_status") || reason.includes("visual_delta"))) {
+      return "verify";
+    }
+    if (reasons.some((reason) => reason.includes("proof_assessment"))) {
+      return "verify";
+    }
+    return "verify";
+  };
   const shipGateBlocked = (state, executed, details = {}) => {
     const shipGate = validateShipGate(state);
     const nextAction = primaryShipGateNextAction(shipGate);
+    const recoveryStage = shipGateRecoveryStage(shipGate);
+    const advanceOptions = Array.from(/* @__PURE__ */ new Set([recoveryStage, "verify", "author", "implement", "recon", "ship"]));
     return checkpoint(
       "verify",
       "ship_gate_blocked",
@@ -1757,12 +1775,13 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
       {
         ok: false,
         nextActions: ["inspect_ship_gate", "advance_run_to_verify", "supply_proof_assessment_json", "return_to_recon_if_baseline_is_missing"],
-        advanceOptions: ["verify", "author", "implement", "recon"],
-        recommendedAdvanceStage: "verify",
-        continueWithStage: "verify",
+        advanceOptions,
+        recommendedAdvanceStage: recoveryStage,
+        continueWithStage: recoveryStage,
         blocking: true,
-        details: { ...details, shipGate, next_action: nextAction, executed },
+        details: { ...details, shipGate, next_action: nextAction, recovery_stage: recoveryStage, executed },
         nextAction,
+        recoveryStage,
         shipGate,
         verifyStatus: state?.verify_status || null,
         mergeRecommendation: state?.merge_recommendation || null,
@@ -3635,6 +3654,68 @@ function compactText2(value, limit = 600) {
   if (!text) return void 0;
   return text.length <= limit ? text : `${text.slice(0, limit - 20).trimEnd()}...`;
 }
+function numericValue(value) {
+  const number = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  return Number.isFinite(number) ? number : void 0;
+}
+function eventDetails(event) {
+  return recordValue(recordValue(event)?.details) || {};
+}
+function collectRunnerMetrics(details) {
+  const metrics = [];
+  const adapterDetails = recordValue(details.adapter_details);
+  const direct = recordValue(adapterDetails?.runner_metrics);
+  if (direct) metrics.push(direct);
+  const attempts = Array.isArray(adapterDetails?.attempt_summaries) ? adapterDetails.attempt_summaries : [];
+  for (const attempt of attempts) {
+    const attemptMetrics = recordValue(recordValue(attempt)?.runner_metrics);
+    if (attemptMetrics) metrics.push(attemptMetrics);
+  }
+  return metrics;
+}
+function observabilityFrom(state) {
+  const engineEvents = state.events.filter((event) => event.kind === "engine.result").map((event) => ({ event, details: eventDetails(event) }));
+  const agentEvents = state.events.filter((event) => event.kind.startsWith("agent.")).map((event) => ({ event, details: eventDetails(event) })).filter(({ details }) => numericValue(details.duration_ms) !== void 0);
+  const retryEvents = state.events.filter((event) => /retry|recovery/i.test(event.kind) || /retry|recovery/i.test(event.summary || "")).slice(-8);
+  const runnerMetrics = agentEvents.flatMap(({ details }) => collectRunnerMetrics(details));
+  const promptChars = runnerMetrics.map((metrics) => numericValue(metrics.prompt_chars)).filter((value) => value !== void 0);
+  const sum = (values) => values.reduce((total, value) => total + (value ?? 0), 0);
+  const recentEngineTimings = engineEvents.slice(-8).map(({ event, details }) => compactRecord({
+    checkpoint: event.checkpoint || null,
+    stage: event.stage || null,
+    duration_ms: numericValue(details.duration_ms),
+    ok: details.ok ?? null
+  }));
+  const recentAgentTimings = agentEvents.slice(-8).map(({ event, details }) => {
+    const metrics = collectRunnerMetrics(details);
+    const localPromptChars = metrics.map((item) => numericValue(item.prompt_chars)).filter((value) => value !== void 0);
+    return compactRecord({
+      kind: event.kind,
+      checkpoint: event.checkpoint || null,
+      stage: event.stage || null,
+      duration_ms: numericValue(details.duration_ms),
+      prompt_chars: localPromptChars.length ? Math.max(...localPromptChars) : void 0,
+      attempt_count: numericValue(recordValue(details.adapter_details)?.attempt_count)
+    });
+  });
+  return compactRecord({
+    engine_call_count: engineEvents.length,
+    agent_call_count: agentEvents.length,
+    engine_total_ms: sum(engineEvents.map(({ details }) => numericValue(details.duration_ms))),
+    agent_total_ms: sum(agentEvents.map(({ details }) => numericValue(details.duration_ms))),
+    max_agent_prompt_chars: promptChars.length ? Math.max(...promptChars) : void 0,
+    total_agent_prompt_chars: promptChars.length ? sum(promptChars) : void 0,
+    recent_engine_timings: recentEngineTimings.length ? recentEngineTimings : void 0,
+    recent_agent_timings: recentAgentTimings.length ? recentAgentTimings : void 0,
+    retry_event_count: retryEvents.length,
+    recent_retry_reasons: retryEvents.length ? retryEvents.map((event) => compactRecord({
+      kind: event.kind,
+      checkpoint: event.checkpoint || null,
+      stage: event.stage || null,
+      summary: compactText2(event.summary, 240)
+    })) : void 0
+  });
+}
 function visualDeltaFrom(input) {
   const fullState = input.fullRiddleState || {};
   const bundle = recordValue(fullState.evidence_bundle);
@@ -3747,6 +3828,7 @@ function createRiddleProofRunCard(state, input = {}) {
       proof_evidence_present: fullState.proof_evidence_present === true || Boolean(bundle?.proof_evidence || bundle?.proof_evidence_sample),
       artifacts
     }),
+    observability: observabilityFrom(state),
     stop_condition: compactRecord({
       status: state.status,
       terminal: isTerminalStatus(state.status),
@@ -4184,6 +4266,20 @@ function checkpointContinueStage2(result) {
   const resume = recordValue(result.checkpointContract?.resume);
   return nonEmptyString(resume?.continue_with_stage);
 }
+function checkpointRecommendedStage(result) {
+  const resumeStage = checkpointContinueStage2(result);
+  if (resumeStage) return resumeStage;
+  return nonEmptyString(result.checkpointContract?.recommended_advance_stage) || nonEmptyString(result.decisionRequest?.continue_with_stage) || nonEmptyString(result.decisionRequest?.recommended_advance_stage) || nonEmptyString(recordValue(result.decisionRequest)?.continueWithStage) || nonEmptyString(recordValue(result.decisionRequest)?.recommendedAdvanceStage);
+}
+function stageCheckpointContinuation(result) {
+  const stage = checkpointRecommendedStage(result);
+  if (!stage) return null;
+  return {
+    action: "run",
+    state_path: String(result.state_path || ""),
+    advance_stage: stage
+  };
+}
 function recommendedContinuation(result) {
   const continueStage = checkpointContinueStage2(result);
   if (!continueStage) return null;
@@ -4226,6 +4322,18 @@ function defaultStageForProofCheckpointDecision(decision) {
   if (decision === "needs_richer_proof") return "author";
   return null;
 }
+function checkpointContractFromPacket(packet) {
+  return recordValue(packet.evidence_excerpt?.checkpoint_contract) || recordValue(recordValue(packet.state_excerpt?.stage_decision_request)?.checkpoint_contract) || null;
+}
+function stageFromCheckpointResponse(response, packet) {
+  if (response.decision === "needs_recon") return "recon";
+  if (response.decision === "needs_implementation") return "implement";
+  const payload = recordValue(response.payload) || {};
+  const contract = checkpointContractFromPacket(packet);
+  const resume = recordValue(contract?.resume);
+  const stage = response.continue_with_stage || nonEmptyString(payload.continue_with_stage) || nonEmptyString(payload.recommended_stage) || nonEmptyString(resume?.continue_with_stage) || (response.decision === "retry_stage" ? packet.stage : "");
+  return stage ? stage : null;
+}
 function proofAssessmentPayloadFromCheckpointResponse(response) {
   if (![
     "ready_to_ship",
@@ -4328,6 +4436,13 @@ function visualDeltaEvidenceRecoveryAssessment(state, payload, blocker) {
     blockers: [...blockers, blocker]
   };
 }
+function isRecoverableStageCheckpoint(checkpoint) {
+  return [
+    "ship_gate_blocked",
+    "verify_required",
+    "verify_supervisor_judgment_required"
+  ].includes(checkpoint);
+}
 function contextFor(request, state, result) {
   return {
     request,
@@ -4674,6 +4789,18 @@ function checkpointResponseContinuation(state, value) {
       };
     }
   }
+  if (response.decision === "continue_stage" || response.decision === "retry_stage" || response.decision === "needs_implementation") {
+    const stage = stageFromCheckpointResponse(response, packet);
+    if (stage) {
+      appendCheckpointResponse(state, response);
+      return {
+        next: {
+          ...base,
+          advance_stage: stage
+        }
+      };
+    }
+  }
   appendCheckpointResponse(state, response, { clear_packet: false });
   return {
     blocker: {
@@ -4756,7 +4883,10 @@ async function handleImplementation(request, state, result, agent) {
       worktree_path: workdir || null
     }
   });
+  const implementationStartedAt = timestamp3();
+  const implementationStartedMs = Date.now();
   const implementation = await agent.implementChange({ ...context, workdir });
+  const implementationDurationMs = Date.now() - implementationStartedMs;
   if (implementation.blocker || implementation.ok === false) {
     recordEvent(state, {
       kind: "agent.implementation.blocked",
@@ -4765,6 +4895,8 @@ async function handleImplementation(request, state, result, agent) {
       summary: implementation.summary || implementation.blocker?.message || "Implementation adapter reported a blocker.",
       details: compactRecord({
         worktree_path: workdir || null,
+        started_at: implementationStartedAt,
+        duration_ms: implementationDurationMs,
         changed_files: implementation.changedFiles || [],
         tests_run: implementation.testsRun || [],
         implementation_notes: implementation.implementationNotes || null,
@@ -4790,24 +4922,32 @@ async function handleImplementation(request, state, result, agent) {
       summary: implementation.summary || "Implementation adapter returned without leaving a detectable git diff.",
       details: compactRecord({
         worktree_path: workdir || null,
+        started_at: implementationStartedAt,
+        duration_ms: implementationDurationMs,
         changed_files: implementation.changedFiles || [],
         tests_run: implementation.testsRun || [],
         implementation_notes: implementation.implementationNotes || null,
         adapter_details: implementation.details || null
       })
     });
-    return {
-      blocker: {
-        code: "implementation_diff_missing",
+    recordEvent(state, {
+      kind: "agent.implementation.retry_requested",
+      checkpoint: result.checkpoint || null,
+      stage: "implement",
+      summary: "Implementation adapter left no detectable diff; retrying the implement checkpoint inside the bounded loop.",
+      details: compactRecord({
+        worktree_path: workdir || null,
         checkpoint: result.checkpoint || null,
-        message: "The implementation adapter returned, but the after worktree has no detectable git diff. The harness will not advance to verify.",
-        details: compactRecord({
-          worktree_path: workdir || null,
-          changed_files: implementation.changedFiles || [],
-          tests_run: implementation.testsRun || [],
-          implementation_notes: implementation.implementationNotes || null,
-          adapter_details: implementation.details || null
-        })
+        next_stage: "implement",
+        previous_duration_ms: implementationDurationMs
+      })
+    });
+    return {
+      next: {
+        action: "run",
+        state_path: String(result.state_path || ""),
+        advance_stage: "implement",
+        implementation_notes: implementation.implementationNotes || implementation.summary || "Implementation adapter returned without a detectable git diff; retry the implement checkpoint."
       }
     };
   }
@@ -4818,6 +4958,8 @@ async function handleImplementation(request, state, result, agent) {
     summary: implementation.summary || "Implementation adapter reported code changes.",
     details: {
       worktree_path: workdir || null,
+      started_at: implementationStartedAt,
+      duration_ms: implementationDurationMs,
       diffDetected,
       changed_files: implementation.changedFiles || [],
       tests_run: implementation.testsRun || [],
@@ -4843,16 +4985,32 @@ async function routeCheckpoint(request, state, result, agent, input) {
       terminal: terminalResult(state, "completed", result, result.summary || "Riddle Proof engine completed.")
     };
   }
+  if (isRecoverableStageCheckpoint(checkpoint) && !input.dry_run && !request.dry_run) {
+    if (input.checkpoint_mode === "yield") {
+      return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
+    }
+    const next = stageCheckpointContinuation(result);
+    if (next) {
+      recordEvent(state, {
+        kind: "checkpoint.recovery_continuation",
+        checkpoint,
+        stage: stageFromCheckpoint2(result),
+        summary: `Routing recoverable checkpoint ${checkpoint} back to ${next.advance_stage}.`,
+        details: {
+          next,
+          checkpointContract: result.checkpointContract || null
+        }
+      });
+      return { next };
+    }
+  }
   const failureBlocker = engineFailureBlocker(result, checkpoint);
   if (failureBlocker) {
     return { blocker: failureBlocker };
   }
   if ([
     "recon_human_escalation",
-    "verify_human_escalation",
-    "ship_gate_blocked",
-    "verify_required",
-    "verify_supervisor_judgment_required"
+    "verify_human_escalation"
   ].includes(checkpoint) && result.ok === false) {
     return {
       blocker: {
@@ -4918,15 +5076,44 @@ async function routeCheckpoint(request, state, result, agent, input) {
     if (input.checkpoint_mode === "yield") {
       return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
     }
+    const startedAt = timestamp3();
+    const startedMs = Date.now();
+    recordEvent(state, {
+      kind: "agent.recon_assessment.started",
+      checkpoint,
+      stage: "recon",
+      summary: "Recon assessment agent started.",
+      details: { started_at: startedAt }
+    });
     const assessment = await agent.assessRecon(context);
+    const durationMs = Date.now() - startedMs;
     const blocker = requirePayload("recon_assessment", assessment, state, result);
-    if (blocker) return { blocker };
+    if (blocker) {
+      recordEvent(state, {
+        kind: "agent.recon_assessment.blocked",
+        checkpoint,
+        stage: "recon",
+        summary: blocker.message,
+        details: compactRecord({
+          started_at: startedAt,
+          duration_ms: durationMs,
+          blocker,
+          adapter_details: assessment.details || null
+        })
+      });
+      return { blocker };
+    }
     recordEvent(state, {
       kind: "agent.recon_assessment.completed",
       checkpoint,
       stage: "recon",
       summary: assessment.summary,
-      details: { payload: assessment.payload }
+      details: compactRecord({
+        payload: assessment.payload,
+        started_at: startedAt,
+        duration_ms: durationMs,
+        adapter_details: assessment.details || null
+      })
     });
     return {
       next: { ...baseContinuation(result), recon_assessment_json: jsonParam(assessment.payload) }
@@ -4938,15 +5125,44 @@ async function routeCheckpoint(request, state, result, agent, input) {
     if (input.checkpoint_mode === "yield") {
       return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
     }
+    const startedAt = timestamp3();
+    const startedMs = Date.now();
+    recordEvent(state, {
+      kind: "agent.author_packet.started",
+      checkpoint,
+      stage: "author",
+      summary: "Proof authoring agent started.",
+      details: { started_at: startedAt }
+    });
     const packet = await agent.authorProofPacket(context);
+    const durationMs = Date.now() - startedMs;
     const blocker = requirePayload("author_packet", packet, state, result);
-    if (blocker) return { blocker };
+    if (blocker) {
+      recordEvent(state, {
+        kind: "agent.author_packet.blocked",
+        checkpoint,
+        stage: "author",
+        summary: blocker.message,
+        details: compactRecord({
+          started_at: startedAt,
+          duration_ms: durationMs,
+          blocker,
+          adapter_details: packet.details || null
+        })
+      });
+      return { blocker };
+    }
     recordEvent(state, {
       kind: "agent.author_packet.completed",
       checkpoint,
       stage: "author",
       summary: packet.summary,
-      details: { payload: packet.payload }
+      details: compactRecord({
+        payload: packet.payload,
+        started_at: startedAt,
+        duration_ms: durationMs,
+        adapter_details: packet.details || null
+      })
     });
     return {
       next: { ...baseContinuation(result), author_packet_json: jsonParam(packet.payload) }
@@ -4969,9 +5185,31 @@ async function routeCheckpoint(request, state, result, agent, input) {
     if (input.checkpoint_mode === "yield") {
       return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
     }
+    const startedAt = timestamp3();
+    const startedMs = Date.now();
+    recordEvent(state, {
+      kind: "agent.proof_assessment.started",
+      checkpoint,
+      stage: "verify",
+      summary: "Proof assessment agent started.",
+      details: { started_at: startedAt }
+    });
     const assessment = await agent.assessProof(context);
+    const durationMs = Date.now() - startedMs;
     const blocker = requirePayload("proof_assessment", assessment, state, result);
     if (blocker) {
+      recordEvent(state, {
+        kind: "agent.proof_assessment.blocked",
+        checkpoint,
+        stage: "verify",
+        summary: blocker.message,
+        details: compactRecord({
+          started_at: startedAt,
+          duration_ms: durationMs,
+          blocker,
+          adapter_details: assessment.details || null
+        })
+      });
       if (blocker.code === "main_agent_proof_review_required") {
         recordEvent(state, {
           kind: "checkpoint.packet.requested",
@@ -4990,7 +5228,12 @@ async function routeCheckpoint(request, state, result, agent, input) {
       checkpoint,
       stage: "verify",
       summary: assessment.summary,
-      details: { payload }
+      details: compactRecord({
+        payload,
+        started_at: startedAt,
+        duration_ms: durationMs,
+        adapter_details: assessment.details || null
+      })
     });
     const visualBlocker = proofAssessmentVisualBlocker({
       ...context.fullRiddleState || {},
@@ -5011,7 +5254,8 @@ async function routeCheckpoint(request, state, result, agent, input) {
           recovery_stage: "verify",
           evidence_issue_code: recoveryAssessment.evidence_issue_code || null,
           visual_delta: recoveryAssessment.visual_delta || null,
-          proof_assessment: recoveryAssessment
+          proof_assessment: recoveryAssessment,
+          agent_duration_ms: durationMs
         })
       });
       return { next: proofAssessmentContinuation(result, recoveryAssessment) };

package/dist/engine-harness.js

@@ -2,10 +2,10 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-ALP5KOS2.js";
+} from "./chunk-722PW3X3.js";
 import "./chunk-4ASMX4R6.js";
-import "./chunk-JOXTKWX6.js";
-import "./chunk-PLSGW2GI.js";
+import "./chunk-U7Q3RB5D.js";
+import "./chunk-CI2F66EE.js";
 import "./chunk-R6SCWJCI.js";
 import "./chunk-DUFDZJOF.js";
 export {