@riddledc/riddle-proof 0.5.46 → 0.5.47

package/README.md

@@ -63,9 +63,10 @@ Codex/CLI-style testing:
 
 ```sh
 riddle-proof-loop run --request-json request.json --checkpoint-mode yield
+riddle-proof-loop run --request-json request.json --agent local
 riddle-proof-loop status --state-path /tmp/riddle-proof-run.json
 riddle-proof-loop respond --state-path /tmp/riddle-proof-run.json --response-json response.json
-riddle-proof-loop doctor codex_exec
+riddle-proof-loop doctor local
 ```
 
 In yield mode, the harness returns portable checkpoint packets for recon,
@@ -73,6 +74,10 @@ authoring, implementation, proof assessment, and evidence recovery. A host can
 answer those packets with `riddle-proof.checkpoint_response.v1` JSON without
 needing OpenClaw-specific proof semantics.
 
+`--agent local` is the generic CLI executor slot. The current implementation
+uses the local Codex CLI adapter underneath, but the loop contract and CLI
+surface are intentionally not Codex-specific.
+
 ## Runner Harness
 
 `runRiddleProof` is the reusable idea-to-PR workflow driver. It does not ship

package/dist/{chunk-X3AQ2WUM.js → chunk-ALP5KOS2.js}

@@ -10,7 +10,7 @@ import {
   createRunStatusSnapshot,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-JTNMEH57.js";
+} from "./chunk-JOXTKWX6.js";
 import {
   createRiddleProofRunCard
 } from "./chunk-PLSGW2GI.js";

package/dist/{chunk-JTNMEH57.js → chunk-JOXTKWX6.js}

@@ -213,7 +213,7 @@ function createRunStatusSnapshot(state, at = timestamp()) {
     checkpoint_summary: state.checkpoint_summary,
     state_paths: state.state_paths,
     proof_contract: state.proof_contract,
-    run_card: createRiddleProofRunCard(state, { at }),
+    run_card: state.run_card || createRiddleProofRunCard(state, { at }),
     latest_event: latestEvent
   });
 }

package/dist/{chunk-L26NTZOU.js → chunk-N3ZNBRIG.js}

@@ -3,7 +3,7 @@ import {
   appendStageHeartbeat,
   createRunState,
   setRunStatus
-} from "./chunk-JTNMEH57.js";
+} from "./chunk-JOXTKWX6.js";
 import {
   createRunResult
 } from "./chunk-DUFDZJOF.js";

package/dist/cli.cjs

@@ -3931,7 +3931,7 @@ function createRunStatusSnapshot(state, at = timestamp2()) {
     checkpoint_summary: state.checkpoint_summary,
     state_paths: state.state_paths,
     proof_contract: state.proof_contract,
-    run_card: createRiddleProofRunCard(state, { at }),
+    run_card: state.run_card || createRiddleProofRunCard(state, { at }),
     latest_event: latestEvent
   });
 }
