@riddledc/riddle-proof 0.5.17 → 0.5.19

package/dist/{chunk-URO4JVMA.js → chunk-PJ3RTT5D.js}

@@ -420,8 +420,31 @@ async function handleImplementation(request, state, result, agent) {
       }
     };
   }
+  recordEvent(state, {
+    kind: "agent.implementation.started",
+    checkpoint: result.checkpoint || null,
+    stage: "implement",
+    summary: "Implementation agent started working in the after worktree.",
+    details: {
+      worktree_path: workdir || null
+    }
+  });
   const implementation = await agent.implementChange({ ...context, workdir });
   if (implementation.blocker || implementation.ok === false) {
+    recordEvent(state, {
+      kind: "agent.implementation.blocked",
+      checkpoint: result.checkpoint || null,
+      stage: "implement",
+      summary: implementation.summary || implementation.blocker?.message || "Implementation adapter reported a blocker.",
+      details: compactRecord({
+        worktree_path: workdir || null,
+        changed_files: implementation.changedFiles || [],
+        tests_run: implementation.testsRun || [],
+        implementation_notes: implementation.implementationNotes || null,
+        blocker: implementation.blocker || null,
+        adapter_details: implementation.details || null
+      })
+    });
     return {
       blocker: implementation.blocker || {
         code: "implementation_blocked",
@@ -433,12 +456,31 @@ async function handleImplementation(request, state, result, agent) {
   const cleanedArtifacts = removeEmptyToolArtifacts(workdir);
   const diffDetected = implementation.diffDetected === true || hasGitDiff(workdir);
   if (!diffDetected) {
+    recordEvent(state, {
+      kind: "agent.implementation.no_diff",
+      checkpoint: result.checkpoint || null,
+      stage: "implement",
+      summary: implementation.summary || "Implementation adapter returned without leaving a detectable git diff.",
+      details: compactRecord({
+        worktree_path: workdir || null,
+        changed_files: implementation.changedFiles || [],
+        tests_run: implementation.testsRun || [],
+        implementation_notes: implementation.implementationNotes || null,
+        adapter_details: implementation.details || null
+      })
+    });
     return {
       blocker: {
         code: "implementation_diff_missing",
         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: { worktree_path: workdir || null }
+        details: compactRecord({
+          worktree_path: workdir || null,
+          changed_files: implementation.changedFiles || [],
+          tests_run: implementation.testsRun || [],
+          implementation_notes: implementation.implementationNotes || null,
+          adapter_details: implementation.details || null
+        })
       }
     };
   }
@@ -451,6 +493,9 @@ async function handleImplementation(request, state, result, agent) {
       worktree_path: workdir || null,
       diffDetected,
       changed_files: implementation.changedFiles || [],
+      tests_run: implementation.testsRun || [],
+      implementation_notes: implementation.implementationNotes || null,
+      adapter_details: implementation.details || null,
       cleaned_artifacts: cleanedArtifacts
     }
   });

package/dist/{chunk-3MHFLQKG.js → chunk-TV3XY7PG.js}

@@ -226,6 +226,8 @@ function recordStageAttempt(state, stage, entry = {}) {
     requested_advance_stage: entry.requestedAdvanceStage || null,
     halted_for_approval: Boolean(entry.haltedForApproval),
     auto_approved: Boolean(entry.autoApproved),
+    retryable: Boolean(entry.retryable),
+    checkpoint_disposition: entry.checkpointDisposition || null,
     error: entry.error || null,
     details: entry.details || {},
     attempted_at: (/* @__PURE__ */ new Date()).toISOString()
@@ -770,6 +772,8 @@ function summarizeState(state) {
     recon_hypothesis: state.recon_hypothesis || null,
     implementation_status: state.implementation_status || null,
     implementation_summary: state.implementation_summary || null,
+    implementation_detection_summary: state.implementation_detection_summary || null,
+    implementation_detection: state.implementation_detection || null,
     implementation_environment_issues: state.implementation_environment_issues || [],
     verify_status: state.verify_status || null,
     verify_summary: state.verify_summary || null,

package/dist/engine-harness.cjs

@@ -244,6 +244,8 @@ function recordStageAttempt(state, stage, entry = {}) {
     requested_advance_stage: entry.requestedAdvanceStage || null,
     halted_for_approval: Boolean(entry.haltedForApproval),
     auto_approved: Boolean(entry.autoApproved),
+    retryable: Boolean(entry.retryable),
+    checkpoint_disposition: entry.checkpointDisposition || null,
     error: entry.error || null,
     details: entry.details || {},
     attempted_at: (/* @__PURE__ */ new Date()).toISOString()
@@ -620,6 +622,8 @@ function summarizeState(state) {
     recon_hypothesis: state.recon_hypothesis || null,
     implementation_status: state.implementation_status || null,
     implementation_summary: state.implementation_summary || null,
+    implementation_detection_summary: state.implementation_detection_summary || null,
+    implementation_detection: state.implementation_detection || null,
     implementation_environment_issues: state.implementation_environment_issues || [],
     verify_status: state.verify_status || null,
     verify_summary: state.verify_summary || null,
@@ -1569,6 +1573,8 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         requestedAdvanceStage: effectiveAdvanceStage || null,
         haltedForApproval: extra.haltedForApproval,
         autoApproved: extra.autoApproved,
+        retryable: extra.retryable,
+        checkpointDisposition: extra.checkpointDisposition || null,
         error: extra.error || null,
         details: extra.details || {}
       });
@@ -2069,10 +2075,21 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
 ${implementRes.stdout || ""}
 ${implementRes.stderr || ""}`;
         if (implementError.includes("No implementation detected")) {
+          const implementationState = readState(config.statePath) || {};
+          const implementationSummary = stringValue(implementationState?.implementation_summary) || null;
+          const implementationDetectionSummary = stringValue(implementationState?.implementation_detection_summary) || null;
+          const implementationDetection = implementationState?.implementation_detection && typeof implementationState.implementation_detection === "object" && !Array.isArray(implementationState.implementation_detection) ? implementationState.implementation_detection : null;
           recordAttempt("implement", "checkpoint", "Implementation checkpoint found no material code changes yet.", {
             checkpoint: "implement_changes_missing",
             error: implementRes.error || null,
-            details: { executed }
+            retryable: true,
+            checkpointDisposition: "retryable_implementation_gap",
+            details: {
+              executed,
+              implementationSummary,
+              implementationDetectionSummary,
+              implementationDetection
+            }
           });
           return checkpoint(
             "implement",
@@ -2083,7 +2100,17 @@ ${implementRes.stderr || ""}`;
               advanceOptions: ["implement", "author", "recon"],
               recommendedAdvanceStage: "implement",
               blocking: true,
-              details: { executed },
+              retryable: true,
+              checkpointDisposition: "retryable_implementation_gap",
+              details: {
+                executed,
+                implementationSummary,
+                implementationDetectionSummary,
+                implementationDetection
+              },
+              implementationSummary,
+              implementationDetectionSummary,
+              implementationDetection,
               executed
             }
           );
@@ -3395,8 +3422,31 @@ async function handleImplementation(request, state, result, agent) {
       }
     };
   }
