@riddledc/riddle-proof 0.5.1 → 0.5.3

package/dist/{chunk-LVP22WE4.js → chunk-MLJJIKTP.js}

@@ -34,6 +34,22 @@ 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 createEngineStatePath(state, config) {
+  const existing = nonEmptyString(state.request.engine_state_path);
+  if (existing) return existing;
+  const harnessStatePath = nonEmptyString(state.state_path);
+  if (harnessStatePath) {
+    const dir = path.dirname(harnessStatePath);
+    const base = path.basename(harnessStatePath);
+    if (base.startsWith("riddle-proof-run-")) {
+      return path.join(dir, base.replace("riddle-proof-run-", "riddle-proof-state-"));
+    }
+    return path.join(dir, `${base}.engine-state.json`);
+  }
+  const stateDir = config?.stateDir || "/tmp";
+  const stamp = timestamp().replace(/\D/g, "").slice(0, 14) || "unknown";
+  return path.join(stateDir, `riddle-proof-state-${stamp}-${crypto.randomUUID().slice(0, 8)}.json`);
+}
 function ensureParent(filePath) {
   mkdirSync(path.dirname(filePath), { recursive: true });
 }
@@ -76,6 +92,18 @@ function heartbeat(state, input) {
 function jsonParam(payload) {
   return JSON.stringify(payload);
 }
+function redactedWorkflowParams(params) {
+  const secretKeys = /* @__PURE__ */ new Set([
+    "auth_localStorage_json",
+    "auth_cookies_json",
+    "auth_headers_json"
+  ]);
+  const output = {};
+  for (const [key, value] of Object.entries(params)) {
+    output[key] = secretKeys.has(key) && value ? "[redacted]" : value;
+  }
+  return output;
+}
 function engineStatePath(result, state) {
   return nonEmptyString(result.state_path) || nonEmptyString(state.request.engine_state_path);
 }
@@ -341,7 +369,11 @@ async function resolveEngine(input) {
   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 mod2 = await import("./proof-run-engine.js");
+    return mod2.createRiddleProofEngine({
+      riddleProofDir: input.config?.riddleProofDir,
+      defaultReviewer: input.config?.defaultReviewer
+    });
   }
   const mod = await import(moduleUrl);
   if (typeof mod.createRiddleProofEngine !== "function") {
@@ -578,6 +610,7 @@ function readRiddleProofRunStatus(state_path) {
 async function runRiddleProofEngineHarness(input) {
   const state = loadRunState(input);
   state.request = normalizeRunParams({ ...state.request, ...input.request });
+  state.request.engine_state_path = nonEmptyString(input.resume_params?.state_path) || nonEmptyString(state.request.engine_state_path) || createEngineStatePath(state, input.config);
   const request = state.request;
   const agent = input.agent || createDisabledRiddleProofAgentAdapter();
   const maxIterations = Math.max(
@@ -633,24 +666,41 @@ async function runRiddleProofEngineHarness(input) {
         branch: state.branch || null
       }
     });
+    const engineCallStartedAt = timestamp();
+    const engineCallStartedMs = Date.now();
     recordEvent(state, {
       kind: "engine.call",
       checkpoint: "engine_call",
       stage,
       summary: "Calling Riddle Proof engine.",
-      details: { params: nextParams }
+      details: {
+        params: redactedWorkflowParams(nextParams),
+        started_at: engineCallStartedAt
+      }
     });
     let result;
     try {
       result = await engine.execute(nextParams);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      recordEvent(state, {
+        kind: "engine.exception",
+        checkpoint: "engine_call_failed",
+        stage,
+        summary: message,
+        details: {
+          duration_ms: Date.now() - engineCallStartedMs,
+          started_at: engineCallStartedAt,
+          finished_at: timestamp()
+        }
+      });
       return blockerResult(state, lastResult, {
         code: "riddle_engine_exception",
         checkpoint: "engine_call_failed",
         message
       });
     }
+    const engineCallDurationMs = Date.now() - engineCallStartedMs;
     lastResult = result;
     const engineState = engineStatePath(result, state);
     if (engineState) state.request.engine_state_path = engineState;
@@ -675,7 +725,10 @@ async function runRiddleProofEngineHarness(input) {
       details: {
         ok: result.ok ?? null,
         engine_state_path: engineState || null,
-        checkpoint: result.checkpoint || null
+        checkpoint: result.checkpoint || null,
+        duration_ms: engineCallDurationMs,
+        started_at: engineCallStartedAt,
+        finished_at: timestamp()
       }
     });
     const routed = await routeCheckpoint(request, state, result, agent, input);