@riddledc/riddle-proof 0.3.0 → 0.4.1

package/dist/{chunk-IQIEOQZF.js → chunk-5FHUOSNO.js}

@@ -63,6 +63,11 @@ function normalizeRunParams(input) {
     color_scheme: input.color_scheme,
     wait_for_selector: input.wait_for_selector,
     ship_mode: input.ship_mode,
+    engine_state_path: input.engine_state_path,
+    harness_state_path: input.harness_state_path,
+    max_iterations: input.max_iterations,
+    auto_approve: input.auto_approve,
+    dry_run: input.dry_run,
     integration_context: normalizeIntegrationContext(input.integration_context)
   });
 }

package/dist/{chunk-P3FUU5X4.js → chunk-F65YYXVO.js}

@@ -3,7 +3,7 @@ import {
   appendStageHeartbeat,
   createRunState,
   setRunStatus
-} from "./chunk-IQIEOQZF.js";
+} from "./chunk-5FHUOSNO.js";
 import {
   createRunResult
 } from "./chunk-5DC6YXN4.js";

package/dist/chunk-UON7C6N4.js

@@ -0,0 +1,684 @@
+import {
+  appendRunEvent,
+  appendStageHeartbeat,
+  createRunState,
+  createRunStatusSnapshot,
+  normalizeRunParams,
+  setRunStatus
+} from "./chunk-5FHUOSNO.js";
+import {
+  applyTerminalMetadata,
+  compactRecord,
+  createRunResult,
+  nonEmptyString,
+  normalizeTerminalMetadata,
+  recordValue
+} from "./chunk-5DC6YXN4.js";
+
+// src/engine-harness.ts
+import { execFileSync } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import path from "path";
+import crypto from "crypto";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createHarnessStatePath(stateDir) {
+  const stamp = timestamp().replace(/\D/g, "").slice(0, 14) || "unknown";
+  return path.join(stateDir, `riddle-proof-run-${stamp}-${crypto.randomUUID().slice(0, 8)}.json`);
+}
+function ensureParent(filePath) {
+  mkdirSync(path.dirname(filePath), { recursive: true });
+}
+function readJson(filePath) {
+  if (!filePath || !existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJson(filePath, payload) {
+  ensureParent(filePath);
+  writeFileSync(filePath, JSON.stringify(payload, null, 2) + "\n");
+}
+function loadRunState(input) {
+  if (input.state) return input.state;
+  const stateDir = input.config?.stateDir || "/tmp";
+  const statePath = input.state_path || input.request.harness_state_path || createHarnessStatePath(stateDir);
+  const existing = readJson(statePath);
+  if (existing?.version === "riddle-proof.run-state.v1" && Array.isArray(existing.events) && existing.request) {
+    return existing;
+  }
+  return createRunState({
+    request: input.request,
+    state_path: statePath
+  });
+}
+function persist(state) {
+  if (state.state_path) writeJson(state.state_path, state);
+}
+function recordEvent(state, event) {
+  appendRunEvent(state, event);
+  persist(state);
+}
+function heartbeat(state, input) {
+  appendStageHeartbeat(state, input);
+  persist(state);
+}
+function jsonParam(payload) {
+  return JSON.stringify(payload);
+}
+function engineStatePath(result, state) {
+  return nonEmptyString(result.state_path) || nonEmptyString(state.request.engine_state_path);
+}
+function fullRiddleState(result, state) {
+  return readJson(engineStatePath(result, state)) || recordValue(result.state) || null;
+}
+function workdirFromState(state) {
+  return nonEmptyString(state?.after_worktree) || nonEmptyString(state?.worktree_path) || null;
+}
+function hasGitDiff(workdir) {
+  if (!workdir || !existsSync(workdir)) return false;
+  try {
+    const status = execFileSync("git", ["status", "--porcelain"], {
+      cwd: workdir,
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    return status.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function removeEmptyToolArtifacts(workdir) {
+  if (!workdir || !existsSync(workdir)) return [];
+  const artifactPath = path.join(workdir, ".codex");
+  if (!existsSync(artifactPath)) return [];
+  try {
+    const status = execFileSync("git", ["status", "--porcelain", "--", ".codex"], {
+      cwd: workdir,
+      encoding: "utf-8",
+      timeout: 1e4
+    }).trim();
+    const stat = statSync(artifactPath);
+    if (status.startsWith("?? ") && stat.isFile() && stat.size === 0) {
+      unlinkSync(artifactPath);
+      return [".codex"];
+    }
+  } catch {
+    return [];
+  }
+  return [];
+}
+function stageFromCheckpoint(result) {
+  const explicitStage = nonEmptyString(result.stage);
+  if (explicitStage) return explicitStage;
+  const checkpoint = String(result.checkpoint || "");
+  if (checkpoint.startsWith("recon_")) return "recon";
+  if (checkpoint.startsWith("author_")) return "author";
+  if (checkpoint.startsWith("implement_")) return "implement";
+  if (checkpoint.startsWith("verify_")) return "verify";
+  if (checkpoint.startsWith("ship_")) return "ship";
+  if (checkpoint.includes("capture")) return "prove";
+  return "setup";
+}
+function stageFromWorkflowParams(params) {
+  const stage = nonEmptyString(params.advance_stage);
+  if (stage) return stage;
+  if (params.ship_after_verify) return "ship";
+  if (params.proof_assessment_json) return "verify";
+  if (params.implementation_notes) return "verify";
+  if (params.author_packet_json) return "implement";
+  if (params.recon_assessment_json) return "author";
+  return "setup";
+}
+function baseContinuation(result) {
+  return {
+    action: "run",
+    state_path: String(result.state_path || ""),
+    continue_from_checkpoint: true
+  };
+}
+function initialRunParams(request, input, state) {
+  return compactRecord({
+    action: "run",
+    repo: request.repo,
+    branch: request.branch,
+    change_request: request.change_request,
+    commit_message: request.commit_message,
+    prod_url: request.prod_url,
+    capture_script: request.capture_script,
+    success_criteria: request.success_criteria,
+    assertions_json: typeof request.assertions === "string" ? request.assertions : request.assertions === void 0 ? void 0 : JSON.stringify(request.assertions),
+    verification_mode: request.verification_mode,
+    reference: request.reference,
+    base_branch: request.base_branch,
+    before_ref: request.before_ref,
+    allow_static_preview_fallback: request.allow_static_preview_fallback,
+    context: request.context,
+    reviewer: request.reviewer,
+    mode: request.mode,
+    build_command: request.build_command,
+    build_output: request.build_output,
+    server_image: request.server_image,
+    server_command: request.server_command,
+    server_port: request.server_port,
+    server_path: request.server_path,
+    use_auth: request.use_auth,
+    color_scheme: request.color_scheme,
+    wait_for_selector: request.wait_for_selector,
+    discord_channel: request.integration_context?.channel_id,
+    discord_thread_id: request.integration_context?.thread_id,
+    discord_message_id: request.integration_context?.message_id,
+    discord_source_url: request.integration_context?.source_url,
+    state_path: request.engine_state_path || state.request.engine_state_path,
+    auto_approve: input.auto_approve ?? request.auto_approve
+  });
+}
+function effectiveShipMode(request, config) {
+  return request.ship_mode || config?.defaultShipMode || "ship";
+}
+function checkpointContinueStage(result) {
+  const resume = recordValue(result.checkpointContract?.resume);
+  return nonEmptyString(resume?.continue_with_stage);
+}
+function recommendedContinuation(result) {
+  const continueStage = checkpointContinueStage(result);
+  if (!continueStage) return null;
+  return {
+    action: "run",
+    state_path: String(result.state_path || ""),
+    advance_stage: continueStage
+  };
+}
+function defaultAwaitingStageContinuation(result) {
+  const contract = recordValue(result.checkpointContract) || {};
+  const stage = nonEmptyString(contract.stage) || nonEmptyString(result.stage) || "";
+  const nextStage = stage === "setup" ? "recon" : stage === "recon" ? "author" : stage === "author" ? "implement" : stage === "implement" || stage === "verify" ? "verify" : "";
+  if (!nextStage) return null;
+  return {
+    action: "run",
+    state_path: String(result.state_path || ""),
+    advance_stage: nextStage
+  };
+}
+function isReadyShipGate(result) {
+  const gate = recordValue(result.shipGate) || recordValue(result.checkpointContract?.ship_gate);
+  return Boolean(gate && gate.ok === true);
+}
+function proofAssessmentRequestsShip(payload) {
+  const decision = String(payload.decision || "");
+  const recommendedStage = String(payload.recommended_stage || "");
+  const continueStage = String(payload.continue_with_stage || "");
+  return decision === "ready_to_ship" || recommendedStage === "ship" || continueStage === "ship";
+}
+function proofAssessmentContinuation(request, result, payload, config) {
+  const proof_assessment_json = jsonParam(payload);
+  if (effectiveShipMode(request, config) === "ship" || !proofAssessmentRequestsShip(payload)) {
+    return { ...baseContinuation(result), proof_assessment_json };
+  }
+  return {
+    action: "run",
+    state_path: String(result.state_path || ""),
+    advance_stage: "verify",
+    proof_assessment_json
+  };
+}
+function contextFor(request, state, result) {
+  return {
+    request,
+    state,
+    engineResult: result,
+    fullRiddleState: fullRiddleState(result, state),
+    checkpoint: String(result.checkpoint || "unknown")
+  };
+}
+function requirePayload(action, payload, state, result) {
+  if (payload.blocker || payload.ok === false) {
+    return payload.blocker || {
+      code: `${action}_blocked`,
+      checkpoint: result.checkpoint || null,
+      message: payload.summary || `${action} did not return a usable payload.`
+    };
+  }
+  if (!payload.payload || typeof payload.payload !== "object") {
+    return {
+      code: `${action}_missing_payload`,
+      checkpoint: result.checkpoint || null,
+      message: `${action} did not return the JSON payload required by the riddle-proof checkpoint.`,
+      details: {
+        run_id: state.run_id,
+        state_path: state.state_path
+      }
+    };
+  }
+  return null;
+}
+function terminalResult(state, status, result, summary, raw = {}) {
+  setRunStatus(state, status);
+  const metadata = normalizeTerminalMetadata({
+    riddleState: result ? fullRiddleState(result, state) : null,
+    engineResult: result
+  });
+  applyTerminalMetadata(state, metadata);
+  persist(state);
+  return createRunResult({
+    state,
+    status,
+    last_summary: summary,
+    metadata,
+    raw: {
+      engine_state_path: result?.state_path || state.request.engine_state_path || null,
+      last_result: result,
+      ...raw
+    }
+  });
+}
+function blockerResult(state, result, blocker) {
+  state.blocker = blocker;
+  recordEvent(state, {
+    kind: "run.blocked",
+    checkpoint: blocker.checkpoint || result?.checkpoint || null,
+    stage: stageFromCheckpoint(result || {}),
+    summary: blocker.message,
+    details: {
+      code: blocker.code,
+      ...blocker.details
+    }
+  });
+  setRunStatus(state, "blocked");
+  persist(state);
+  return createRunResult({
+    state,
+    status: "blocked",
+    last_summary: blocker.message,
+    raw: {
+      engine_state_path: result?.state_path || state.request.engine_state_path || null,
+      last_result: result
+    }
+  });
+}
+function disabledAdapterPayload(action, context) {
+  return {
+    ok: false,
+    blocker: {
+      code: "agent_adapter_not_configured",
+      checkpoint: context.checkpoint,
+      message: `No agent adapter is configured for ${action}. The engine harness reached the checkpoint safely and stopped before faking agent output.`,
+      details: {
+        run_id: context.state.run_id,
+        state_path: context.state.state_path,
+        engine_state_path: context.engineResult.state_path || null,
+        checkpointContract: context.engineResult.checkpointContract || null
+      }
+    }
+  };
+}
+function createDisabledRiddleProofAgentAdapter() {
+  return {
+    assessRecon: (context) => Promise.resolve(disabledAdapterPayload("recon assessment", context)),
+    authorProofPacket: (context) => Promise.resolve(disabledAdapterPayload("proof packet authoring", context)),
+    implementChange: (context) => Promise.resolve(disabledAdapterPayload("implementation", context)),
+    assessProof: (context) => Promise.resolve(disabledAdapterPayload("proof assessment", context))
+  };
+}
+async function resolveEngine(input) {
+  if (typeof input.engine === "function") return input.engine();
+  if (input.engine) return input.engine;
+  const moduleUrl = input.config?.riddleEngineModuleUrl;
+  if (!moduleUrl) {
+    throw new Error("No riddle engine adapter or riddleEngineModuleUrl is configured.");
+  }
+  const mod = await import(moduleUrl);
+  if (typeof mod.createRiddleProofEngine !== "function") {
+    throw new Error(`Riddle engine module does not export createRiddleProofEngine: ${moduleUrl}`);
+  }
+  return mod.createRiddleProofEngine({
+    riddleProofDir: input.config?.riddleProofDir,
+    defaultReviewer: input.config?.defaultReviewer
+  });
+}
+async function handleImplementation(request, state, result, agent) {
+  const context = contextFor(request, state, result);
+  const workdir = workdirFromState(context.fullRiddleState);
+  state.worktree_path = workdir || state.worktree_path;
+  state.branch = nonEmptyString(context.fullRiddleState?.branch) || state.branch;
+  persist(state);
+  if (!workdir || !existsSync(workdir)) {
+    return {
+      blocker: {
+        code: "implementation_worktree_missing",
+        checkpoint: result.checkpoint || null,
+        message: "The Riddle Proof engine state does not include an isolated after worktree that exists on disk.",
+        details: {
+          worktree_path: workdir || null,
+          engine_state_path: result.state_path || null
+        }
+      }
+    };
+  }
+  const implementation = await agent.implementChange({ ...context, workdir });
+  if (implementation.blocker || implementation.ok === false) {
+    return {
+      blocker: implementation.blocker || {
+        code: "implementation_blocked",
+        checkpoint: result.checkpoint || null,
+        message: implementation.summary || "Implementation adapter did not complete."
+      }
+    };
+  }
+  const cleanedArtifacts = removeEmptyToolArtifacts(workdir);
+  const diffDetected = implementation.diffDetected === true || hasGitDiff(workdir);
+  if (!diffDetected) {
+    return {
+      blocker: {
+        code: "implementation_diff_missing",
+        checkpoint: result.checkpoint || null,
+        message: "The implementation adapter returned, but the after worktree has no detectable git diff. The harness will not advance to verify.",
+        details: { worktree_path: workdir || null }
+      }
+    };
+  }
+  recordEvent(state, {
+    kind: "agent.implementation.completed",
+    checkpoint: result.checkpoint || null,
+    stage: "implement",
+    summary: implementation.summary || "Implementation adapter reported code changes.",
+    details: {
+      worktree_path: workdir || null,
+      diffDetected,
+      changed_files: implementation.changedFiles || [],
+      cleaned_artifacts: cleanedArtifacts
+    }
+  });
+  return {
+    next: compactRecord({
+      ...baseContinuation(result),
+      advance_stage: "implement",
+      implementation_notes: implementation.implementationNotes || implementation.summary
+    })
+  };
+}
+async function routeCheckpoint(request, state, result, agent, input) {
+  const checkpoint = String(result.checkpoint || "");
+  const context = contextFor(request, state, result);
+  if (!checkpoint) {
+    return {
+      terminal: terminalResult(state, "completed", result, result.summary || "Riddle Proof engine completed.")
+    };
+  }
+  if ([
+    "recon_human_escalation",
+    "verify_human_escalation",
+    "ship_gate_blocked",
+    "verify_required",
+    "verify_supervisor_judgment_required"
+  ].includes(checkpoint) && result.ok === false) {
+    return {
+      blocker: {
+        code: checkpoint,
+        checkpoint,
+        message: result.summary || `Riddle Proof blocked at ${checkpoint}.`,
+        details: { checkpointContract: result.checkpointContract || null }
+      }
+    };
+  }
+  if (checkpoint === "ship_review") {
+    return {
+      terminal: terminalResult(state, "shipped", result, result.summary || "Riddle Proof shipped.")
+    };
+  }
+  if (checkpoint === "verify_ship_ready") {
+    const shipMode = effectiveShipMode(request, input.config);
+    if (shipMode === "ship") {
+      if (!isReadyShipGate(result)) {
+        return {
+          blocker: {
+            code: "ship_gate_not_ready",
+            checkpoint,
+            message: "The harness reached verify_ship_ready, but the ship gate is not passing. It will not call ship.",
+            details: { shipGate: result.shipGate || result.checkpointContract?.ship_gate || null }
+          }
+        };
+      }
+      return { next: { ...baseContinuation(result), ship_after_verify: true } };
+    }
+    return {
+      terminal: terminalResult(state, "ready_to_ship", result, result.summary || "Riddle Proof is ready to ship.", {
+        ship_held: true
+      })
+    };
+  }
+  if (input.dry_run || request.dry_run) {
+    return {
+      blocker: {
+        code: "dry_run_checkpoint",
+        checkpoint,
+        message: "Dry run stopped before applying agent input to the Riddle Proof workflow.",
+        details: { checkpointContract: result.checkpointContract || null }
+      }
+    };
+  }
+  if (checkpoint === "recon_supervisor_judgment") {
+    const assessment = await agent.assessRecon(context);
+    const blocker = requirePayload("recon_assessment", assessment, state, result);
+    if (blocker) return { blocker };
+    recordEvent(state, {
+      kind: "agent.recon_assessment.completed",
+      checkpoint,
+      stage: "recon",
+      summary: assessment.summary,
+      details: { payload: assessment.payload }
+    });
+    return {
+      next: { ...baseContinuation(result), recon_assessment_json: jsonParam(assessment.payload) }
+    };
+  }
+  const continueStage = checkpointContinueStage(result);
+  const checkpointContinuesToAuthor = continueStage === "author";
+  if (checkpoint === "author_supervisor_judgment" || checkpoint === "verify_capture_retry" || checkpoint === "verify_agent_retry" && checkpointContinuesToAuthor) {
+    const packet = await agent.authorProofPacket(context);
+    const blocker = requirePayload("author_packet", packet, state, result);
+    if (blocker) return { blocker };
+    recordEvent(state, {
+      kind: "agent.author_packet.completed",
+      checkpoint,
+      stage: "author",
+      summary: packet.summary,
+      details: { payload: packet.payload }
+    });
+    return {
+      next: { ...baseContinuation(result), author_packet_json: jsonParam(packet.payload) }
+    };
+  }
+  if (checkpoint === "implement_changes_missing" || checkpoint === "implement_required" || checkpoint === "verify_agent_retry" && continueStage === "implement") {
+    return handleImplementation(request, state, result, agent);
+  }
+  if (checkpoint === "implement_review") {
+    return { next: { action: "run", state_path: String(result.state_path || ""), advance_stage: "verify" } };
+  }
+  if (checkpoint === "verify_supervisor_judgment") {
+    const assessment = await agent.assessProof(context);
+    const blocker = requirePayload("proof_assessment", assessment, state, result);
+    if (blocker) return { blocker };
+    const payload = assessment.payload;
+    recordEvent(state, {
+      kind: "agent.proof_assessment.completed",
+      checkpoint,
+      stage: "verify",
+      summary: assessment.summary,
+      details: { payload }
+    });
+    return { next: proofAssessmentContinuation(request, result, payload, input.config) };
+  }
+  if (checkpoint === "verify_agent_retry") {
+    const next = recommendedContinuation(result);
+    if (next) return { next };
+  }
+  if (checkpoint === "awaiting_stage_advance") {
+    const next = recommendedContinuation(result) || defaultAwaitingStageContinuation(result);
+    if (next) {
+      if (String(next.advance_stage || "") === "ship" && effectiveShipMode(request, input.config) !== "ship") {
+        return {
+          terminal: terminalResult(state, "ready_to_ship", result, result.summary || "Riddle Proof is ready to ship.", {
+            ship_held: true
+          })
+        };
+      }
+      return { next };
+    }
+  }
+  if (checkpoint.endsWith("_review")) {
+    const next = recommendedContinuation(result);
+    if (next) return { next };
+  }
+  return {
+    blocker: {
+      code: "unhandled_checkpoint",
+      checkpoint,
+      message: `The harness does not yet know how to safely continue checkpoint ${checkpoint}.`,
+      details: { checkpointContract: result.checkpointContract || null }
+    }
+  };
+}
+function readRiddleProofRunStatus(state_path) {
+  const state = readJson(state_path);
+  if (state?.version !== "riddle-proof.run-state.v1" || !Array.isArray(state.events)) return null;
+  return createRunStatusSnapshot(state);
+}
+async function runRiddleProofEngineHarness(input) {
+  const state = loadRunState(input);
+  state.request = normalizeRunParams({ ...state.request, ...input.request });
+  const request = state.request;
+  const agent = input.agent || createDisabledRiddleProofAgentAdapter();
+  const maxIterations = Math.max(
+    1,
+    Math.trunc(input.max_iterations ?? request.max_iterations ?? input.config?.defaultMaxIterations ?? 8)
+  );
+  state.status = "running";
+  state.ok = void 0;
+  state.blocker = void 0;
+  persist(state);
+  recordEvent(state, {
+    kind: "engine_harness.started",
+    checkpoint: "engine_harness_started",
+    stage: "setup",
+    summary: "Riddle Proof engine harness started.",
+    details: {
+      run_id: state.run_id,
+      state_path: state.state_path,
+      engine_state_path: request.engine_state_path || null,
+      max_iterations: maxIterations,
+      ship_mode: effectiveShipMode(request, input.config)
+    }
+  });
+  let engine;
+  try {
+    engine = await resolveEngine(input);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return blockerResult(state, null, {
+      code: "riddle_engine_not_configured",
+      checkpoint: "engine_resolve_failed",
+      message
+    });
+  }
+  let nextParams = input.resume_params || initialRunParams(request, input, state);
+  let lastResult = null;
+  for (let index = 0; index < maxIterations; index += 1) {
+    state.iterations += 1;
+    const stage = stageFromWorkflowParams(nextParams);
+    heartbeat(state, {
+      stage,
+      summary: `${stage} stage is active.`,
+      details: {
+        iteration: state.iterations,
+        run_id: state.run_id,
+        state_path: state.state_path,
+        engine_state_path: nextParams.state_path || null,
+        worktree_path: state.worktree_path || null,
+        branch: state.branch || null
+      }
+    });
+    recordEvent(state, {
+      kind: "engine.call",
+      checkpoint: "engine_call",
+      stage,
+      summary: "Calling Riddle Proof engine.",
+      details: { params: nextParams }
+    });
+    let result;
+    try {
+      result = await engine.execute(nextParams);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return blockerResult(state, lastResult, {
+        code: "riddle_engine_exception",
+        checkpoint: "engine_call_failed",
+        message
+      });
+    }
+    lastResult = result;
+    const engineState = engineStatePath(result, state);
+    if (engineState) state.request.engine_state_path = engineState;
+    state.last_checkpoint = result.checkpoint || state.last_checkpoint || null;
+    const resultStage = stageFromCheckpoint(result);
+    heartbeat(state, {
+      stage: resultStage,
+      summary: `${resultStage} stage is active.`,
+      details: {
+        iteration: state.iterations,
+        run_id: state.run_id,
+        state_path: state.state_path,
+        engine_state_path: engineState || null,
+        checkpoint: result.checkpoint || null
+      }
+    });
+    recordEvent(state, {
+      kind: "engine.result",
+      checkpoint: result.checkpoint || null,
+      stage: resultStage,
+      summary: result.summary,
+      details: {
+        ok: result.ok ?? null,
+        engine_state_path: engineState || null,
+        checkpoint: result.checkpoint || null
+      }
+    });
+    const routed = await routeCheckpoint(request, state, result, agent, input);
+    if (routed.terminal) return routed.terminal;
+    if (routed.blocker) return blockerResult(state, result, routed.blocker);
+    if (!routed.next) {
+      return blockerResult(state, result, {
+        code: "missing_next_step",
+        checkpoint: result.checkpoint || null,
+        message: "The harness route returned no next step."
+      });
+    }
+    nextParams = routed.next;
+  }
+  return blockerResult(state, lastResult, {
+    code: "max_iterations_reached",
+    checkpoint: lastResult?.checkpoint || null,
+    message: `The harness reached max_iterations=${maxIterations} before the proof was ready or shipped.`,
+    details: {
+      nextParams,
+      lastCheckpoint: lastResult?.checkpoint || null,
+      lastSummary: lastResult?.summary || null
+    }
+  });
+}
+
+export {
+  createDisabledRiddleProofAgentAdapter,
+  readRiddleProofRunStatus,
+  runRiddleProofEngineHarness
+};