+  recordEvent(state, {
+    kind: "agent.implementation.started",
+    checkpoint: result.checkpoint || null,
+    stage: "implement",
+    summary: "Implementation agent started working in the after worktree.",
+    details: {
+      worktree_path: workdir || null
+    }
+  });
   const implementation = await agent.implementChange({ ...context, workdir });
   if (implementation.blocker || implementation.ok === false) {
+    recordEvent(state, {
+      kind: "agent.implementation.blocked",
+      checkpoint: result.checkpoint || null,
+      stage: "implement",
+      summary: implementation.summary || implementation.blocker?.message || "Implementation adapter reported a blocker.",
+      details: compactRecord({
+        worktree_path: workdir || null,
+        changed_files: implementation.changedFiles || [],
+        tests_run: implementation.testsRun || [],
+        implementation_notes: implementation.implementationNotes || null,
+        blocker: implementation.blocker || null,
+        adapter_details: implementation.details || null
+      })
+    });
     return {
       blocker: implementation.blocker || {
         code: "implementation_blocked",
@@ -3408,12 +3458,31 @@ async function handleImplementation(request, state, result, agent) {
   const cleanedArtifacts = removeEmptyToolArtifacts(workdir);
   const diffDetected = implementation.diffDetected === true || hasGitDiff(workdir);
   if (!diffDetected) {
+    recordEvent(state, {
+      kind: "agent.implementation.no_diff",
+      checkpoint: result.checkpoint || null,
+      stage: "implement",
+      summary: implementation.summary || "Implementation adapter returned without leaving a detectable git diff.",
+      details: compactRecord({
+        worktree_path: workdir || null,
+        changed_files: implementation.changedFiles || [],
+        tests_run: implementation.testsRun || [],
+        implementation_notes: implementation.implementationNotes || null,
+        adapter_details: implementation.details || null
+      })
+    });
     return {
       blocker: {
         code: "implementation_diff_missing",
         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: { worktree_path: workdir || null }
+        details: compactRecord({
+          worktree_path: workdir || null,
+          changed_files: implementation.changedFiles || [],
+          tests_run: implementation.testsRun || [],
+          implementation_notes: implementation.implementationNotes || null,
+          adapter_details: implementation.details || null
+        })
       }
     };
   }
@@ -3426,6 +3495,9 @@ async function handleImplementation(request, state, result, agent) {
       worktree_path: workdir || null,
       diffDetected,
       changed_files: implementation.changedFiles || [],
+      tests_run: implementation.testsRun || [],
+      implementation_notes: implementation.implementationNotes || null,
+      adapter_details: implementation.details || null,
       cleaned_artifacts: cleanedArtifacts
     }
   });

package/dist/engine-harness.d.cts

@@ -37,7 +37,9 @@ interface RiddleProofAgentPayload {
     blocker?: RiddleProofBlocker;
     diffDetected?: boolean;
     changedFiles?: string[];
+    testsRun?: string[];
     implementationNotes?: string;
+    details?: Record<string, unknown>;
 }
 interface RiddleProofEngineHarnessContext {
     request: RiddleProofRunParams;

package/dist/engine-harness.d.ts

@@ -37,7 +37,9 @@ interface RiddleProofAgentPayload {
     blocker?: RiddleProofBlocker;
     diffDetected?: boolean;
     changedFiles?: string[];
+    testsRun?: string[];
     implementationNotes?: string;
+    details?: Record<string, unknown>;
 }
 interface RiddleProofEngineHarnessContext {
     request: RiddleProofRunParams;

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-URO4JVMA.js";
+} from "./chunk-PJ3RTT5D.js";
 import "./chunk-7ZJAUEUN.js";
 import "./chunk-TMMKRKY5.js";
 export {

package/dist/index.cjs

@@ -244,6 +244,8 @@ function recordStageAttempt(state, stage, entry = {}) {
     requested_advance_stage: entry.requestedAdvanceStage || null,
     halted_for_approval: Boolean(entry.haltedForApproval),
     auto_approved: Boolean(entry.autoApproved),
+    retryable: Boolean(entry.retryable),
+    checkpoint_disposition: entry.checkpointDisposition || null,
     error: entry.error || null,
     details: entry.details || {},
     attempted_at: (/* @__PURE__ */ new Date()).toISOString()
@@ -620,6 +622,8 @@ function summarizeState(state) {
     recon_hypothesis: state.recon_hypothesis || null,
     implementation_status: state.implementation_status || null,
     implementation_summary: state.implementation_summary || null,
+    implementation_detection_summary: state.implementation_detection_summary || null,
+    implementation_detection: state.implementation_detection || null,
     implementation_environment_issues: state.implementation_environment_issues || [],
     verify_status: state.verify_status || null,
     verify_summary: state.verify_summary || null,
@@ -1569,6 +1573,8 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         requestedAdvanceStage: effectiveAdvanceStage || null,
         haltedForApproval: extra.haltedForApproval,
         autoApproved: extra.autoApproved,
+        retryable: extra.retryable,
+        checkpointDisposition: extra.checkpointDisposition || null,
         error: extra.error || null,
         details: extra.details || {}
       });
@@ -2069,10 +2075,21 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
 ${implementRes.stdout || ""}
 ${implementRes.stderr || ""}`;
         if (implementError.includes("No implementation detected")) {
+          const implementationState = readState(config.statePath) || {};
+          const implementationSummary = stringValue(implementationState?.implementation_summary) || null;
+          const implementationDetectionSummary = stringValue(implementationState?.implementation_detection_summary) || null;
+          const implementationDetection = implementationState?.implementation_detection && typeof implementationState.implementation_detection === "object" && !Array.isArray(implementationState.implementation_detection) ? implementationState.implementation_detection : null;
           recordAttempt("implement", "checkpoint", "Implementation checkpoint found no material code changes yet.", {
             checkpoint: "implement_changes_missing",
             error: implementRes.error || null,
-            details: { executed }
+            retryable: true,
+            checkpointDisposition: "retryable_implementation_gap",
+            details: {
+              executed,
+              implementationSummary,
+              implementationDetectionSummary,
+              implementationDetection
+            }
           });
           return checkpoint(
             "implement",
@@ -2083,7 +2100,17 @@ ${implementRes.stderr || ""}`;
               advanceOptions: ["implement", "author", "recon"],
               recommendedAdvanceStage: "implement",
               blocking: true,
-              details: { executed },
+              retryable: true,
+              checkpointDisposition: "retryable_implementation_gap",
+              details: {
+                executed,
+                implementationSummary,
+                implementationDetectionSummary,
+                implementationDetection
+              },
+              implementationSummary,
+              implementationDetectionSummary,
+              implementationDetection,
               executed
             }
           );
@@ -3951,8 +3978,31 @@ async function handleImplementation(request, state, result, agent) {
       }
     };
   }
