@riddledc/riddle-proof 0.8.8 → 0.8.10

package/dist/{chunk-V6VZ3CAI.js → chunk-2PXL3RDB.js}

@@ -22,14 +22,14 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-E7ATYSYS.js";
+} from "./chunk-BBUO7HM4.js";
 import {
   createCheckpointResponseTemplate
 } from "./chunk-4FOHZ7JG.js";
 import {
   createCodexExecAgentAdapter,
   runCodexExecAgentDoctor
-} from "./chunk-PYCQNK66.js";
+} from "./chunk-EEIYUZXE.js";
 
 // src/cli.ts
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";

package/dist/{chunk-E7ATYSYS.js → chunk-BBUO7HM4.js}

@@ -1331,6 +1331,18 @@ async function routeCheckpoint(request, state, result, agent, input) {
   if (checkpoint === "verify_agent_retry") {
     const next = recommendedContinuation(result);
     if (next) return { next };
+    return {
+      blocker: {
+        code: "proof_assessment_blocked",
+        checkpoint,
+        message: result.summary || "The supervising proof assessment did not approve shipping and did not provide a safe retry continuation.",
+        details: compactRecord({
+          proofAssessment: result.proofAssessment || result.checkpointContract?.proof_assessment || recordValue(result.raw)?.proofAssessment || null,
+          verifyDecisionRequest: result.verifyDecisionRequest || result.checkpointContract?.verify_decision_request || null,
+          checkpointContract: result.checkpointContract || null
+        })
+      }
+    };
   }
   if (checkpoint === "awaiting_stage_advance") {
     const next = recommendedContinuation(result) || defaultAwaitingStageContinuation(result);

package/dist/{chunk-PYCQNK66.js → chunk-EEIYUZXE.js}

@@ -7,6 +7,8 @@ import { execFileSync, spawnSync } from "child_process";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
 import os from "os";
 import path from "path";
+var DEFAULT_CODEX_TIMEOUT_MS = 6e5;
+var DEFAULT_PROOF_PACKET_AUTHOR_TIMEOUT_MS = 18e4;
 var REFINED_INPUTS_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -350,6 +352,46 @@ function parseJsonFromRunnerOutputs(outputs, schema) {
   if (!combined.trim() || seen.has(combined)) return { parsed: null, source: "" };
   return { parsed: parseJsonObject(combined, schema), source: "combined_output" };
 }
+function resolveCodexTimeoutMs(config, request) {
+  if (typeof config.codexTimeoutMs === "number" && Number.isFinite(config.codexTimeoutMs) && config.codexTimeoutMs > 0) {
+    return Number(config.codexTimeoutMs);
+  }
+  return request.purpose === "proof packet authoring" ? DEFAULT_PROOF_PACKET_AUTHOR_TIMEOUT_MS : DEFAULT_CODEX_TIMEOUT_MS;
+}
+function isCodexLifecycleEvent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const type = value.type;
+  return typeof type === "string" && (type.startsWith("thread.") || type.startsWith("turn.") || type.startsWith("exec.") || type.startsWith("agent.") || type.startsWith("token.") || type.startsWith("reasoning.") || type.startsWith("error."));
+}
+function analyzeCodexRunnerOutput(outputs) {
+  const eventTypes = /* @__PURE__ */ new Set();
+  let eventLineCount = 0;
+  let nonEventLineCount = 0;
+  const nonEventSamples = [];
+  for (const output of outputs) {
+    const lines = output.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (isCodexLifecycleEvent(parsed)) {
+          eventLineCount += 1;
+          eventTypes.add(parsed.type);
+          continue;
+        }
+      } catch {
+      }
+      nonEventLineCount += 1;
+      if (nonEventSamples.length < 3) nonEventSamples.push(line.slice(0, 240));
+    }
+  }
+  return {
+    eventLineCount,
+    eventTypes: Array.from(eventTypes),
+    nonEventLineCount,
+    nonEventSamples,
+    onlyLifecycleEvents: eventLineCount > 0 && nonEventLineCount === 0
+  };
+}
 function isHarnessVerificationOnlyBlocker(blocker) {
   const text = blocker.toLowerCase();
   return (text.includes("erofs") || text.includes("read-only file system")) && text.includes("node_modules") && (text.includes(".vite-temp") || text.includes("vite.config"));
@@ -373,21 +415,25 @@ function runnerMetrics(input) {
     exit_status: input.status ?? null,
     timed_out: input.timedOut || false,
     error_code: input.errorCode,
+    codex_event_types: input.codexEventTypes && input.codexEventTypes.length ? input.codexEventTypes : void 0,
+    codex_event_line_count: input.codexEventLineCount,
+    codex_non_event_line_count: input.codexNonEventLineCount,
     codex_command: input.config.codexCommand || "codex",
     codex_model: input.config.codexModel,
     codex_sandbox: input.config.codexSandbox || "workspace-write",
     codex_full_auto: input.config.codexFullAuto !== false,
-    timeout_ms: Number(input.config.codexTimeoutMs || 6e5)
+    timeout_ms: input.timeoutMs ?? DEFAULT_CODEX_TIMEOUT_MS
   });
 }
 function createCodexExecJsonRunner(config = {}) {
   return (request) => {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startedMs = Date.now();
+    const timeoutMs = resolveCodexTimeoutMs(config, request);
     if (!request.workdir || !existsSync(request.workdir)) {
       return {
         ok: false,
-        metrics: runnerMetrics({ request, config, startedAt, startedMs, errorCode: "workdir_missing" }),
+        metrics: runnerMetrics({ request, config, startedAt, startedMs, timeoutMs, errorCode: "workdir_missing" }),
         blocker: {
           code: "codex_workdir_missing",
           message: `Codex workdir does not exist for ${request.purpose}.`,
@@ -422,7 +468,7 @@ function createCodexExecJsonRunner(config = {}) {
       const proc = spawnSync(config.codexCommand || "codex", args, {
         input: request.prompt,
         encoding: "utf-8",
-        timeout: Number(config.codexTimeoutMs || 6e5),
+        timeout: timeoutMs,
         maxBuffer: 10 * 1024 * 1024,
         env
       });
@@ -441,6 +487,7 @@ function createCodexExecJsonRunner(config = {}) {
             stderr: proc.stderr || "",
             status: proc.status,
             timedOut,
+            timeoutMs,
             errorCode: proc.error.code || "spawn_error"
           }),
           blocker: {
@@ -463,6 +510,7 @@ function createCodexExecJsonRunner(config = {}) {
             stdout: proc.stdout || "",
             stderr: proc.stderr || "",
             status: proc.status,
+            timeoutMs,
             errorCode: "nonzero_exit"
           }),
           blocker: {
@@ -475,12 +523,15 @@ function createCodexExecJsonRunner(config = {}) {
       const finalText = existsSync(lastMessagePath) ? readFileSync(lastMessagePath, "utf-8") : String(proc.stdout || "");
       const stdoutText = String(proc.stdout || "");
       const stderrText = String(proc.stderr || "");
-      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs([
+      const runnerOutputs = [
         { source: existsSync(lastMessagePath) ? "last_message" : "stdout", text: finalText },
         { source: "stdout", text: stdoutText },
         { source: "stderr", text: stderrText }
-      ], request.schema);
+      ];
+      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs(runnerOutputs, request.schema);
       if (!parsed) {
+        const outputAnalysis = analyzeCodexRunnerOutput(runnerOutputs);
+        const errorCode = outputAnalysis.onlyLifecycleEvents ? "no_final_response" : "invalid_json";
         return {
           ok: false,
           stdout: stdoutText,
@@ -494,12 +545,24 @@ function createCodexExecJsonRunner(config = {}) {
             stderr: stderrText,
             finalText,
             status: proc.status,
-            errorCode: "invalid_json"
+            timeoutMs,
+            errorCode,
+            codexEventTypes: outputAnalysis.eventTypes,
+            codexEventLineCount: outputAnalysis.eventLineCount,
+            codexNonEventLineCount: outputAnalysis.nonEventLineCount
           }),
           blocker: {
-            code: "codex_invalid_json",
-            message: `Codex completed ${request.purpose}, but did not return valid JSON.`,
-            details: { finalText, stdout: stdoutText, stderr: stderrText }
+            code: outputAnalysis.onlyLifecycleEvents ? "codex_no_final_response" : "codex_invalid_json",
+            message: outputAnalysis.onlyLifecycleEvents ? `Codex emitted lifecycle events during ${request.purpose}, but did not produce a final JSON response.` : `Codex completed ${request.purpose}, but did not return valid JSON.`,
+            details: {
+              finalText,
+              stdout: stdoutText,
+              stderr: stderrText,
+              event_types: outputAnalysis.eventTypes,
+              event_line_count: outputAnalysis.eventLineCount,
+              non_event_line_count: outputAnalysis.nonEventLineCount,
+              non_event_samples: outputAnalysis.nonEventSamples
+            }
           }
         };
       }
@@ -517,7 +580,8 @@ function createCodexExecJsonRunner(config = {}) {
           stderr: stderrText,
           finalText,
           parsedJsonSource,
-          status: proc.status
+          status: proc.status,
+          timeoutMs
         })
       };
     } finally {
@@ -626,6 +690,7 @@ function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRu
           "Write a proof_plan and capture_script that will verify the exact user-facing change.",
           "Use recon_assessment.baseline_understanding as the source of truth. Do not author a proof plan unless it names the observed before state and the requested delta from that state.",
           "Use the recon-approved route and baseline context; make the plan name the concrete target, expected before state, expected after state, and stop condition.",
+          "Do not leave this authoring stage pending for external investigation. Keep any repo inspection brief, do not modify files, and return the JSON proof packet from the available state.",
           "Choose the evidence modality from verification_mode and success_criteria: screenshots for visual/UI proof, interactions plus screenshots for interaction proof, structured metrics/logs/JSON/audio analysis for non-visual proof.",
           "For playable/gameplay proof, treat screenshots as supporting artifacts only: start the game, send keyboard or pointer input, measure state before/after, measure non-HUD canvas/playfield pixel deltas across time, and return playability evidence with version riddle-proof.playability.v1.",
           "For interaction proof, return a structured evidence object with start route/state, terminal route/state, action, assertions, and matched UI text. Catch waitForURL or selector timeouts and record them as failed assertions instead of throwing before evidence is emitted.",

package/dist/cli/index.js

@@ -1,12 +1,12 @@
-import "../chunk-V6VZ3CAI.js";
+import "../chunk-2PXL3RDB.js";
 import "../chunk-PEWAIEER.js";
 import "../chunk-TWTEUS7R.js";
-import "../chunk-E7ATYSYS.js";
+import "../chunk-BBUO7HM4.js";
 import "../chunk-YZUVEJ5B.js";
 import "../chunk-FMOYUYH2.js";
 import "../chunk-5N5QFI2S.js";
 import "../chunk-4FOHZ7JG.js";
 import "../chunk-JFQXAJH2.js";
-import "../chunk-PYCQNK66.js";
+import "../chunk-EEIYUZXE.js";
 import "../chunk-VY4Y5U57.js";
 import "../chunk-MLKGABMK.js";

package/dist/cli.cjs

@@ -5656,6 +5656,18 @@ async function routeCheckpoint(request, state, result, agent, input) {
   if (checkpoint === "verify_agent_retry") {
     const next = recommendedContinuation(result);
     if (next) return { next };
+    return {
+      blocker: {
+        code: "proof_assessment_blocked",
+        checkpoint,
+        message: result.summary || "The supervising proof assessment did not approve shipping and did not provide a safe retry continuation.",
+        details: compactRecord({
+          proofAssessment: result.proofAssessment || result.checkpointContract?.proof_assessment || recordValue(result.raw)?.proofAssessment || null,
+          verifyDecisionRequest: result.verifyDecisionRequest || result.checkpointContract?.verify_decision_request || null,
+          checkpointContract: result.checkpointContract || null
+        })
+      }
+    };
   }
   if (checkpoint === "awaiting_stage_advance") {
     const next = recommendedContinuation(result) || defaultAwaitingStageContinuation(result);
@@ -5868,6 +5880,8 @@ var import_node_child_process3 = require("child_process");
 var import_node_fs4 = require("fs");
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
+var DEFAULT_CODEX_TIMEOUT_MS = 6e5;
+var DEFAULT_PROOF_PACKET_AUTHOR_TIMEOUT_MS = 18e4;
 var REFINED_INPUTS_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -6211,6 +6225,46 @@ function parseJsonFromRunnerOutputs(outputs, schema) {
   if (!combined.trim() || seen.has(combined)) return { parsed: null, source: "" };
   return { parsed: parseJsonObject(combined, schema), source: "combined_output" };
 }
+function resolveCodexTimeoutMs(config, request) {
+  if (typeof config.codexTimeoutMs === "number" && Number.isFinite(config.codexTimeoutMs) && config.codexTimeoutMs > 0) {
+    return Number(config.codexTimeoutMs);
+  }
+  return request.purpose === "proof packet authoring" ? DEFAULT_PROOF_PACKET_AUTHOR_TIMEOUT_MS : DEFAULT_CODEX_TIMEOUT_MS;
+}
+function isCodexLifecycleEvent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const type = value.type;
+  return typeof type === "string" && (type.startsWith("thread.") || type.startsWith("turn.") || type.startsWith("exec.") || type.startsWith("agent.") || type.startsWith("token.") || type.startsWith("reasoning.") || type.startsWith("error."));
+}
+function analyzeCodexRunnerOutput(outputs) {
+  const eventTypes = /* @__PURE__ */ new Set();
+  let eventLineCount = 0;
+  let nonEventLineCount = 0;
+  const nonEventSamples = [];
+  for (const output of outputs) {
+    const lines = output.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (isCodexLifecycleEvent(parsed)) {
+          eventLineCount += 1;
+          eventTypes.add(parsed.type);
+          continue;
+        }
+      } catch {
+      }
+      nonEventLineCount += 1;
+      if (nonEventSamples.length < 3) nonEventSamples.push(line.slice(0, 240));
+    }
+  }
+  return {
+    eventLineCount,
+    eventTypes: Array.from(eventTypes),
+    nonEventLineCount,
+    nonEventSamples,
+    onlyLifecycleEvents: eventLineCount > 0 && nonEventLineCount === 0
+  };
+}
 function isHarnessVerificationOnlyBlocker(blocker) {
   const text = blocker.toLowerCase();
   return (text.includes("erofs") || text.includes("read-only file system")) && text.includes("node_modules") && (text.includes(".vite-temp") || text.includes("vite.config"));
@@ -6234,21 +6288,25 @@ function runnerMetrics(input) {
     exit_status: input.status ?? null,
     timed_out: input.timedOut || false,
     error_code: input.errorCode,
+    codex_event_types: input.codexEventTypes && input.codexEventTypes.length ? input.codexEventTypes : void 0,
+    codex_event_line_count: input.codexEventLineCount,
+    codex_non_event_line_count: input.codexNonEventLineCount,
     codex_command: input.config.codexCommand || "codex",
     codex_model: input.config.codexModel,
     codex_sandbox: input.config.codexSandbox || "workspace-write",
     codex_full_auto: input.config.codexFullAuto !== false,
-    timeout_ms: Number(input.config.codexTimeoutMs || 6e5)
+    timeout_ms: input.timeoutMs ?? DEFAULT_CODEX_TIMEOUT_MS
   });
 }
 function createCodexExecJsonRunner(config = {}) {
   return (request) => {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startedMs = Date.now();
+    const timeoutMs = resolveCodexTimeoutMs(config, request);
     if (!request.workdir || !(0, import_node_fs4.existsSync)(request.workdir)) {
       return {
         ok: false,
-        metrics: runnerMetrics({ request, config, startedAt, startedMs, errorCode: "workdir_missing" }),
+        metrics: runnerMetrics({ request, config, startedAt, startedMs, timeoutMs, errorCode: "workdir_missing" }),
         blocker: {
           code: "codex_workdir_missing",
           message: `Codex workdir does not exist for ${request.purpose}.`,
@@ -6283,7 +6341,7 @@ function createCodexExecJsonRunner(config = {}) {
       const proc = (0, import_node_child_process3.spawnSync)(config.codexCommand || "codex", args, {
         input: request.prompt,
         encoding: "utf-8",
-        timeout: Number(config.codexTimeoutMs || 6e5),
+        timeout: timeoutMs,
         maxBuffer: 10 * 1024 * 1024,
         env
       });
@@ -6302,6 +6360,7 @@ function createCodexExecJsonRunner(config = {}) {
             stderr: proc.stderr || "",
             status: proc.status,
             timedOut,
+            timeoutMs,
             errorCode: proc.error.code || "spawn_error"
           }),
           blocker: {
@@ -6324,6 +6383,7 @@ function createCodexExecJsonRunner(config = {}) {
             stdout: proc.stdout || "",
             stderr: proc.stderr || "",
             status: proc.status,
+            timeoutMs,
             errorCode: "nonzero_exit"
           }),
           blocker: {
@@ -6336,12 +6396,15 @@ function createCodexExecJsonRunner(config = {}) {
       const finalText = (0, import_node_fs4.existsSync)(lastMessagePath) ? (0, import_node_fs4.readFileSync)(lastMessagePath, "utf-8") : String(proc.stdout || "");
       const stdoutText = String(proc.stdout || "");
       const stderrText = String(proc.stderr || "");
-      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs([
+      const runnerOutputs = [
         { source: (0, import_node_fs4.existsSync)(lastMessagePath) ? "last_message" : "stdout", text: finalText },
         { source: "stdout", text: stdoutText },
         { source: "stderr", text: stderrText }
-      ], request.schema);
+      ];
+      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs(runnerOutputs, request.schema);
       if (!parsed) {
+        const outputAnalysis = analyzeCodexRunnerOutput(runnerOutputs);
+        const errorCode = outputAnalysis.onlyLifecycleEvents ? "no_final_response" : "invalid_json";
         return {
           ok: false,
           stdout: stdoutText,
@@ -6355,12 +6418,24 @@ function createCodexExecJsonRunner(config = {}) {
             stderr: stderrText,
             finalText,
             status: proc.status,
-            errorCode: "invalid_json"
+            timeoutMs,
+            errorCode,
+            codexEventTypes: outputAnalysis.eventTypes,
+            codexEventLineCount: outputAnalysis.eventLineCount,
+            codexNonEventLineCount: outputAnalysis.nonEventLineCount
           }),
           blocker: {
-            code: "codex_invalid_json",
-            message: `Codex completed ${request.purpose}, but did not return valid JSON.`,
-            details: { finalText, stdout: stdoutText, stderr: stderrText }
+            code: outputAnalysis.onlyLifecycleEvents ? "codex_no_final_response" : "codex_invalid_json",
+            message: outputAnalysis.onlyLifecycleEvents ? `Codex emitted lifecycle events during ${request.purpose}, but did not produce a final JSON response.` : `Codex completed ${request.purpose}, but did not return valid JSON.`,
+            details: {
+              finalText,
+              stdout: stdoutText,
+              stderr: stderrText,
+              event_types: outputAnalysis.eventTypes,
+              event_line_count: outputAnalysis.eventLineCount,
+              non_event_line_count: outputAnalysis.nonEventLineCount,
+              non_event_samples: outputAnalysis.nonEventSamples
+            }
           }
         };
       }
@@ -6378,7 +6453,8 @@ function createCodexExecJsonRunner(config = {}) {
           stderr: stderrText,
           finalText,
           parsedJsonSource,
-          status: proc.status
+          status: proc.status,
+          timeoutMs
         })
       };
     } finally {
@@ -6487,6 +6563,7 @@ function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRu
           "Write a proof_plan and capture_script that will verify the exact user-facing change.",
           "Use recon_assessment.baseline_understanding as the source of truth. Do not author a proof plan unless it names the observed before state and the requested delta from that state.",
           "Use the recon-approved route and baseline context; make the plan name the concrete target, expected before state, expected after state, and stop condition.",
+          "Do not leave this authoring stage pending for external investigation. Keep any repo inspection brief, do not modify files, and return the JSON proof packet from the available state.",
           "Choose the evidence modality from verification_mode and success_criteria: screenshots for visual/UI proof, interactions plus screenshots for interaction proof, structured metrics/logs/JSON/audio analysis for non-visual proof.",
           "For playable/gameplay proof, treat screenshots as supporting artifacts only: start the game, send keyboard or pointer input, measure state before/after, measure non-HUD canvas/playfield pixel deltas across time, and return playability evidence with version riddle-proof.playability.v1.",
           "For interaction proof, return a structured evidence object with start route/state, terminal route/state, action, assertions, and matched UI text. Catch waitForURL or selector timeouts and record them as failed assertions instead of throwing before evidence is emitted.",

package/dist/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import "./chunk-V6VZ3CAI.js";
+import "./chunk-2PXL3RDB.js";
 import "./chunk-PEWAIEER.js";
 import "./chunk-TWTEUS7R.js";
-import "./chunk-E7ATYSYS.js";
+import "./chunk-BBUO7HM4.js";
 import "./chunk-YZUVEJ5B.js";
 import "./chunk-FMOYUYH2.js";
 import "./chunk-5N5QFI2S.js";
 import "./chunk-4FOHZ7JG.js";
 import "./chunk-JFQXAJH2.js";
-import "./chunk-PYCQNK66.js";
+import "./chunk-EEIYUZXE.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";

package/dist/codex-exec-agent.cjs

@@ -46,6 +46,8 @@ function compactRecord(input) {
 }
 
 // src/codex-exec-agent.ts
+var DEFAULT_CODEX_TIMEOUT_MS = 6e5;
+var DEFAULT_PROOF_PACKET_AUTHOR_TIMEOUT_MS = 18e4;
 var REFINED_INPUTS_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -389,6 +391,46 @@ function parseJsonFromRunnerOutputs(outputs, schema) {
   if (!combined.trim() || seen.has(combined)) return { parsed: null, source: "" };
   return { parsed: parseJsonObject(combined, schema), source: "combined_output" };
 }
+function resolveCodexTimeoutMs(config, request) {
+  if (typeof config.codexTimeoutMs === "number" && Number.isFinite(config.codexTimeoutMs) && config.codexTimeoutMs > 0) {
+    return Number(config.codexTimeoutMs);
+  }
+  return request.purpose === "proof packet authoring" ? DEFAULT_PROOF_PACKET_AUTHOR_TIMEOUT_MS : DEFAULT_CODEX_TIMEOUT_MS;
+}
+function isCodexLifecycleEvent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const type = value.type;
+  return typeof type === "string" && (type.startsWith("thread.") || type.startsWith("turn.") || type.startsWith("exec.") || type.startsWith("agent.") || type.startsWith("token.") || type.startsWith("reasoning.") || type.startsWith("error."));
+}
+function analyzeCodexRunnerOutput(outputs) {
+  const eventTypes = /* @__PURE__ */ new Set();
+  let eventLineCount = 0;
+  let nonEventLineCount = 0;
+  const nonEventSamples = [];
+  for (const output of outputs) {
+    const lines = output.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (isCodexLifecycleEvent(parsed)) {
+          eventLineCount += 1;
+          eventTypes.add(parsed.type);
+          continue;
+        }
+      } catch {
+      }
+      nonEventLineCount += 1;
+      if (nonEventSamples.length < 3) nonEventSamples.push(line.slice(0, 240));
+    }
+  }
+  return {
+    eventLineCount,
+    eventTypes: Array.from(eventTypes),
+    nonEventLineCount,
+    nonEventSamples,
+    onlyLifecycleEvents: eventLineCount > 0 && nonEventLineCount === 0
+  };
+}
 function isHarnessVerificationOnlyBlocker(blocker) {
   const text = blocker.toLowerCase();
   return (text.includes("erofs") || text.includes("read-only file system")) && text.includes("node_modules") && (text.includes(".vite-temp") || text.includes("vite.config"));
@@ -412,21 +454,25 @@ function runnerMetrics(input) {
     exit_status: input.status ?? null,
     timed_out: input.timedOut || false,
     error_code: input.errorCode,
+    codex_event_types: input.codexEventTypes && input.codexEventTypes.length ? input.codexEventTypes : void 0,
+    codex_event_line_count: input.codexEventLineCount,
+    codex_non_event_line_count: input.codexNonEventLineCount,
     codex_command: input.config.codexCommand || "codex",
     codex_model: input.config.codexModel,
     codex_sandbox: input.config.codexSandbox || "workspace-write",
     codex_full_auto: input.config.codexFullAuto !== false,
-    timeout_ms: Number(input.config.codexTimeoutMs || 6e5)
+    timeout_ms: input.timeoutMs ?? DEFAULT_CODEX_TIMEOUT_MS
   });
 }
 function createCodexExecJsonRunner(config = {}) {
   return (request) => {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startedMs = Date.now();
+    const timeoutMs = resolveCodexTimeoutMs(config, request);
     if (!request.workdir || !(0, import_node_fs.existsSync)(request.workdir)) {
       return {
         ok: false,
-        metrics: runnerMetrics({ request, config, startedAt, startedMs, errorCode: "workdir_missing" }),
+        metrics: runnerMetrics({ request, config, startedAt, startedMs, timeoutMs, errorCode: "workdir_missing" }),
         blocker: {
           code: "codex_workdir_missing",
           message: `Codex workdir does not exist for ${request.purpose}.`,
@@ -461,7 +507,7 @@ function createCodexExecJsonRunner(config = {}) {
       const proc = (0, import_node_child_process.spawnSync)(config.codexCommand || "codex", args, {
         input: request.prompt,
         encoding: "utf-8",
-        timeout: Number(config.codexTimeoutMs || 6e5),
+        timeout: timeoutMs,
         maxBuffer: 10 * 1024 * 1024,
         env
       });
@@ -480,6 +526,7 @@ function createCodexExecJsonRunner(config = {}) {
             stderr: proc.stderr || "",
             status: proc.status,
             timedOut,
+            timeoutMs,
             errorCode: proc.error.code || "spawn_error"
           }),
           blocker: {
@@ -502,6 +549,7 @@ function createCodexExecJsonRunner(config = {}) {
             stdout: proc.stdout || "",
             stderr: proc.stderr || "",
             status: proc.status,
+            timeoutMs,
             errorCode: "nonzero_exit"
           }),
           blocker: {
@@ -514,12 +562,15 @@ function createCodexExecJsonRunner(config = {}) {
       const finalText = (0, import_node_fs.existsSync)(lastMessagePath) ? (0, import_node_fs.readFileSync)(lastMessagePath, "utf-8") : String(proc.stdout || "");
       const stdoutText = String(proc.stdout || "");
       const stderrText = String(proc.stderr || "");
-      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs([
+      const runnerOutputs = [
         { source: (0, import_node_fs.existsSync)(lastMessagePath) ? "last_message" : "stdout", text: finalText },
         { source: "stdout", text: stdoutText },
         { source: "stderr", text: stderrText }
-      ], request.schema);
+      ];
+      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs(runnerOutputs, request.schema);
       if (!parsed) {
+        const outputAnalysis = analyzeCodexRunnerOutput(runnerOutputs);
+        const errorCode = outputAnalysis.onlyLifecycleEvents ? "no_final_response" : "invalid_json";
         return {
           ok: false,
           stdout: stdoutText,
@@ -533,12 +584,24 @@ function createCodexExecJsonRunner(config = {}) {
             stderr: stderrText,
             finalText,
             status: proc.status,
-            errorCode: "invalid_json"
+            timeoutMs,
+            errorCode,
+            codexEventTypes: outputAnalysis.eventTypes,
+            codexEventLineCount: outputAnalysis.eventLineCount,
+            codexNonEventLineCount: outputAnalysis.nonEventLineCount
           }),
           blocker: {
-            code: "codex_invalid_json",
-            message: `Codex completed ${request.purpose}, but did not return valid JSON.`,
-            details: { finalText, stdout: stdoutText, stderr: stderrText }
+            code: outputAnalysis.onlyLifecycleEvents ? "codex_no_final_response" : "codex_invalid_json",
+            message: outputAnalysis.onlyLifecycleEvents ? `Codex emitted lifecycle events during ${request.purpose}, but did not produce a final JSON response.` : `Codex completed ${request.purpose}, but did not return valid JSON.`,
+            details: {
+              finalText,
+              stdout: stdoutText,
+              stderr: stderrText,
+              event_types: outputAnalysis.eventTypes,
+              event_line_count: outputAnalysis.eventLineCount,
+              non_event_line_count: outputAnalysis.nonEventLineCount,
+              non_event_samples: outputAnalysis.nonEventSamples
+            }
           }
         };
       }
@@ -556,7 +619,8 @@ function createCodexExecJsonRunner(config = {}) {
           stderr: stderrText,
           finalText,
           parsedJsonSource,
-          status: proc.status
+          status: proc.status,
+          timeoutMs
         })
       };
     } finally {
@@ -665,6 +729,7 @@ function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRu
           "Write a proof_plan and capture_script that will verify the exact user-facing change.",
           "Use recon_assessment.baseline_understanding as the source of truth. Do not author a proof plan unless it names the observed before state and the requested delta from that state.",
           "Use the recon-approved route and baseline context; make the plan name the concrete target, expected before state, expected after state, and stop condition.",
+          "Do not leave this authoring stage pending for external investigation. Keep any repo inspection brief, do not modify files, and return the JSON proof packet from the available state.",
           "Choose the evidence modality from verification_mode and success_criteria: screenshots for visual/UI proof, interactions plus screenshots for interaction proof, structured metrics/logs/JSON/audio analysis for non-visual proof.",
           "For playable/gameplay proof, treat screenshots as supporting artifacts only: start the game, send keyboard or pointer input, measure state before/after, measure non-HUD canvas/playfield pixel deltas across time, and return playability evidence with version riddle-proof.playability.v1.",
           "For interaction proof, return a structured evidence object with start route/state, terminal route/state, action, assertions, and matched UI text. Catch waitForURL or selector timeouts and record them as failed assertions instead of throwing before evidence is emitted.",

package/dist/codex-exec-agent.js

@@ -2,7 +2,7 @@ import {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   runCodexExecAgentDoctor
-} from "./chunk-PYCQNK66.js";
+} from "./chunk-EEIYUZXE.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/engine-harness.cjs

@@ -5585,6 +5585,18 @@ async function routeCheckpoint(request, state, result, agent, input) {
   if (checkpoint === "verify_agent_retry") {
     const next = recommendedContinuation(result);
     if (next) return { next };
+    return {
+      blocker: {
+        code: "proof_assessment_blocked",
+        checkpoint,
+        message: result.summary || "The supervising proof assessment did not approve shipping and did not provide a safe retry continuation.",
+        details: compactRecord({
+          proofAssessment: result.proofAssessment || result.checkpointContract?.proof_assessment || recordValue(result.raw)?.proofAssessment || null,
+          verifyDecisionRequest: result.verifyDecisionRequest || result.checkpointContract?.verify_decision_request || null,
+          checkpointContract: result.checkpointContract || null
+        })
+      }
+    };
   }
   if (checkpoint === "awaiting_stage_advance") {
     const next = recommendedContinuation(result) || defaultAwaitingStageContinuation(result);

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-E7ATYSYS.js";
+} from "./chunk-BBUO7HM4.js";
 import "./chunk-YZUVEJ5B.js";
 import "./chunk-FMOYUYH2.js";
 import "./chunk-5N5QFI2S.js";