@riddledc/riddle-proof 0.5.16 → 0.5.18

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
             }
           );

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-URO4JVMA.js";
+} from "./chunk-FVPNG3BA.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
             }
           );

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-URO4JVMA.js";
+} from "./chunk-FVPNG3BA.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.16",
+  "version": "0.5.18",
   "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/lib/verify.py

@@ -625,6 +625,111 @@ def collect_supporting_artifacts(payload):
     }
 
 
+def artifact_contract_for_mode(verification_mode):
+    mode = normalized_verification_mode(verification_mode)
+    return {
+        'verification_mode': mode,
+        'required': {
+            'baseline_context': True,
+            'route_semantics': True,
+            'screenshot': screenshot_required_for_mode(mode),
+            'proof_evidence': proof_evidence_required_for_mode(mode),
+        },
+        'preferred': {
+            'page_state': True,
+            'structured_payload': mode in STRUCTURED_FIRST_MODES or proof_evidence_required_for_mode(mode),
+            'visual_delta': visual_delta_applies(mode),
+        },
+        'optional': {
+            'console_summary': True,
+            'json_artifacts': True,
+            'image_outputs': True,
+        },
+    }
+
+
+def artifact_production_summary(payload, supporting):
+    artifact_summary = summarize_capture_artifacts(payload)
+    return {
+        'output_names': [str(item.get('name') or '') for item in (artifact_summary.get('outputs') or [])[:20]],
+        'screenshot_names': [str(item.get('name') or '') for item in (artifact_summary.get('screenshots') or [])[:10]],
+        'artifact_json': list(artifact_summary.get('artifact_json') or []),
+        'artifact_error_names': sorted((artifact_summary.get('artifact_errors') or {}).keys()),
+        'image_output_count': len(supporting.get('image_outputs') or []),
+        'data_output_count': len(supporting.get('data_outputs') or []),
+        'other_output_count': len(supporting.get('other_outputs') or []),
+        'console_entries': int(supporting.get('console_entries') or 0),
+        'structured_result_keys': list(supporting.get('structured_result_keys') or []),
+        'proof_evidence_present': bool(supporting.get('proof_evidence_present')),
+        'has_structured_payload': bool(supporting.get('has_structured_payload')),
+    }
+
+
+def artifact_signal_availability(state, after_observation, supporting, visual_delta, required_baseline_present, semantic_context):
+    details = (after_observation or {}).get('details') or {}
+    route = (semantic_context or {}).get('route') or {}
+    return {
+        'baseline_context': bool(required_baseline_present),
+        'route_semantics': bool(route.get('after_observed_path') or details.get('observed_path')),
+        'screenshot': bool(details.get('has_screenshot')),
+        'page_state': bool(
+            details.get('visible_text_sample')
+            or details.get('headings')
+            or details.get('buttons')
+            or details.get('links')
+            or details.get('semantic_anchor_count')
+        ),
+        'structured_payload': bool(supporting.get('has_structured_payload')),
+        'proof_evidence': bool(supporting.get('proof_evidence_present')),
+        'visual_delta': bool((visual_delta or {}).get('status') not in ('', None, 'not_applicable')),
+        'console_summary': bool(supporting.get('console_entries')),
+        'json_artifacts': bool(supporting.get('data_outputs')),
+        'image_outputs': bool(supporting.get('image_outputs')),
+        'assertions': bool(state.get('parsed_assertions')),
+        'success_criteria': bool((state.get('success_criteria') or '').strip()),
+    }
+
+
+def artifact_usage_summary(state, after_observation, supporting, visual_delta, required_baseline_present, semantic_context, evidence_basis):
+    contract = artifact_contract_for_mode(state.get('verification_mode'))
+    available = artifact_signal_availability(
+        state,
+        after_observation,
+        supporting,
+        visual_delta,
+        required_baseline_present,
+        semantic_context,
+    )
+    capture_quality = []
+    details = (after_observation or {}).get('details') or {}
+    if details.get('has_screenshot'):
+        capture_quality.append('screenshot')
+    if available.get('page_state'):
+        capture_quality.append('page_state')
+    if available.get('console_summary'):
+        capture_quality.append('console_summary')
+    if available.get('structured_payload'):
+        capture_quality.append('structured_payload')
+    if available.get('proof_evidence'):
+        capture_quality.append('proof_evidence')
+    if available.get('visual_delta'):
+        capture_quality.append('visual_delta')
+
+    required_signals = [key for key, enabled in (contract.get('required') or {}).items() if enabled]
+    preferred_signals = [key for key, enabled in (contract.get('preferred') or {}).items() if enabled]
+    optional_signals = [key for key, enabled in (contract.get('optional') or {}).items() if enabled]
+
+    return {
+        'required_signals': required_signals,
+        'preferred_signals': preferred_signals,
+        'optional_signals': optional_signals,
+        'available_signals': [key for key, enabled in available.items() if enabled],
+        'missing_required_signals': [key for key in required_signals if not available.get(key)],
+        'capture_quality_signals': capture_quality,
+        'supervisor_review_signals': list(evidence_basis or []),
+    }
+
+
 def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
     payload = enrich_capture_payload(payload)
     mode = normalized_verification_mode(verification_mode)