@@ -5988,12 +5988,13 @@ async function runCodexExecAgentDoctor(config = {}, runner = createCodexExecJson
 function usage() {
   return [
     "Usage:",
-    "  riddle-proof-loop run --request-json <file|json|-> [--agent disabled|codex_exec] [--checkpoint-mode yield|auto]",
+    "  riddle-proof-loop run --request-json <file|json|-> [--agent disabled|local] [--checkpoint-mode yield|auto]",
     "  riddle-proof-loop respond --state-path <path> --response-json <file|json|->",
     "  riddle-proof-loop status --state-path <path>",
-    "  riddle-proof-loop doctor codex_exec [--codex-command <path>]",
+    "  riddle-proof-loop doctor local [--codex-command <path>]",
     "",
-    "The default CLI run mode is checkpoint-mode=yield unless --agent codex_exec is used."
+    "The default CLI run mode is checkpoint-mode=yield unless --agent local is used.",
+    "Compatibility aliases: --agent codex_exec and doctor codex_exec."
   ].join("\n");
 }
 function parseArgs(argv) {
@@ -6050,11 +6051,14 @@ function codexConfig(options) {
     codexFullAuto: codexFullAuto === "false" ? false : void 0
   };
 }
+function isLocalAgentMode(value) {
+  return value === "local" || value === "local_exec" || value === "codex_exec";
+}
 function agentFor(options) {
   const agentMode = optionString(options, "agent") || "disabled";
-  if (agentMode === "codex_exec") return createCodexExecAgentAdapter(codexConfig(options));
+  if (isLocalAgentMode(agentMode)) return createCodexExecAgentAdapter(codexConfig(options));
   if (agentMode === "disabled") return createDisabledRiddleProofAgentAdapter();
-  throw new Error(`Unsupported --agent ${agentMode}. Use disabled or codex_exec.`);
+  throw new Error(`Unsupported --agent ${agentMode}. Use disabled or local.`);
 }
 function requestForRun(options) {
   const statePath = optionString(options, "statePath");
@@ -6067,7 +6071,7 @@ function requestForRun(options) {
 function checkpointModeFor(options) {
   const explicit = optionString(options, "checkpointMode");
   if (explicit) return explicit;
-  return optionString(options, "agent") === "codex_exec" ? "auto" : "yield";
+  return isLocalAgentMode(optionString(options, "agent")) ? "auto" : "yield";
 }
 async function main() {
   const { positional, options } = parseArgs(process.argv.slice(2));
@@ -6079,7 +6083,7 @@ async function main() {
   }
   if (command === "doctor") {
     const subject = positional[1];
-    if (subject !== "codex_exec") throw new Error("Only `doctor codex_exec` is supported.");
+    if (!isLocalAgentMode(subject)) throw new Error("Only `doctor local` is supported.");
     const result = await runCodexExecAgentDoctor(codexConfig(options));
     process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
@@ -6109,6 +6113,7 @@ async function main() {
       agent: agentFor(options),
       config: {
         stateDir: optionString(options, "stateDir"),
+        riddleEngineModuleUrl: optionString(options, "riddleEngineModuleUrl"),
         riddleProofDir: optionString(options, "riddleProofDir"),
         defaultReviewer: optionString(options, "defaultReviewer"),
         defaultShipMode: optionString(options, "defaultShipMode")

package/dist/cli.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
-import {
-  createCodexExecAgentAdapter,
-  runCodexExecAgentDoctor
-} from "./chunk-NOBFZDZG.js";
 import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-X3AQ2WUM.js";
+} from "./chunk-ALP5KOS2.js";
 import "./chunk-4ASMX4R6.js";
-import "./chunk-JTNMEH57.js";
+import "./chunk-JFQXAJH2.js";
+import {
+  createCodexExecAgentAdapter,
+  runCodexExecAgentDoctor
+} from "./chunk-NOBFZDZG.js";
+import "./chunk-JOXTKWX6.js";
 import "./chunk-PLSGW2GI.js";
 import "./chunk-R6SCWJCI.js";
 import "./chunk-DUFDZJOF.js";
@@ -19,12 +20,13 @@ import { existsSync, readFileSync } from "fs";
 function usage() {
   return [
     "Usage:",
-    "  riddle-proof-loop run --request-json <file|json|-> [--agent disabled|codex_exec] [--checkpoint-mode yield|auto]",
+    "  riddle-proof-loop run --request-json <file|json|-> [--agent disabled|local] [--checkpoint-mode yield|auto]",
     "  riddle-proof-loop respond --state-path <path> --response-json <file|json|->",
     "  riddle-proof-loop status --state-path <path>",
-    "  riddle-proof-loop doctor codex_exec [--codex-command <path>]",
+    "  riddle-proof-loop doctor local [--codex-command <path>]",
     "",
-    "The default CLI run mode is checkpoint-mode=yield unless --agent codex_exec is used."
+    "The default CLI run mode is checkpoint-mode=yield unless --agent local is used.",
+    "Compatibility aliases: --agent codex_exec and doctor codex_exec."
   ].join("\n");
 }
 function parseArgs(argv) {
@@ -81,11 +83,14 @@ function codexConfig(options) {
     codexFullAuto: codexFullAuto === "false" ? false : void 0
   };
 }
+function isLocalAgentMode(value) {
+  return value === "local" || value === "local_exec" || value === "codex_exec";
+}
 function agentFor(options) {
   const agentMode = optionString(options, "agent") || "disabled";
-  if (agentMode === "codex_exec") return createCodexExecAgentAdapter(codexConfig(options));
+  if (isLocalAgentMode(agentMode)) return createCodexExecAgentAdapter(codexConfig(options));
   if (agentMode === "disabled") return createDisabledRiddleProofAgentAdapter();
-  throw new Error(`Unsupported --agent ${agentMode}. Use disabled or codex_exec.`);
+  throw new Error(`Unsupported --agent ${agentMode}. Use disabled or local.`);
 }
 function requestForRun(options) {
   const statePath = optionString(options, "statePath");
@@ -98,7 +103,7 @@ function requestForRun(options) {
 function checkpointModeFor(options) {
   const explicit = optionString(options, "checkpointMode");
   if (explicit) return explicit;
-  return optionString(options, "agent") === "codex_exec" ? "auto" : "yield";
+  return isLocalAgentMode(optionString(options, "agent")) ? "auto" : "yield";
 }
 async function main() {
   const { positional, options } = parseArgs(process.argv.slice(2));
@@ -110,7 +115,7 @@ async function main() {
   }
   if (command === "doctor") {
     const subject = positional[1];
-    if (subject !== "codex_exec") throw new Error("Only `doctor codex_exec` is supported.");
+    if (!isLocalAgentMode(subject)) throw new Error("Only `doctor local` is supported.");
     const result = await runCodexExecAgentDoctor(codexConfig(options));
     process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
@@ -140,6 +145,7 @@ async function main() {
       agent: agentFor(options),
       config: {
         stateDir: optionString(options, "stateDir"),
+        riddleEngineModuleUrl: optionString(options, "riddleEngineModuleUrl"),
         riddleProofDir: optionString(options, "riddleProofDir"),
         defaultReviewer: optionString(options, "defaultReviewer"),
         defaultShipMode: optionString(options, "defaultShipMode")

package/dist/engine-harness.cjs

@@ -3935,7 +3935,7 @@ function createRunStatusSnapshot(state, at = timestamp2()) {
     checkpoint_summary: state.checkpoint_summary,
     state_paths: state.state_paths,
     proof_contract: state.proof_contract,
-    run_card: createRiddleProofRunCard(state, { at }),
+    run_card: state.run_card || createRiddleProofRunCard(state, { at }),
     latest_event: latestEvent
   });
 }

package/dist/engine-harness.js

@@ -2,9 +2,9 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-X3AQ2WUM.js";
+} from "./chunk-ALP5KOS2.js";
 import "./chunk-4ASMX4R6.js";
-import "./chunk-JTNMEH57.js";
+import "./chunk-JOXTKWX6.js";
 import "./chunk-PLSGW2GI.js";
 import "./chunk-R6SCWJCI.js";
 import "./chunk-DUFDZJOF.js";

package/dist/index.cjs

@@ -2785,6 +2785,8 @@ __export(index_exports, {
   createCodexExecAgentAdapter: () => createCodexExecAgentAdapter,
   createCodexExecJsonRunner: () => createCodexExecJsonRunner,
   createDisabledRiddleProofAgentAdapter: () => createDisabledRiddleProofAgentAdapter,
+  createLocalAgentAdapter: () => createCodexExecAgentAdapter,
+  createLocalAgentJsonRunner: () => createCodexExecJsonRunner,
   createRiddleProofRunCard: () => createRiddleProofRunCard,
   createRunResult: () => createRunResult,
   createRunState: () => createRunState,
@@ -2806,6 +2808,7 @@ __export(index_exports, {
   recordValue: () => recordValue,
   redactForProofDiagnostics: () => redactForProofDiagnostics,
   runCodexExecAgentDoctor: () => runCodexExecAgentDoctor,
+  runLocalAgentDoctor: () => runCodexExecAgentDoctor,
   runRiddleProof: () => runRiddleProof,
   runRiddleProofEngineHarness: () => runRiddleProofEngineHarness,
   setRunStatus: () => setRunStatus,
@@ -4018,7 +4021,7 @@ function createRunStatusSnapshot(state, at = timestamp2()) {
     checkpoint_summary: state.checkpoint_summary,
     state_paths: state.state_paths,
     proof_contract: state.proof_contract,
-    run_card: createRiddleProofRunCard(state, { at }),
+    run_card: state.run_card || createRiddleProofRunCard(state, { at }),
     latest_event: latestEvent
   });
 }
@@ -7215,6 +7218,8 @@ function parseJson(value) {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   createDisabledRiddleProofAgentAdapter,
+  createLocalAgentAdapter,
+  createLocalAgentJsonRunner,
   createRiddleProofRunCard,
   createRunResult,
   createRunState,
@@ -7236,6 +7241,7 @@ function parseJson(value) {
   recordValue,
   redactForProofDiagnostics,
   runCodexExecAgentDoctor,
+  runLocalAgentDoctor,
   runRiddleProof,
   runRiddleProofEngineHarness,
   setRunStatus,

package/dist/index.d.cts

@@ -5,7 +5,7 @@ export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONS
 export { RIDDLE_PROOF_RUN_CARD_VERSION, createRiddleProofRunCard } from './run-card.cjs';
 export { RiddleProofRunnerAdapters, RunRiddleProofInput, runRiddleProof } from './runner.cjs';
 export { RiddleProofAgentAdapter, RiddleProofAgentPayload, RiddleProofCheckpointMode, RiddleProofEngine, RiddleProofEngineHarnessConfig, RiddleProofEngineHarnessContext, RiddleProofEngineResult, RiddleProofShipMode, RiddleProofWorkflowParams, RunRiddleProofEngineHarnessInput, createDisabledRiddleProofAgentAdapter, readRiddleProofRunStatus, runRiddleProofEngineHarness } from './engine-harness.cjs';
-export { CodexExecAgentConfig, CodexJsonRequest, CodexJsonResult, CodexJsonRunner, createCodexExecAgentAdapter, createCodexExecJsonRunner, runCodexExecAgentDoctor } from './codex-exec-agent.cjs';
+export { CodexExecAgentConfig, CodexJsonRequest, CodexJsonResult, CodexJsonRunner, CodexExecAgentConfig as LocalAgentConfig, CodexJsonRequest as LocalAgentJsonRequest, CodexJsonResult as LocalAgentJsonResult, CodexJsonRunner as LocalAgentJsonRunner, createCodexExecAgentAdapter, createCodexExecJsonRunner, createCodexExecAgentAdapter as createLocalAgentAdapter, createCodexExecJsonRunner as createLocalAgentJsonRunner, runCodexExecAgentDoctor, runCodexExecAgentDoctor as runLocalAgentDoctor } from './codex-exec-agent.cjs';
 export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.cjs';
 export { BuildVisualProofSessionInput, RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION, RIDDLE_PROOF_VISUAL_SESSION_VERSION, VisualProofSessionMismatch, buildVisualProofSession, compareVisualProofSessionFingerprint, parseVisualProofSession, visualSessionFingerprint, visualSessionFingerprintBasis } from './proof-session.cjs';
 export { AssessPlayabilityOptions, RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION, RIDDLE_PROOF_PLAYABILITY_VERSION, RiddleProofPlayabilityAssessment, RiddleProofPlayabilityEvidence, assessPlayabilityEvidence, extractPlayabilityEvidence, isRiddleProofPlayabilityMode } from './playability.cjs';

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONS
 export { RIDDLE_PROOF_RUN_CARD_VERSION, createRiddleProofRunCard } from './run-card.js';
 export { RiddleProofRunnerAdapters, RunRiddleProofInput, runRiddleProof } from './runner.js';
 export { RiddleProofAgentAdapter, RiddleProofAgentPayload, RiddleProofCheckpointMode, RiddleProofEngine, RiddleProofEngineHarnessConfig, RiddleProofEngineHarnessContext, RiddleProofEngineResult, RiddleProofShipMode, RiddleProofWorkflowParams, RunRiddleProofEngineHarnessInput, createDisabledRiddleProofAgentAdapter, readRiddleProofRunStatus, runRiddleProofEngineHarness } from './engine-harness.js';
-export { CodexExecAgentConfig, CodexJsonRequest, CodexJsonResult, CodexJsonRunner, createCodexExecAgentAdapter, createCodexExecJsonRunner, runCodexExecAgentDoctor } from './codex-exec-agent.js';
+export { CodexExecAgentConfig, CodexJsonRequest, CodexJsonResult, CodexJsonRunner, CodexExecAgentConfig as LocalAgentConfig, CodexJsonRequest as LocalAgentJsonRequest, CodexJsonResult as LocalAgentJsonResult, CodexJsonRunner as LocalAgentJsonRunner, createCodexExecAgentAdapter, createCodexExecJsonRunner, createCodexExecAgentAdapter as createLocalAgentAdapter, createCodexExecJsonRunner as createLocalAgentJsonRunner, runCodexExecAgentDoctor, runCodexExecAgentDoctor as runLocalAgentDoctor } from './codex-exec-agent.js';
 export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.js';
 export { BuildVisualProofSessionInput, RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION, RIDDLE_PROOF_VISUAL_SESSION_VERSION, VisualProofSessionMismatch, buildVisualProofSession, compareVisualProofSessionFingerprint, parseVisualProofSession, visualSessionFingerprint, visualSessionFingerprintBasis } from './proof-session.js';
 export { AssessPlayabilityOptions, RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION, RIDDLE_PROOF_PLAYABILITY_VERSION, RiddleProofPlayabilityAssessment, RiddleProofPlayabilityEvidence, assessPlayabilityEvidence, extractPlayabilityEvidence, isRiddleProofPlayabilityMode } from './playability.js';

package/dist/index.js

@@ -1,3 +1,11 @@
+import "./chunk-6F4PWJZI.js";
+import {
+  RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION,
+  RIDDLE_PROOF_PLAYABILITY_VERSION,
+  assessPlayabilityEvidence,
+  extractPlayabilityEvidence,
+  isRiddleProofPlayabilityMode
+} from "./chunk-NSWT3VSV.js";
 import {
   RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION,
   RIDDLE_PROOF_VISUAL_SESSION_VERSION,
@@ -9,13 +17,7 @@ import {
 } from "./chunk-ODORKNSO.js";
 import {
   runRiddleProof
-} from "./chunk-L26NTZOU.js";
-import "./chunk-6F4PWJZI.js";
-import {
-  createCodexExecAgentAdapter,
-  createCodexExecJsonRunner,
-  runCodexExecAgentDoctor
-} from "./chunk-NOBFZDZG.js";
+} from "./chunk-N3ZNBRIG.js";
 import {
   DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
   DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
@@ -30,8 +32,14 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-X3AQ2WUM.js";
+} from "./chunk-ALP5KOS2.js";
 import "./chunk-4ASMX4R6.js";
+import "./chunk-JFQXAJH2.js";
+import {
+  createCodexExecAgentAdapter,
+  createCodexExecJsonRunner,
+  runCodexExecAgentDoctor
+} from "./chunk-NOBFZDZG.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
@@ -43,7 +51,7 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-JTNMEH57.js";
+} from "./chunk-JOXTKWX6.js";
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
@@ -73,13 +81,6 @@ import {
   normalizeTerminalMetadata,
   recordValue
 } from "./chunk-DUFDZJOF.js";
-import {
-  RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION,
-  RIDDLE_PROOF_PLAYABILITY_VERSION,
-  assessPlayabilityEvidence,
-  extractPlayabilityEvidence,
-  isRiddleProofPlayabilityMode
-} from "./chunk-NSWT3VSV.js";
 export {
   DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
   DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
@@ -113,6 +114,8 @@ export {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   createDisabledRiddleProofAgentAdapter,
+  createCodexExecAgentAdapter as createLocalAgentAdapter,
+  createCodexExecJsonRunner as createLocalAgentJsonRunner,
   createRiddleProofRunCard,
   createRunResult,
   createRunState,
@@ -134,6 +137,7 @@ export {
   recordValue,
   redactForProofDiagnostics,
   runCodexExecAgentDoctor,
+  runCodexExecAgentDoctor as runLocalAgentDoctor,
   runRiddleProof,
   runRiddleProofEngineHarness,
   setRunStatus,

package/dist/local-agent.cjs

@@ -0,0 +1,792 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/local-agent.ts
+var local_agent_exports = {};
+__export(local_agent_exports, {
+  createLocalAgentAdapter: () => createCodexExecAgentAdapter,
+  createLocalAgentJsonRunner: () => createCodexExecJsonRunner,
+  runLocalAgentDoctor: () => runCodexExecAgentDoctor
+});
+module.exports = __toCommonJS(local_agent_exports);
+
+// src/codex-exec-agent.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var REFINED_INPUTS_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["server_path", "wait_for_selector", "reference"],
+  properties: {
+    server_path: { type: ["string", "null"] },
+    wait_for_selector: { type: ["string", "null"] },
+    reference: { enum: ["before", "prod", "both", null] }
+  }
+};
+var BASELINE_UNDERSTANDING_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "reference",
+    "target_route",
+    "before_evidence_url",
+    "visible_before_state",
+    "relevant_elements",
+    "requested_change",
+    "proof_focus",
+    "stop_condition",
+    "quality_risks"
+  ],
+  properties: {
+    reference: { type: "string", enum: ["before", "prod", "both", "unknown"] },
+    target_route: { type: "string" },
+    before_evidence_url: { type: "string" },
+    visible_before_state: { type: "string" },
+    relevant_elements: { type: "array", items: { type: "string" } },
+    requested_change: { type: "string" },
+    proof_focus: { type: "string" },
+    stop_condition: { type: "string" },
+    quality_risks: { type: "array", items: { type: "string" } }
+  }
+};
+var RECON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "decision",
+    "summary",
+    "baseline_understanding",
+    "continue_with_stage",
+    "escalation_target",
+    "refined_inputs",
+    "reasons",
+    "source"
+  ],
+  properties: {
+    decision: { type: "string", enum: ["retry_recon", "ready_for_author", "recon_stuck"] },
+    summary: { type: "string" },
+    baseline_understanding: BASELINE_UNDERSTANDING_SCHEMA,
+    continue_with_stage: { type: "string", enum: ["recon", "author"] },
+    escalation_target: { type: "string", enum: ["agent", "human"] },
+    refined_inputs: REFINED_INPUTS_SCHEMA,
+    reasons: { type: "array", items: { type: "string" } },
+    source: { type: "string", enum: ["supervising_agent"] }
+  }
+};
+var AUTHOR_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "proof_plan",
+    "capture_script",
+    "baseline_understanding_used",
+    "refined_inputs",
+    "rationale",
+    "confidence",
+    "summary"
+  ],
+  properties: {
+    proof_plan: { type: "string" },
+    capture_script: { type: "string" },
+    baseline_understanding_used: BASELINE_UNDERSTANDING_SCHEMA,
+    refined_inputs: REFINED_INPUTS_SCHEMA,
+    rationale: { type: "array", items: { type: "string" } },
+    confidence: { type: "string", enum: ["low", "medium", "high"] },
+    summary: { type: "string" }
+  }
+};
+var IMPLEMENT_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["summary", "implementation_notes", "changed_files", "tests_run", "blockers"],
+  properties: {
+    summary: { type: "string" },
+    implementation_notes: { type: "string" },
+    changed_files: { type: "array", items: { type: "string" } },
+    tests_run: { type: "array", items: { type: "string" } },
+    blockers: { type: "array", items: { type: "string" } }
+  }
+};
+var PROOF_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "decision",
+    "summary",
+    "recommended_stage",
+    "continue_with_stage",
+    "escalation_target",
+    "reasons",
+    "source"
+  ],
+  properties: {
+    decision: {
+      type: "string",
+      enum: [
+        "ready_to_ship",
+        "needs_richer_proof",
+        "revise_capture",
+        "needs_recon",
+        "needs_implementation"
+      ]
+    },
+    summary: { type: "string" },
+    recommended_stage: { type: "string", enum: ["ship", "author", "implement", "recon", "verify"] },
+    continue_with_stage: { type: "string", enum: ["ship", "author", "implement", "recon", "verify"] },
+    escalation_target: { type: "string", enum: ["agent", "human"] },
+    reasons: { type: "array", items: { type: "string" } },
+    source: { type: "string", enum: ["supervising_agent"] }
+  }
+};
+var PROMPT_STRING_LIMIT = 2e3;
+var PROMPT_ARRAY_LIMIT = 12;
+var PROMPT_OBJECT_KEY_LIMIT = 70;
+var PROMPT_BLOCK_LIMIT = 12e4;
+var PROMPT_KEY_PRIORITY = [
+  "ok",
+  "status",
+  "stage",
+  "checkpoint",
+  "summary",
+  "state_path",
+  "repo",
+  "branch",
+  "change_request",
+  "context",
+  "success_criteria",
+  "verification_mode",
+  "reference",
+  "server_path",
+  "wait_for_selector",
+  "before_cdn",
+  "prod_cdn",
+  "after_cdn",
+  "before_baseline",
+  "prod_baseline",
+  "recon_assessment",
+  "baseline_understanding",
+  "supervisor_author_packet",
+  "proof_plan",
+  "capture_script",
+  "implementation_status",
+  "implementation_summary",
+  "implementation_notes",
+  "changed_files",
+  "verify_status",
+  "verify_summary",
+  "proof_assessment",
+  "proof_assessment_request",
+  "semantic_context",
+  "visual_delta",
+  "proof_evidence_present",
+  "proof_evidence_sample",
+  "artifacts",
+  "assertions",
+  "checkpointContract",
+  "shipGate",
+  "last_error",
+  "errors",
+  "events"
+];
+var PROMPT_PRIORITY_INDEX = new Map(PROMPT_KEY_PRIORITY.map((key, index) => [key, index]));
+function truncatePromptString(value, limit = PROMPT_STRING_LIMIT) {
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit)}
+...[truncated ${value.length - limit} chars]`;
+}
+function compactPromptValue(value, depth = 0, key = "") {
+  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") {
+    const lowerKey = key.toLowerCase();
+    const looksLikeUrl = /^https?:\/\//.test(value);
+    if (!looksLikeUrl && (lowerKey.includes("base64") || lowerKey.includes("data_url") || lowerKey.includes("screenshot_blob"))) {
+      return `[omitted ${value.length} chars from ${key || "large artifact"}]`;
+    }
+    const limit = looksLikeUrl ? 1e3 : depth <= 1 ? PROMPT_STRING_LIMIT : 1200;
+    return truncatePromptString(value, limit);
+  }
+  if (Array.isArray(value)) {
+    const lowerKey = key.toLowerCase();
+    const items = lowerKey.includes("event") || lowerKey.includes("histor") || lowerKey.includes("retry") ? value.slice(-PROMPT_ARRAY_LIMIT) : value.slice(0, PROMPT_ARRAY_LIMIT);
+    const compacted = items.map((item) => compactPromptValue(item, depth + 1, key));
+    if (value.length > items.length) {
+      const omitted = value.length - items.length;
+      return lowerKey.includes("event") || lowerKey.includes("histor") || lowerKey.includes("retry") ? [{ omittedEarlierItems: omitted }, ...compacted] : [...compacted, { omittedItems: omitted }];
+    }
+    return compacted;
+  }
+  if (!value || typeof value !== "object") return String(value);
+  const entries = Object.entries(value).sort(([left], [right]) => {
+    const leftPriority = PROMPT_PRIORITY_INDEX.get(left) ?? 1e3;
+    const rightPriority = PROMPT_PRIORITY_INDEX.get(right) ?? 1e3;
+    if (leftPriority !== rightPriority) return leftPriority - rightPriority;
+    return left.localeCompare(right);
+  });
+  const result = {};
+  for (const [entryKey, entryValue] of entries.slice(0, PROMPT_OBJECT_KEY_LIMIT)) {
+    result[entryKey] = compactPromptValue(entryValue, depth + 1, entryKey);
+  }
+  if (entries.length > PROMPT_OBJECT_KEY_LIMIT) {
+    result.__omitted_keys = entries.length - PROMPT_OBJECT_KEY_LIMIT;
+  }
+  return result;
+}
+function jsonBlock(label, value) {
+  let json = JSON.stringify(compactPromptValue(value), null, 2);
+  if (json.length > PROMPT_BLOCK_LIMIT) {
+    json = `${json.slice(0, PROMPT_BLOCK_LIMIT)}
+...[truncated ${json.length - PROMPT_BLOCK_LIMIT} chars from compacted ${label}]`;
+  }
+  return `${label}:
+${json}`;
+}
+function resolveWorkdir(context, fallback = "/tmp") {
+  const after = typeof context.fullRiddleState?.after_worktree === "string" ? context.fullRiddleState.after_worktree.trim() : "";
+  return after || fallback;
+}
+function basePrompt(context, role) {
+  return [
+    role,
+    "",
+    "You are the supervising Codex worker inside the Riddle Proof harness.",
+    "Return only JSON matching the provided output schema.",
+    "Do not ask the human to manually continue. If blocked, encode the blocker in the JSON fields allowed by the schema.",
+    "Large raw artifacts are summarized before this prompt. Use preserved state summaries, URLs, file paths, and proof evidence samples instead of expecting full raw logs or binary artifacts inline.",
+    "",
+    jsonBlock("Original request", context.request),
+    jsonBlock("Riddle checkpoint result", context.engineResult),
+    jsonBlock("Full riddle state", context.fullRiddleState || {})
+  ].join("\n");
+}
+function schemaRequiredKeys(schema) {
+  const required = schema?.required;
+  return Array.isArray(required) ? required.filter((key) => typeof key === "string" && key.length > 0) : [];
+}
+function isSchemaShapedObject(value, schema) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const required = schemaRequiredKeys(schema);
+  return required.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function parseJsonCandidate(raw, schema) {
+  try {
+    const parsed = JSON.parse(raw);
+    return isSchemaShapedObject(parsed, schema) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function extractJsonObjectCandidates(raw) {
+  const candidates = [];
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < raw.length; index += 1) {
+    const char = raw[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      if (depth === 0) start = index;
+      depth += 1;
+      continue;
+    }
+    if (char === "}" && depth > 0) {
+      depth -= 1;
+      if (depth === 0 && start >= 0) {
+        candidates.push(raw.slice(start, index + 1));
+        start = -1;
+      }
+    }
+  }
+  return candidates;
+}
+function parseJsonObject(raw, schema) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const whole = parseJsonCandidate(trimmed, schema);
+  if (whole) return whole;
+  const lines = trimmed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const parsed = parseJsonCandidate(lines[index], schema);
+    if (parsed) return parsed;
+  }
+  const candidates = extractJsonObjectCandidates(trimmed);
+  for (let index = candidates.length - 1; index >= 0; index -= 1) {
+    const parsed = parseJsonCandidate(candidates[index], schema);
+    if (parsed) return parsed;
+  }
+  return null;
+}
+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"));
+}
+function createCodexExecJsonRunner(config = {}) {
+  return (request) => {
+    if (!request.workdir || !(0, import_node_fs.existsSync)(request.workdir)) {
+      return {
+        ok: false,
+        blocker: {
+          code: "codex_workdir_missing",
+          message: `Codex workdir does not exist for ${request.purpose}.`,
+          details: { workdir: request.workdir }
+        }
+      };
+    }
+    const tmpDir = (0, import_node_fs.mkdtempSync)(import_node_path.default.join(import_node_os.default.tmpdir(), "riddle-proof-codex-"));
+    const schemaPath = import_node_path.default.join(tmpDir, "schema.json");
+    const lastMessagePath = import_node_path.default.join(tmpDir, "last-message.json");
+    (0, import_node_fs.writeFileSync)(schemaPath, JSON.stringify(request.schema, null, 2));
+    const args = [
+      "exec",
+      "--json",
+      "--output-schema",
+      schemaPath,
+      "--output-last-message",
+      lastMessagePath,
+      "--cd",
+      request.workdir,
+      "--sandbox",
+      config.codexSandbox || "workspace-write",
+      "--skip-git-repo-check"
+    ];
+    if (config.codexFullAuto !== false) args.push("--full-auto");
+    if (config.codexModel) args.push("-m", config.codexModel);
+    args.push("-");
+    const env = { ...process.env };
+    if (config.codexHome) env.CODEX_HOME = config.codexHome;
+    delete env.OPENAI_API_KEY;
+    try {
+      const proc = (0, import_node_child_process.spawnSync)(config.codexCommand || "codex", args, {
+        input: request.prompt,
+        encoding: "utf-8",
+        timeout: Number(config.codexTimeoutMs || 6e5),
+        maxBuffer: 10 * 1024 * 1024,
+        env
+      });
+      if (proc.error) {
+        const timedOut = proc.error.code === "ETIMEDOUT";
+        return {
+          ok: false,
+          stdout: proc.stdout || "",
+          stderr: proc.stderr || "",
+          blocker: {
+            code: timedOut ? "codex_timeout" : "codex_exec_error",
+            message: timedOut ? `Codex timed out during ${request.purpose}.` : `Codex failed to start or complete ${request.purpose}.`,
+            details: { error: proc.error.message }
+          }
+        };
+      }
+      if (proc.status !== 0) {
+        return {
+          ok: false,
+          stdout: proc.stdout || "",
+          stderr: proc.stderr || "",
+          blocker: {
+            code: "codex_nonzero_exit",
+            message: `Codex exited with status ${proc.status} during ${request.purpose}.`,
+            details: { stdout: proc.stdout || "", stderr: proc.stderr || "" }
+          }
+        };
+      }
+      const finalText = (0, import_node_fs.existsSync)(lastMessagePath) ? (0, import_node_fs.readFileSync)(lastMessagePath, "utf-8") : String(proc.stdout || "");
+      const parsed = parseJsonObject(finalText, request.schema);
+      if (!parsed) {
+        return {
+          ok: false,
+          stdout: proc.stdout || "",
+          stderr: proc.stderr || "",
+          blocker: {
+            code: "codex_invalid_json",
+            message: `Codex completed ${request.purpose}, but did not return valid JSON.`,
+            details: { finalText, stdout: proc.stdout || "", stderr: proc.stderr || "" }
+          }
+        };
+      }
+      return {
+        ok: true,
+        json: parsed,
+        stdout: proc.stdout || "",
+        stderr: proc.stderr || ""
+      };
+    } finally {
+      (0, import_node_fs.rmSync)(tmpDir, { recursive: true, force: true });
+    }
+  };
+}
+async function callRunner(runner, request) {
+  return runner(request);
+}
+function payloadOrBlocker(raw, checkpoint) {
+  if (!raw.ok || !raw.json) {
+    const blocker = raw.blocker || {
+      code: "codex_runner_failed",
+      message: "Codex runner failed without a detailed blocker.",
+      details: { stdout: raw.stdout || "", stderr: raw.stderr || "" }
+    };
+    return {
+      ok: false,
+      blocker: {
+        ...blocker,
+        checkpoint
+      }
+    };
+  }
+  return {
+    ok: true,
+    payload: raw.json,
+    summary: typeof raw.json.summary === "string" ? raw.json.summary : void 0
+  };
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function parseGitStatusPaths(status) {
+  return status.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean).map((line) => {
+    let item = line.length > 3 ? line.slice(3) : line;
+    if (item.includes(" -> ")) item = item.split(" -> ").pop() || item;
+    return item.trim();
+  }).filter(Boolean);
+}
+function isToolNoisePath(filePath) {
+  return filePath === ".codex" || filePath.startsWith(".codex/") || filePath === ".oc-smoke" || filePath.startsWith(".oc-smoke/");
+}
+function hasGitDiff(workdir) {
+  try {
+    const status = git(["status", "--porcelain"], workdir);
+    return parseGitStatusPaths(status).some((filePath) => !isToolNoisePath(filePath));
+  } catch {
+    return false;
+  }
+}
+function buildImplementationPrompt(context, extraLines = []) {
+  return [
+    basePrompt(context, "Implement the requested code change in the after worktree."),
+    "Make the code changes directly in this repository.",
+    "Use the recon-approved baseline understanding in the state to decide exactly what prior UI/state is being changed.",
+    "Run focused checks when practical.",
+    "If a focused check is blocked only by the harness sandbox writing Vite temp config into a shared/symlinked node_modules path (for example EROFS on node_modules/.vite-temp/vite.config...), do not treat that as an implementation blocker when the requested git diff exists. Record it in tests_run or implementation_notes instead so the harness can advance to its own verify stage.",
+    "Leave a real git diff in the after worktree. Do not commit or push.",
+    "Before you return success, run git status --short and git diff --name-only in this repository and verify they show the intended change.",
+    "Do not return success with empty changed_files or a clean git status. If you cannot create the requested diff, explain why in blockers instead.",
+    "changed_files should match the real git diff as closely as practical.",
+    "Return changed_files, implementation_notes, tests_run, and blockers if any.",
+    "Use empty arrays for tests_run or blockers when none apply.",
+    ...extraLines
+  ].join("\n");
+}
+function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRunner(config)) {
+  return {
+    async assessRecon(context) {
+      const raw = await callRunner(runner, {
+        purpose: "recon assessment",
+        workdir: resolveWorkdir(context),
+        schema: RECON_SCHEMA,
+        prompt: [
+          basePrompt(context, "Judge the latest recon packet."),
+          "Decide whether recon should retry, continue to author, or escalate to the human.",
+          "This is the first intelligent before-evidence gate. It runs before proof authoring and before any code edits.",
+          "Prefer ready_for_author only when the baseline evidence is trustworthy for the requested change.",
+          "Do not approve recon just because telemetry_ready is true or a screenshot URL exists.",
+          "Inspect the baseline evidence in the state: screenshot URLs, structured pageState details, visible_text_sample, headings, buttons, links, canvas_count, large_visible_elements, observed_path, and route candidates.",
+          "Fill baseline_understanding with concrete observations about what the before/prod evidence shows, what exact user request it anchors, what proof should focus on, and what stop condition would satisfy the request.",
+          "If you cannot write a specific baseline_understanding from the current evidence, choose retry_recon or recon_stuck; do not choose ready_for_author.",
+          "Reject blank, banner-only, app-shell-only, loading-only, generic landing, source-import path, or wrong-feature baselines; retry recon with a better server_path or selector instead.",
+          "Your summary must say what is visibly present in the approved baseline or why the current baseline is not good enough.",
+          "Always include refined_inputs; use null values for server_path, wait_for_selector, or reference when no refinement is needed."
+        ].join("\n")
+      });
+      return payloadOrBlocker(raw, context.checkpoint);
+    },
+    async authorProofPacket(context) {
+      const raw = await callRunner(runner, {
+        purpose: "proof packet authoring",
+        workdir: resolveWorkdir(context),
+        schema: AUTHOR_SCHEMA,
+        prompt: [
+          basePrompt(context, "Author the proof packet."),
+          "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.",
+          "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 structured proof, collect meaningful measurements inside page.evaluate and set window.__riddleProofEvidence in that browser page context to a JSON-serializable object. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
+          "Do not assign globalThis.__riddleProofEvidence, window.__riddleProofEvidence, or self.__riddleProofEvidence outside page.evaluate; the Riddle worker context may not expose those globals safely.",
+          "Do not call Playwright page.* APIs inside page.evaluate; page.evaluate runs in the browser page, while page.waitForFunction, page.waitForSelector, page.click, and saveScreenshot belong in the outer capture script.",
+          "When page.evaluate needs data from the outer Playwright script, pass exactly one serializable argument object; do not pass multiple positional arguments.",
+          "When setting Playwright wait timeouts, use the correct signature: await page.waitForFunction(fn, undefined, { timeout: 60000 }). Do not write page.waitForFunction(fn, { timeout: 60000 }); that passes the object as the page argument and leaves the default timeout in place.",
+          "For audio/data/metric proof, return and persist the same evidence object: const evidence = await page.evaluate(async () => { /* browser measurements */ window.__riddleProofEvidence = { ... }; return window.__riddleProofEvidence; }); Then assert evidence fields before saving screenshots.",
+          "If a capture attempt errors or proof_evidence is absent, revise the capture_script to make structured evidence easier to collect; do not only add more screenshots for non-visual proof.",
+          "When checking visible copy, normalize text before exact matching: const normalizedText = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim(); Avoid raw innerText.includes(exact sentence) because browser line wrapping can split copy.",
+          "Prefer success-oriented evidence booleans such as newCopyVisible: true and oldCopyAbsent: true. If a positive assertion is false while screenshots/text samples look right, fix the capture script instead of leaving contradictory proof evidence.",
+          "Include a short matchedSnippet or normalizedTextSample when proofing copy so assertion mismatches are diagnosable.",
+          "For visual/UI proof, include saveScreenshot('after-proof') exactly once.",
+          "Avoid generic proof language. The packet should be specific enough that verify can tell whether the requested change actually happened.",
+          "Echo the baseline understanding you used in baseline_understanding_used so later stages can detect drift.",
+          "Use refined_inputs for server_path, wait_for_selector, or reference when useful; use null values when no refinement is needed."
+        ].join("\n")
+      });
+      return payloadOrBlocker(raw, context.checkpoint);
+    },
+    async implementChange(context) {
+      if (!context.workdir || !(0, import_node_fs.existsSync)(context.workdir)) {
+        return {
+          ok: false,
+          blocker: {
+            code: "implementation_workdir_missing",
+            checkpoint: context.checkpoint,
+            message: "The Riddle Proof state does not include an after worktree that exists on disk.",
+            details: { workdir: context.workdir || null }
+          }
+        };
+      }
+      const workdir = context.workdir;
+      const attemptSummaries = [];
+      const runImplementationAttempt = async (purpose, extraLines = []) => {
+        const raw = await callRunner(runner, {
+          purpose,
+          workdir,
+          schema: IMPLEMENT_SCHEMA,
+          prompt: buildImplementationPrompt(context, extraLines)
+        });
+        if (!raw.ok || !raw.json) {
+          return {
+            ok: false,
+            payload: payloadOrBlocker(raw, context.checkpoint)
+          };
+        }
+        const changedFiles = stringArray(raw.json.changed_files);
+        const blockers = stringArray(raw.json.blockers);
+        const testsRun = stringArray(raw.json.tests_run);
+        const softVerificationBlockers = changedFiles.length ? blockers.filter(isHarnessVerificationOnlyBlocker) : [];
+        const hardBlockers = blockers.filter((item) => !softVerificationBlockers.includes(item));
+        const implementationNotesRaw = typeof raw.json.implementation_notes === "string" ? raw.json.implementation_notes : "";
+        const summary = typeof raw.json.summary === "string" ? raw.json.summary : "";
+        const implementationNotes = [
+          implementationNotesRaw,
+          ...softVerificationBlockers.map((item) => `Harness verification note: ${item}`)
+        ].filter(Boolean).join("\n");
+        const agentDetails = {
+          agent_purpose: purpose,
+          agent_summary: summary,
+          agent_changed_files: changedFiles,
+          agent_tests_run: testsRun,
+          agent_blockers: blockers
+        };
+        attemptSummaries.push({
+          purpose,
+          summary,
+          changed_files: changedFiles,
+          tests_run: testsRun,
+          blockers
+        });
+        if (hardBlockers.length) {
+          return {
+            ok: false,
+            payload: {
+              ok: false,
+              blocker: {
+                code: "codex_implementation_blocked",
+                checkpoint: context.checkpoint,
+                message: summary || "Codex reported implementation blockers.",
+                details: {
+                  blockers: hardBlockers,
+                  changedFiles,
+                  testsRun,
+                  implementationNotes: implementationNotesRaw,
+                  ...agentDetails
+                }
+              }
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary,
+          changedFiles,
+          testsRun,
+          implementationNotes,
+          implementationNotesRaw,
+          softVerificationBlockers,
+          hardBlockers,
+          agentDetails
+        };
+      };
+      let attempt = await runImplementationAttempt("implementation");
+      if (!attempt.ok) return attempt.payload;
+      let diffDetected = hasGitDiff(workdir);
+      if (!diffDetected) {
+        attempt = await runImplementationAttempt("implementation retry", [
+          "The previous implementation attempt returned without a detectable git diff in this repository.",
+          `Previous summary: ${attempt.summary || "(none)"}`,
+          `Previous changed_files: ${JSON.stringify(attempt.changedFiles)}`,
+          "Before you return success this time, run git status --short and git diff --name-only. If they are still empty, do not return success; either keep editing or explain the blocker."
+        ]);
+        if (!attempt.ok) return attempt.payload;
+        diffDetected = hasGitDiff(workdir);
+      }
+      return {
+        ok: true,
+        summary: attempt.summary || void 0,
+        implementationNotes: attempt.implementationNotes || void 0,
+        changedFiles: attempt.changedFiles,
+        testsRun: attempt.testsRun,
+        details: {
+          ...attempt.agentDetails,
+          implementation_notes: attempt.implementationNotes || attempt.implementationNotesRaw || "",
+          soft_verification_blockers: attempt.softVerificationBlockers,
+          hard_blocker_count: attempt.hardBlockers.length,
+          retry_attempted: attemptSummaries.length > 1,
+          attempt_count: attemptSummaries.length,
+          attempt_summaries: attemptSummaries,
+          post_agent_diff_detected: diffDetected
+        }
+      };
+    },
+    async assessProof(context) {
+      const raw = await callRunner(runner, {
+        purpose: "proof assessment",
+        workdir: resolveWorkdir(context),
+        schema: PROOF_SCHEMA,
+        prompt: [
+          basePrompt(context, "Judge the proof bundle."),
+          "Decide whether the evidence is ready_to_ship or which internal stage should run next.",
+          "Only use ready_to_ship when the before/prod and after evidence actually prove the requested change.",
+          "Do not assume screenshots are required for every verification_mode. For data/audio/log/metric/custom proof, inspect the structured evidence bundle, proof_evidence_sample, artifacts, assertions, and success criteria directly.",
+          "Use semantic_context.route, headings, buttons, and text anchors to ground route/content judgment before calling screenshot evidence wrong-route or unrelated.",
+          "If structured proof evidence contains failed positive assertions, such as newCopyVisible: false or hasExpectedText: false, do not choose ready_to_ship until the evidence is reconciled or a richer proof is produced.",
+          "For visual/UI proof, screenshots and route/page-state quality still matter, but capture success alone is not proof.",
+          "For playable/gameplay proof, do not choose ready_to_ship unless playability evidence shows accepted input, state/time progression, and playfield/canvas pixel motion; a static generated scene is not playable proof.",
+          "For visual/UI polish, reject changes that are technically different but not legible to a reviewer. If visual_delta.status is measured and visual_delta.passed is false, choose needs_implementation when the visible result is wrong, or needs_richer_proof only when non-visual proof artifacts are insufficient.",
+          "If required visual_delta is unmeasured, missing, or not_applicable, choose revise_capture with recommended_stage=verify and continue_with_stage=verify so the same run stays in evidence/comparison recovery; do not choose ready_to_ship or generic needs_richer_proof for that missing metric.",
+          "Do not ship if the baseline is blank, shell-only, generic, or unrelated to the requested feature.",
+          "Your summary must name the concrete change, the target that was tested, what changed between baseline and after evidence, and why the stop condition is satisfied."
+        ].join("\n")
+      });
+      return payloadOrBlocker(raw, context.checkpoint);
+    }
+  };
+}
+function git(args, workdir) {
+  return (0, import_node_child_process.execFileSync)("git", args, {
+    cwd: workdir,
+    encoding: "utf-8",
+    timeout: 1e4
+  });
+}
+async function runCodexExecAgentDoctor(config = {}, runner = createCodexExecJsonRunner(config)) {
+  const workdir = (0, import_node_fs.mkdtempSync)(import_node_path.default.join(import_node_os.default.tmpdir(), "riddle-proof-codex-doctor-"));
+  const targetPath = import_node_path.default.join(workdir, "target.txt");
+  (0, import_node_fs.writeFileSync)(targetPath, "color=red\n");
+  try {
+    git(["init", "-b", "main"], workdir);
+    git(["config", "user.email", "doctor@example.com"], workdir);
+    git(["config", "user.name", "Riddle Proof Doctor"], workdir);
+    git(["add", "target.txt"], workdir);
+    git(["commit", "-m", "initial doctor fixture"], workdir);
+  } catch (error) {
+    return {
+      ok: false,
+      status: "blocked",
+      blocker: {
+        code: "doctor_git_setup_failed",
+        message: "Could not create the temporary doctor git fixture.",
+        details: { error: error instanceof Error ? error.message : String(error), workdir }
+      }
+    };
+  }
+  const raw = await callRunner(runner, {
+    purpose: "codex exec doctor implementation",
+    workdir,
+    schema: IMPLEMENT_SCHEMA,
+    prompt: [
+      "You are running a Riddle Proof Codex exec doctor check.",
+      "In this temporary git repository, edit target.txt so it says exactly: color=blue",
+      "Do not commit. Leave a git diff.",
+      "Return JSON matching the schema with changed_files containing target.txt.",
+      "Use empty arrays for tests_run and blockers."
+    ].join("\n")
+  });
+  if (!raw.ok || !raw.json) {
+    return {
+      ok: false,
+      status: "blocked",
+      blocker: {
+        ...raw.blocker || {
+          code: "doctor_codex_failed",
+          message: "Codex doctor runner failed.",
+          details: { stdout: raw.stdout || "", stderr: raw.stderr || "" }
+        },
+        details: {
+          ...raw.blocker?.details || {},
+          workdir
+        }
+      }
+    };
+  }
+  const content = (0, import_node_fs.readFileSync)(targetPath, "utf-8");
+  const status = git(["status", "--porcelain"], workdir);
+  const changedFiles = stringArray(raw.json.changed_files);
+  const ok = content.trim() === "color=blue" && status.includes("target.txt");
+  return {
+    ok,
+    status: ok ? "passed" : "blocked",
+    workdir,
+    changedFiles,
+    implementationSummary: raw.json.summary || null,
+    implementationNotes: raw.json.implementation_notes || null,
+    gitStatus: status,
+    targetContent: content,
+    blocker: ok ? null : {
+      code: "doctor_diff_missing_or_wrong",
+      message: "Codex doctor completed, but target.txt was not changed to color=blue with a git diff.",
+      details: { workdir, changedFiles, gitStatus: status, targetContent: content }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLocalAgentAdapter,
+  createLocalAgentJsonRunner,
+  runLocalAgentDoctor
+});

package/dist/local-agent.d.cts

@@ -0,0 +1,3 @@
+export { CodexExecAgentConfig as LocalAgentConfig, CodexJsonRequest as LocalAgentJsonRequest, CodexJsonResult as LocalAgentJsonResult, CodexJsonRunner as LocalAgentJsonRunner, createCodexExecAgentAdapter as createLocalAgentAdapter, createCodexExecJsonRunner as createLocalAgentJsonRunner, runCodexExecAgentDoctor as runLocalAgentDoctor } from './codex-exec-agent.cjs';
+import './engine-harness.cjs';
+import './types.cjs';

package/dist/local-agent.d.ts

@@ -0,0 +1,3 @@
+export { CodexExecAgentConfig as LocalAgentConfig, CodexJsonRequest as LocalAgentJsonRequest, CodexJsonResult as LocalAgentJsonResult, CodexJsonRunner as LocalAgentJsonRunner, createCodexExecAgentAdapter as createLocalAgentAdapter, createCodexExecJsonRunner as createLocalAgentJsonRunner, runCodexExecAgentDoctor as runLocalAgentDoctor } from './codex-exec-agent.js';
+import './engine-harness.js';
+import './types.js';

package/dist/local-agent.js

@@ -0,0 +1,11 @@
+import "./chunk-JFQXAJH2.js";
+import {
+  createCodexExecAgentAdapter,
+  createCodexExecJsonRunner,
+  runCodexExecAgentDoctor
+} from "./chunk-NOBFZDZG.js";
+export {
+  createCodexExecAgentAdapter as createLocalAgentAdapter,
+  createCodexExecJsonRunner as createLocalAgentJsonRunner,
+  runCodexExecAgentDoctor as runLocalAgentDoctor
+};

package/dist/openclaw.js

@@ -1,7 +1,7 @@
 import {
   normalizeIntegrationContext,
   normalizeRunParams
-} from "./chunk-JTNMEH57.js";
+} from "./chunk-JOXTKWX6.js";
 import "./chunk-PLSGW2GI.js";
 import "./chunk-R6SCWJCI.js";
 import {

package/dist/runner.js

@@ -1,7 +1,7 @@
 import {
   runRiddleProof
-} from "./chunk-L26NTZOU.js";
-import "./chunk-JTNMEH57.js";
+} from "./chunk-N3ZNBRIG.js";
+import "./chunk-JOXTKWX6.js";
 import "./chunk-PLSGW2GI.js";
 import "./chunk-R6SCWJCI.js";
 import "./chunk-DUFDZJOF.js";

package/dist/state.cjs

@@ -419,7 +419,7 @@ function createRunStatusSnapshot(state, at = timestamp()) {
     checkpoint_summary: state.checkpoint_summary,
     state_paths: state.state_paths,
     proof_contract: state.proof_contract,
-    run_card: createRiddleProofRunCard(state, { at }),
+    run_card: state.run_card || createRiddleProofRunCard(state, { at }),
     latest_event: latestEvent
   });
 }

package/dist/state.js

@@ -9,7 +9,7 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-JTNMEH57.js";
+} from "./chunk-JOXTKWX6.js";
 import "./chunk-PLSGW2GI.js";
 import "./chunk-R6SCWJCI.js";
 import "./chunk-DUFDZJOF.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.46",
+  "version": "0.5.47",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",
@@ -59,6 +59,11 @@
       "import": "./dist/codex-exec-agent.js",
       "require": "./dist/codex-exec-agent.cjs"
     },
+    "./local-agent": {
+      "types": "./dist/local-agent.d.ts",
+      "import": "./dist/local-agent.js",
+      "require": "./dist/local-agent.cjs"
+    },
     "./diagnostics": {
       "types": "./dist/diagnostics.d.ts",
       "import": "./dist/diagnostics.js",
@@ -110,7 +115,7 @@
     "typescript": "^5.4.5"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/types.ts src/result.ts src/state.ts src/checkpoint.ts src/run-card.ts src/runner.ts src/engine-harness.ts src/codex-exec-agent.ts src/cli.ts src/diagnostics.ts src/proof-session.ts src/playability.ts src/openclaw.ts src/proof-run-core.ts src/proof-run-engine.ts --format cjs,esm --dts --out-dir dist --clean",
+    "build": "tsup src/index.ts src/types.ts src/result.ts src/state.ts src/checkpoint.ts src/run-card.ts src/runner.ts src/engine-harness.ts src/codex-exec-agent.ts src/local-agent.ts src/cli.ts src/diagnostics.ts src/proof-session.ts src/playability.ts src/openclaw.ts src/proof-run-core.ts src/proof-run-engine.ts --format cjs,esm --dts --out-dir dist --clean",
     "clean": "rm -rf dist",
     "lint": "echo 'lint: (not configured)'",
     "test": "npm run build && node test.js && node proof-run.test.js"