+  recordEvent(state, {
+    kind: "agent.implementation.started",
+    checkpoint: result.checkpoint || null,
+    stage: "implement",
+    summary: "Implementation agent started working in the after worktree.",
+    details: {
+      worktree_path: workdir || null
+    }
+  });
   const implementation = await agent.implementChange({ ...context, workdir });
   if (implementation.blocker || implementation.ok === false) {
+    recordEvent(state, {
+      kind: "agent.implementation.blocked",
+      checkpoint: result.checkpoint || null,
+      stage: "implement",
+      summary: implementation.summary || implementation.blocker?.message || "Implementation adapter reported a blocker.",
+      details: compactRecord({
+        worktree_path: workdir || null,
+        changed_files: implementation.changedFiles || [],
+        tests_run: implementation.testsRun || [],
+        implementation_notes: implementation.implementationNotes || null,
+        blocker: implementation.blocker || null,
+        adapter_details: implementation.details || null
+      })
+    });
     return {
       blocker: implementation.blocker || {
         code: "implementation_blocked",
@@ -3964,12 +4014,31 @@ async function handleImplementation(request, state, result, agent) {
   const cleanedArtifacts = removeEmptyToolArtifacts(workdir);
   const diffDetected = implementation.diffDetected === true || hasGitDiff(workdir);
   if (!diffDetected) {
+    recordEvent(state, {
+      kind: "agent.implementation.no_diff",
+      checkpoint: result.checkpoint || null,
+      stage: "implement",
+      summary: implementation.summary || "Implementation adapter returned without leaving a detectable git diff.",
+      details: compactRecord({
+        worktree_path: workdir || null,
+        changed_files: implementation.changedFiles || [],
+        tests_run: implementation.testsRun || [],
+        implementation_notes: implementation.implementationNotes || null,
+        adapter_details: implementation.details || null
+      })
+    });
     return {
       blocker: {
         code: "implementation_diff_missing",
         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: { worktree_path: workdir || null }
+        details: compactRecord({
+          worktree_path: workdir || null,
+          changed_files: implementation.changedFiles || [],
+          tests_run: implementation.testsRun || [],
+          implementation_notes: implementation.implementationNotes || null,
+          adapter_details: implementation.details || null
+        })
       }
     };
   }
@@ -3982,6 +4051,9 @@ async function handleImplementation(request, state, result, agent) {
       worktree_path: workdir || null,
       diffDetected,
       changed_files: implementation.changedFiles || [],
+      tests_run: implementation.testsRun || [],
+      implementation_notes: implementation.implementationNotes || null,
+      adapter_details: implementation.details || null,
       cleaned_artifacts: cleanedArtifacts
     }
   });

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-URO4JVMA.js";
+} from "./chunk-PJ3RTT5D.js";
 import {
   runRiddleProof
 } from "./chunk-F6VFKS7K.js";

package/dist/proof-run-core.cjs

@@ -282,6 +282,8 @@ function recordStageAttempt(state, stage, entry = {}) {
     requested_advance_stage: entry.requestedAdvanceStage || null,
     halted_for_approval: Boolean(entry.haltedForApproval),
     auto_approved: Boolean(entry.autoApproved),
+    retryable: Boolean(entry.retryable),
+    checkpoint_disposition: entry.checkpointDisposition || null,
     error: entry.error || null,
     details: entry.details || {},
     attempted_at: (/* @__PURE__ */ new Date()).toISOString()
@@ -826,6 +828,8 @@ function summarizeState(state) {
     recon_hypothesis: state.recon_hypothesis || null,
     implementation_status: state.implementation_status || null,
     implementation_summary: state.implementation_summary || null,
+    implementation_detection_summary: state.implementation_detection_summary || null,
+    implementation_detection: state.implementation_detection || null,
     implementation_environment_issues: state.implementation_environment_issues || [],
     verify_status: state.verify_status || null,
     verify_summary: state.verify_summary || null,

package/dist/proof-run-core.d.cts

@@ -135,6 +135,8 @@ declare function recordStageAttempt(state: any, stage: WorkflowStage, entry?: {
     requestedAdvanceStage?: WorkflowStage | null;
     haltedForApproval?: boolean;
     autoApproved?: boolean;
+    retryable?: boolean;
+    checkpointDisposition?: string | null;
     error?: string | null;
     details?: Record<string, unknown>;
 }): {
@@ -146,6 +148,8 @@ declare function recordStageAttempt(state: any, stage: WorkflowStage, entry?: {
     requested_advance_stage: WorkflowStage | null;
     halted_for_approval: boolean;
     auto_approved: boolean;
+    retryable: boolean;
+    checkpoint_disposition: string | null;
     error: string | null;
     details: Record<string, unknown>;
     attempted_at: string;
@@ -236,6 +240,8 @@ declare function summarizeState(state: any): {
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;

package/dist/proof-run-core.d.ts

@@ -135,6 +135,8 @@ declare function recordStageAttempt(state: any, stage: WorkflowStage, entry?: {
     requestedAdvanceStage?: WorkflowStage | null;
     haltedForApproval?: boolean;
     autoApproved?: boolean;
+    retryable?: boolean;
+    checkpointDisposition?: string | null;
     error?: string | null;
     details?: Record<string, unknown>;
 }): {
@@ -146,6 +148,8 @@ declare function recordStageAttempt(state: any, stage: WorkflowStage, entry?: {
     requested_advance_stage: WorkflowStage | null;
     halted_for_approval: boolean;
     auto_approved: boolean;
+    retryable: boolean;
+    checkpoint_disposition: string | null;
     error: string | null;
     details: Record<string, unknown>;
     attempted_at: string;
@@ -236,6 +240,8 @@ declare function summarizeState(state: any): {
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;

package/dist/proof-run-core.js

@@ -21,7 +21,7 @@ import {
   validateShipGate,
   workflowFile,
   writeState
-} from "./chunk-3MHFLQKG.js";
+} from "./chunk-TV3XY7PG.js";
 export {
   BUNDLED_RIDDLE_PROOF_DIR,
   CHECKPOINT_CONTRACT_VERSION,

package/dist/proof-run-engine.cjs

@@ -267,6 +267,8 @@ function recordStageAttempt(state, stage, entry = {}) {
     requested_advance_stage: entry.requestedAdvanceStage || null,
     halted_for_approval: Boolean(entry.haltedForApproval),
     auto_approved: Boolean(entry.autoApproved),
+    retryable: Boolean(entry.retryable),
+    checkpoint_disposition: entry.checkpointDisposition || null,
     error: entry.error || null,
     details: entry.details || {},
     attempted_at: (/* @__PURE__ */ new Date()).toISOString()
@@ -811,6 +813,8 @@ function summarizeState(state) {
     recon_hypothesis: state.recon_hypothesis || null,
     implementation_status: state.implementation_status || null,
     implementation_summary: state.implementation_summary || null,
+    implementation_detection_summary: state.implementation_detection_summary || null,
+    implementation_detection: state.implementation_detection || null,
     implementation_environment_issues: state.implementation_environment_issues || [],
     verify_status: state.verify_status || null,
     verify_summary: state.verify_summary || null,
@@ -1567,6 +1571,8 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         requestedAdvanceStage: effectiveAdvanceStage || null,
         haltedForApproval: extra.haltedForApproval,
         autoApproved: extra.autoApproved,
+        retryable: extra.retryable,
+        checkpointDisposition: extra.checkpointDisposition || null,
         error: extra.error || null,
         details: extra.details || {}
       });
@@ -2067,10 +2073,21 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
 ${implementRes.stdout || ""}
 ${implementRes.stderr || ""}`;
         if (implementError.includes("No implementation detected")) {
+          const implementationState = readState(config.statePath) || {};
+          const implementationSummary = stringValue(implementationState?.implementation_summary) || null;
+          const implementationDetectionSummary = stringValue(implementationState?.implementation_detection_summary) || null;
+          const implementationDetection = implementationState?.implementation_detection && typeof implementationState.implementation_detection === "object" && !Array.isArray(implementationState.implementation_detection) ? implementationState.implementation_detection : null;
           recordAttempt("implement", "checkpoint", "Implementation checkpoint found no material code changes yet.", {
             checkpoint: "implement_changes_missing",
             error: implementRes.error || null,
-            details: { executed }
+            retryable: true,
+            checkpointDisposition: "retryable_implementation_gap",
+            details: {
+              executed,
+              implementationSummary,
+              implementationDetectionSummary,
+              implementationDetection
+            }
           });
           return checkpoint(
             "implement",
@@ -2081,7 +2098,17 @@ ${implementRes.stderr || ""}`;
               advanceOptions: ["implement", "author", "recon"],
               recommendedAdvanceStage: "implement",
               blocking: true,
-              details: { executed },
+              retryable: true,
+              checkpointDisposition: "retryable_implementation_gap",
+              details: {
+                executed,
+                implementationSummary,
+                implementationDetectionSummary,
+                implementationDetection
+              },
+              implementationSummary,
+              implementationDetectionSummary,
+              implementationDetection,
               executed
             }
           );

package/dist/proof-run-engine.d.cts

@@ -43,6 +43,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -130,6 +132,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -215,6 +219,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -293,6 +299,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -374,6 +382,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -459,6 +469,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -542,6 +554,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -620,6 +634,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;

package/dist/proof-run-engine.d.ts

@@ -43,6 +43,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -130,6 +132,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -215,6 +219,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -293,6 +299,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -374,6 +382,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -459,6 +469,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -542,6 +554,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;
@@ -620,6 +634,8 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
         recon_hypothesis: any;
         implementation_status: any;
         implementation_summary: any;
+        implementation_detection_summary: any;
+        implementation_detection: any;
         implementation_environment_issues: any;
         verify_status: any;
         verify_summary: any;

package/dist/proof-run-engine.js

@@ -14,7 +14,7 @@ import {
   validateShipGate,
   workflowFile,
   writeState
-} from "./chunk-3MHFLQKG.js";
+} from "./chunk-TV3XY7PG.js";
 
 // src/proof-run-engine.ts
 import { execFileSync } from "child_process";
@@ -718,6 +718,8 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         requestedAdvanceStage: effectiveAdvanceStage || null,
         haltedForApproval: extra.haltedForApproval,
         autoApproved: extra.autoApproved,
+        retryable: extra.retryable,
+        checkpointDisposition: extra.checkpointDisposition || null,
         error: extra.error || null,
         details: extra.details || {}
       });
@@ -1218,10 +1220,21 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
 ${implementRes.stdout || ""}
 ${implementRes.stderr || ""}`;
         if (implementError.includes("No implementation detected")) {
+          const implementationState = readState(config.statePath) || {};
+          const implementationSummary = stringValue(implementationState?.implementation_summary) || null;
+          const implementationDetectionSummary = stringValue(implementationState?.implementation_detection_summary) || null;
+          const implementationDetection = implementationState?.implementation_detection && typeof implementationState.implementation_detection === "object" && !Array.isArray(implementationState.implementation_detection) ? implementationState.implementation_detection : null;
           recordAttempt("implement", "checkpoint", "Implementation checkpoint found no material code changes yet.", {
             checkpoint: "implement_changes_missing",
             error: implementRes.error || null,
-            details: { executed }
+            retryable: true,
+            checkpointDisposition: "retryable_implementation_gap",
+            details: {
+              executed,
+              implementationSummary,
+              implementationDetectionSummary,
+              implementationDetection
+            }
           });
           return checkpoint(
             "implement",
@@ -1232,7 +1245,17 @@ ${implementRes.stderr || ""}`;
               advanceOptions: ["implement", "author", "recon"],
               recommendedAdvanceStage: "implement",
               blocking: true,
-              details: { executed },
+              retryable: true,
+              checkpointDisposition: "retryable_implementation_gap",
+              details: {
+                executed,
+                implementationSummary,
+                implementationDetectionSummary,
+                implementationDetection
+              },
+              implementationSummary,
+              implementationDetectionSummary,
+              implementationDetection,
               executed
             }
           );

package/dist/types.d.cts

@@ -103,6 +103,8 @@ interface RiddleProofRunState {
     notification?: Record<string, unknown>;
     proof_decision?: RiddleProofDecision;
     merge_recommendation?: string;
+    implementation_detection_summary?: string | null;
+    implementation_detection?: Record<string, unknown> | null;
     finalized?: boolean;
     blocker?: RiddleProofBlocker;
     events: RiddleProofEvent[];
@@ -162,6 +164,8 @@ interface RiddleProofRunStatusSnapshot {
     merged_at?: string;
     proof_comment_url?: string;
     cleanup_report?: Record<string, unknown>;
+    implementation_detection_summary?: string | null;
+    implementation_detection?: Record<string, unknown> | null;
     iterations: number;
     last_checkpoint?: string | null;
     updated_at: string;

package/dist/types.d.ts

@@ -103,6 +103,8 @@ interface RiddleProofRunState {
     notification?: Record<string, unknown>;
     proof_decision?: RiddleProofDecision;
     merge_recommendation?: string;
+    implementation_detection_summary?: string | null;
+    implementation_detection?: Record<string, unknown> | null;
     finalized?: boolean;
     blocker?: RiddleProofBlocker;
     events: RiddleProofEvent[];
@@ -162,6 +164,8 @@ interface RiddleProofRunStatusSnapshot {
     merged_at?: string;
     proof_comment_url?: string;
     cleanup_report?: Record<string, unknown>;
+    implementation_detection_summary?: string | null;
+    implementation_detection?: Record<string, unknown> | null;
     iterations: number;
     last_checkpoint?: string | null;
     updated_at: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",

package/runtime/lib/implement.py

@@ -9,6 +9,34 @@ import json, os, sys
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from util import load_state, save_state, git, shell_quote
 
+
+def unique_nonempty(items):
+    seen = set()
+    values = []
+    for item in items:
+        text = str(item or '').strip()
+        if not text or text in seen:
+            continue
+        seen.add(text)
+        values.append(text)
+    return values
+
+
+def parse_status_paths(lines):
+    paths = []
+    for line in lines:
+        text = str(line or '').rstrip()
+        if not text:
+            continue
+        path = text[3:] if len(text) > 3 else text
+        if ' -> ' in path:
+            path = path.split(' -> ', 1)[1]
+        path = path.strip()
+        if path:
+            paths.append(path)
+    return unique_nonempty(paths)
+
+
 s = load_state()
 after_dir = (s.get('after_worktree') or '').strip()
 if not after_dir or not os.path.exists(after_dir):
@@ -17,25 +45,72 @@ if not after_dir or not os.path.exists(after_dir):
 base_branch = s.get('base_branch', 'main')
 base_ref = (s.get('before_ref') or '').strip() or ('origin/' + base_branch)
 dirty = [ln for ln in git('git status --short', after_dir).stdout.splitlines() if ln.strip()]
+dirty_paths = parse_status_paths(dirty)
+
+diff_probes = []
+
+
+def run_diff_probe(label, command):
+    result = git(command, after_dir)
+    paths = unique_nonempty(result.stdout.splitlines())
+    diff_probes.append({
+        'label': label,
+        'command': command,
+        'returncode': result.returncode,
+        'paths': paths[:20],
+        'path_count': len(paths),
+    })
+    return result, paths
 
 diff_cmd = 'git diff --name-only ' + shell_quote(base_ref) + '...HEAD'
-diff_result = git(diff_cmd, after_dir)
-committed = [ln for ln in diff_result.stdout.splitlines() if ln.strip()]
+diff_result, committed = run_diff_probe('requested_base', diff_cmd)
 if diff_result.returncode != 0:
     fallback_base = base_branch
-    fallback_result = git('git diff --name-only ' + shell_quote(fallback_base) + '...HEAD', after_dir)
-    committed = [ln for ln in fallback_result.stdout.splitlines() if ln.strip()]
+    fallback_result, committed = run_diff_probe('branch_base', 'git diff --name-only ' + shell_quote(fallback_base) + '...HEAD')
 if diff_result.returncode != 0 and not committed:
-    fallback = git('git diff --name-only HEAD~1 HEAD', after_dir)
-    committed = [ln for ln in fallback.stdout.splitlines() if ln.strip()]
+    fallback, committed = run_diff_probe('head_parent', 'git diff --name-only HEAD~1 HEAD')
+
+changed = unique_nonempty(dirty_paths + committed)
+authored = bool((s.get('capture_script') or '').strip()) and bool((s.get('proof_plan') or '').strip())
 
-changed = []
-for line in dirty + committed:
-    item = line.strip()
-    if item and item not in changed:
-        changed.append(item)
+detection = {
+    'outcome': 'changes_detected' if changed else 'no_changes_detected',
+    'diff_detected': bool(changed),
+    'worktree_path': after_dir,
+    'base_branch': base_branch,
+    'base_ref_requested': base_ref,
+    'dirty_status_lines': dirty[:20],
+    'dirty_paths': dirty_paths[:20],
+    'dirty_path_count': len(dirty_paths),
+    'committed_paths': committed[:20],
+    'committed_path_count': len(committed),
+    'changed_paths': changed[:20],
+    'changed_path_count': len(changed),
+    'diff_probes': diff_probes[:6],
+    'authored_inputs_ready': authored,
+}
+
+if changed:
+    detection_summary = (
+        'Implementation detection found material changes '
+        f'(dirty={len(dirty_paths)}, committed={len(committed)}, changed={len(changed)}).'
+    )
+else:
+    probe_labels = ', '.join([probe.get('label', '') for probe in diff_probes if probe.get('label')]) or 'no probes'
+    detection_summary = (
+        'Implementation detection found no material code changes '
+        f'(dirty={len(dirty_paths)}, committed={len(committed)}, changed=0; probes={probe_labels}).'
+    )
+
+s['implementation_detection'] = detection
+s['implementation_detection_summary'] = detection_summary
 
 if not changed:
+    s['implementation_status'] = 'changes_missing'
+    s['implementation_summary'] = 'No implementation detected on the after worktree.'
+    s['changed_files'] = []
+    s['stage'] = 'implement'
+    save_state(s)
     raise SystemExit('No implementation detected on the after worktree. Make the code changes, then rerun riddle-proof-implement.')
 
 summary = 'Implementation detected in ' + str(len(changed)) + ' file(s): ' + ', '.join(changed[:8])
@@ -46,7 +121,6 @@ s['implementation_status'] = 'changes_detected'
 s['implementation_summary'] = summary
 s['changed_files'] = changed[:20]
 s['stage'] = 'implement'
-authored = bool((s.get('capture_script') or '').strip()) and bool((s.get('proof_plan') or '').strip())
 if authored:
     s['author_status'] = 'ready'
     s['proof_plan_status'] = 'ready'

package/runtime/tests/recon_verify_smoke.py

@@ -14,6 +14,7 @@ UTIL_PATH = LIB / 'util.py'
 RECON_PATH = LIB / 'recon.py'
 VERIFY_PATH = LIB / 'verify.py'
 AUTHOR_PATH = LIB / 'author.py'
+IMPLEMENT_PATH = LIB / 'implement.py'
 SHIP_PATH = LIB / 'ship.py'
 
 BUILD_SCRIPT = "python3 -c \"from pathlib import Path; Path('build').mkdir(exist_ok=True); Path('build/index.html').write_text('<html>ok</html>')\""
@@ -246,6 +247,14 @@ def make_project(root: Path, route_snippet: str):
     }, indent=2))
 
 
+def init_git_repo(root: Path):
+    sp.run(['git', 'init', '-b', 'main'], cwd=root, check=True, stdout=sp.DEVNULL, stderr=sp.DEVNULL)
+    sp.run(['git', 'config', 'user.email', 'proof@example.com'], cwd=root, check=True, stdout=sp.DEVNULL, stderr=sp.DEVNULL)
+    sp.run(['git', 'config', 'user.name', 'Proof Test'], cwd=root, check=True, stdout=sp.DEVNULL, stderr=sp.DEVNULL)
+    sp.run(['git', 'add', '.'], cwd=root, check=True, stdout=sp.DEVNULL, stderr=sp.DEVNULL)
+    sp.run(['git', 'commit', '-m', 'init'], cwd=root, check=True, stdout=sp.DEVNULL, stderr=sp.DEVNULL)
+
+
 def write_state(path: Path, payload: dict):
     path.write_text(json.dumps(payload, indent=2))
 
@@ -540,6 +549,59 @@ def run_project_build_retries_after_clean_failure():
         shutil.rmtree(tempdir)
 
 
+def run_implement_records_detection_when_changes_missing():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-implement-missing-'))
+    state_path = tempdir / 'state.json'
+    previous_state_file = os.environ.get('RIDDLE_PROOF_STATE_FILE')
+    try:
+        state = base_state(tempdir, reference='before')
+        after_dir = Path(state['after_worktree'])
+        init_git_repo(after_dir)
+        state.update({
+            'recon_status': 'ready_for_proof_plan',
+            'author_status': 'ready',
+            'proof_plan_status': 'ready',
+            'proof_plan': 'Capture the pricing CTA after the implementation is applied.',
+            'capture_script': "await page.waitForSelector('[data-testid=pricing-cta]'); await saveScreenshot('after-proof');",
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+
+        try:
+            load_module('implement_changes_missing_state', IMPLEMENT_PATH)
+        except SystemExit as exc:
+            assert 'No implementation detected on the after worktree.' in str(exc), exc
+        else:
+            raise AssertionError('implement stage should have halted when no diff exists')
+
+        after_state = json.loads(state_path.read_text())
+        assert after_state['implementation_status'] == 'changes_missing'
+        assert after_state['implementation_summary'] == 'No implementation detected on the after worktree.'
+        assert after_state['changed_files'] == []
+        assert after_state['stage'] == 'implement'
+        detection = after_state['implementation_detection']
+        assert detection['outcome'] == 'no_changes_detected'
+        assert detection['diff_detected'] is False
+        assert detection['dirty_path_count'] == 0
+        assert detection['committed_path_count'] == 0
+        assert detection['changed_path_count'] == 0
+        assert detection['authored_inputs_ready'] is True
+        assert detection['base_ref_requested'] == 'origin/main'
+        assert detection['diff_probes'][0]['label'] == 'requested_base'
+        assert after_state['implementation_detection_summary'].startswith('Implementation detection found no material code changes')
+        return {
+            'ok': True,
+            'outcome': detection['outcome'],
+            'summary': after_state['implementation_detection_summary'],
+        }
+    finally:
+        if previous_state_file is None:
+            os.environ.pop('RIDDLE_PROOF_STATE_FILE', None)
+        else:
+            os.environ['RIDDLE_PROOF_STATE_FILE'] = previous_state_file
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_recon_then_author_request():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-supervisor-request-'))
     state_path = tempdir / 'state.json'
@@ -1304,6 +1366,7 @@ if __name__ == '__main__':
         'capture_diagnostics_redaction': run_capture_diagnostics_redact_sensitive_values(),
         'apply_auth_context': run_apply_auth_context_passes_supported_auth_payloads(),
         'run_project_build_retries_after_clean_failure': run_project_build_retries_after_clean_failure(),
+        'implement_records_detection_when_changes_missing': run_implement_records_detection_when_changes_missing(),
         'verify_quality_ignores_proof_telemetry_console_text': run_verify_quality_ignores_proof_telemetry_console_text(),
         'recon_then_author_request': run_recon_then_author_request(),
         'recon_route_literal_preference': run_recon_prefers_route_literals_over_import_paths(),