@@ -863,6 +968,17 @@ def build_evidence_bundle(state, results, after_payload, after_observation, requ
         else {'status': 'not_applicable', 'passed': None, 'reason': 'Verification mode does not require visual delta gating.'}
     )
     semantic_context = build_semantic_context(state, results, after_observation, expected_path)
+    artifact_contract = artifact_contract_for_mode(state.get('verification_mode'))
+    artifact_production = artifact_production_summary(after_payload, supporting)
+    artifact_usage = artifact_usage_summary(
+        state,
+        after_observation,
+        supporting,
+        visual_delta,
+        required_baseline_present,
+        semantic_context,
+        [],
+    )
     return {
         'verification_mode': normalized_verification_mode(state.get('verification_mode')),
         'reference': state.get('requested_reference') or state.get('reference', 'both'),
@@ -870,6 +986,9 @@ def build_evidence_bundle(state, results, after_payload, after_observation, requ
         'required_baseline_present': required_baseline_present,
         'baseline': results.get('baseline') or {},
         'semantic_context': semantic_context,
+        'artifact_contract': artifact_contract,
+        'artifact_production': artifact_production,
+        'artifact_usage': artifact_usage,
         'after': {
             'screenshot_url': state.get('after_cdn') or '',
             'observation': after_observation,
@@ -910,6 +1029,26 @@ def build_supervisor_assessment_request(state, payload, after_observation, requi
     if has_success_criteria:
         evidence_basis.append('success-criteria')
 
+    artifact_contract = (evidence_bundle or {}).get('artifact_contract') if isinstance(evidence_bundle, dict) else None
+    if not isinstance(artifact_contract, dict):
+        artifact_contract = artifact_contract_for_mode(verification_mode)
+    artifact_production = (evidence_bundle or {}).get('artifact_production') if isinstance(evidence_bundle, dict) else None
+    if not isinstance(artifact_production, dict):
+        artifact_production = artifact_production_summary(payload, supporting)
+    artifact_usage = artifact_usage_summary(
+        state,
+        after_observation,
+        supporting,
+        visual_delta,
+        required_baseline_present,
+        semantic_context,
+        evidence_basis,
+    )
+    if isinstance(evidence_bundle, dict):
+        evidence_bundle['artifact_contract'] = artifact_contract
+        evidence_bundle['artifact_production'] = artifact_production
+        evidence_bundle['artifact_usage'] = artifact_usage
+
     return {
         'status': 'needs_supervising_agent_assessment',
         'verification_mode': verification_mode,
@@ -921,6 +1060,9 @@ def build_supervisor_assessment_request(state, payload, after_observation, requi
         'semantic_context': semantic_context,
         'evidence_bundle': evidence_bundle or {},
         'evidence_basis': evidence_basis,
+        'artifact_contract': artifact_contract,
+        'artifact_production': artifact_production,
+        'artifact_usage': artifact_usage,
         'instructions': [
             'The supervising agent owns proof assessment. Inspect the recon baseline(s), after evidence, and any structured artifacts together.',
             'Decide whether the evidence is ready_to_ship or should continue internally through author, implement, or recon.',

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'
@@ -790,6 +852,20 @@ def run_verify_requests_supervisor_assessment():
         assert semantic_context['after']['headings'] == ['Pricing'], semantic_context
         assert 'semantic-context' in after_verify['proof_assessment_request']['evidence_basis']
         assert after_verify['proof_assessment_request']['evidence_bundle']['semantic_context']['after']['buttons'] == ['Buy Now']
+        artifact_contract = after_verify['proof_assessment_request']['artifact_contract']
+        assert artifact_contract['required']['baseline_context'] is True
+        assert artifact_contract['required']['screenshot'] is True
+        artifact_production = after_verify['proof_assessment_request']['artifact_production']
+        assert artifact_production['image_output_count'] >= 1
+        assert artifact_production['proof_evidence_present'] is False
+        artifact_usage = after_verify['proof_assessment_request']['artifact_usage']
+        assert artifact_usage['missing_required_signals'] == []
+        assert 'after-capture' in artifact_usage['supervisor_review_signals']
+        assert 'baseline_context' in artifact_usage['required_signals']
+        assert 'route_semantics' in artifact_usage['available_signals']
+        assert after_verify['proof_assessment_request']['evidence_bundle']['artifact_contract']['required']['screenshot'] is True
+        assert after_verify['proof_assessment_request']['evidence_bundle']['artifact_production']['image_output_count'] >= 1
+        assert after_verify['proof_assessment_request']['evidence_bundle']['artifact_usage']['missing_required_signals'] == []
         assert 'capture success is not proof' in '\n'.join(after_verify['proof_assessment_request']['instructions'])
         assert after_verify['verify_decision_request']['continue_with_stage'] is None
         assert after_verify['verify_results']['baseline']['before']['source'] == 'recon'
@@ -1290,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(),