@riddledc/riddle-proof 0.5.2 → 0.5.3

package/dist/{chunk-5GZZZ6JA.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);
 }
@@ -582,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(
@@ -637,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;
@@ -679,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);

package/dist/engine-harness.cjs

@@ -947,6 +947,87 @@ function updateState(statePath, mutate) {
   writeState(statePath, state);
   return state;
 }
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function appendRuntimeEventToState(state, event) {
+  const events = Array.isArray(state.runtime_events) ? state.runtime_events : [];
+  state.runtime_events = [...events, event].slice(-RUNTIME_EVENT_LIMIT);
+  state.runtime_updated_at = event.ts;
+}
+function beginRuntimeStep(statePath, action, step, workflowPath) {
+  const timer = {
+    startedAt: nowIso(),
+    startedMs: Date.now()
+  };
+  updateState(statePath, (state) => {
+    const current = {
+      step,
+      action,
+      status: "running",
+      started_at: timer.startedAt,
+      workflow_file: import_node_path2.default.basename(workflowPath)
+    };
+    state.current_runtime_step = current;
+    appendRuntimeEventToState(state, {
+      ts: timer.startedAt,
+      kind: "workflow.step.started",
+      step,
+      action,
+      summary: `Started ${step} workflow step.`,
+      details: {
+        workflow_file: import_node_path2.default.basename(workflowPath)
+      }
+    });
+  });
+  return timer;
+}
+function finishRuntimeStep(statePath, action, result, timer) {
+  const finishedAt = nowIso();
+  const durationMs = Date.now() - timer.startedMs;
+  const summary = result.haltedForApproval ? `${result.step} halted for approval.` : result.ok ? `Finished ${result.step} workflow step.` : `${result.step} workflow step failed.`;
+  updateState(statePath, (state) => {
+    const completed = {
+      step: result.step,
+      action,
+      status: result.haltedForApproval ? "approval_required" : result.ok ? "completed" : "failed",
+      started_at: timer.startedAt,
+      finished_at: finishedAt,
+      duration_ms: durationMs,
+      ok: result.ok,
+      halted_for_approval: result.haltedForApproval || false,
+      auto_approved: result.autoApproved || false,
+      error: result.error || null
+    };
+    state.current_runtime_step = null;
+    state.last_runtime_step = completed;
+    appendRuntimeEventToState(state, {
+      ts: finishedAt,
+      kind: "workflow.step.finished",
+      step: result.step,
+      action,
+      summary,
+      details: completed
+    });
+  });
+  return {
+    ...result,
+    started_at: timer.startedAt,
+    finished_at: finishedAt,
+    duration_ms: durationMs
+  };
+}
+function executedStep(res, extra = {}) {
+  const output = {
+    step: res.step,
+    ok: res.ok,
+    haltedForApproval: res.haltedForApproval || false,
+    autoApproved: res.autoApproved || false,
+    ...extra
+  };
+  if (typeof res.duration_ms === "number") output.duration_ms = res.duration_ms;
+  return output;
+}
 function hasSupervisorProofAssessment(state) {
   const proofAssessment = state?.proof_assessment || {};
   const source = String(proofAssessment?.source || state?.proof_assessment_source || "").trim().toLowerCase();
@@ -1409,53 +1490,74 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
   const lobsterPrefix = process.env.RIDDLE_PROOF_LOBSTER_SCRIPT ? [process.env.RIDDLE_PROOF_LOBSTER_SCRIPT] : [];
   const runOne = (step) => {
     const args = step === "setup" ? buildSetupArgs(params, config) : {};
+    const stepWorkflowFile = workflowFile(config.riddleProofDir, step);
+    const timer = beginRuntimeStep(config.statePath, action, step, stepWorkflowFile);
     let output;
     try {
       output = JSON.parse(
-        (0, import_node_child_process.execFileSync)(lobsterCommand, [...lobsterPrefix, "run", "--file", workflowFile(config.riddleProofDir, step), "--args-json", JSON.stringify(args)], {
+        (0, import_node_child_process.execFileSync)(lobsterCommand, [...lobsterPrefix, "run", "--file", stepWorkflowFile, "--args-json", JSON.stringify(args)], {
           encoding: "utf-8",
           env
         })
       );
     } catch (error) {
-      return {
+      return finishRuntimeStep(config.statePath, action, {
         ok: false,
         step,
         error: error?.message || String(error),
         stdout: String(error?.stdout || ""),
         stderr: String(error?.stderr || "")
-      };
+      }, timer);
     }
     if (output?.status === "needs_approval") {
       if (!params.auto_approve) {
-        return {
+        return finishRuntimeStep(config.statePath, action, {
           ok: false,
           haltedForApproval: true,
           step,
           approval: output.requiresApproval || null,
           raw: output
-        };
+        }, timer);
       }
       const token = output?.requiresApproval?.resumeToken;
-      if (!token) throw new Error(`${step} requested approval without a resume token.`);
-      const resumed = JSON.parse(
-        (0, import_node_child_process.execFileSync)(lobsterCommand, [...lobsterPrefix, "resume", "--token", token, "--approve", "yes"], {
-          encoding: "utf-8",
-          env
-        })
-      );
-      return {
+      if (!token) {
+        return finishRuntimeStep(config.statePath, action, {
+          ok: false,
+          step,
+          error: `${step} requested approval without a resume token.`,
+          raw: output
+        }, timer);
+      }
+      let resumed;
+      try {
+        resumed = JSON.parse(
+          (0, import_node_child_process.execFileSync)(lobsterCommand, [...lobsterPrefix, "resume", "--token", token, "--approve", "yes"], {
+            encoding: "utf-8",
+            env
+          })
+        );
+      } catch (error) {
+        return finishRuntimeStep(config.statePath, action, {
+          ok: false,
+          step,
+          autoApproved: true,
+          error: error?.message || String(error),
+          stdout: String(error?.stdout || ""),
+          stderr: String(error?.stderr || "")
+        }, timer);
+      }
+      return finishRuntimeStep(config.statePath, action, {
         ok: resumed?.ok !== false,
         step,
         autoApproved: true,
         raw: resumed
-      };
+      }, timer);
     }
-    return {
+    return finishRuntimeStep(config.statePath, action, {
       ok: output?.ok !== false,
       step,
       raw: output
-    };
+    }, timer);
   };
   let effectiveAdvanceStage = params.advance_stage || null;
   const recordAttempt = (stage, status, summary, extra = {}) => {
@@ -1581,7 +1683,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     let state = readState(config.statePath);
     if (!state || !state.workspace_ready || params.advance_stage === "setup") {
       const setupRes = runOne("setup");
-      executed.push({ step: "setup", ok: setupRes.ok, haltedForApproval: setupRes.haltedForApproval || false, autoApproved: setupRes.autoApproved || false });
+      executed.push(executedStep(setupRes));
       if (!setupRes.ok || setupRes.haltedForApproval) {
         return failedRun("setup", setupRes.haltedForApproval ? "setup halted for approval" : "setup failed", setupRes, {
           checkpoint: "setup_blocked"
@@ -1791,7 +1893,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     }
     if (!state?.recon_results || state?.stage === "setup" || state?.stage === "preflight" || ["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "") || requestedStage === "recon") {
       const reconRes = runOne("recon");
-      executed.push({ step: "recon", ok: reconRes.ok, haltedForApproval: reconRes.haltedForApproval || false, autoApproved: reconRes.autoApproved || false });
+      executed.push(executedStep(reconRes));
       if (!reconRes.ok || reconRes.haltedForApproval) {
         return failedRun("recon", reconRes.haltedForApproval ? "recon halted for approval" : "recon failed", reconRes, {
           checkpoint: "recon_failed",
@@ -1839,7 +1941,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     state = readState(config.statePath);
     if (!authorReady(state) || effectiveAdvanceStage === "author") {
       const authorRes = runOne("author");
-      executed.push({ step: "author", ok: authorRes.ok, haltedForApproval: authorRes.haltedForApproval || false, autoApproved: authorRes.autoApproved || false });
+      executed.push(executedStep(authorRes));
       if (!authorRes.ok || authorRes.haltedForApproval) {
         return failedRun("author", authorRes.haltedForApproval ? "author halted for approval" : "author failed", authorRes, {
           checkpoint: "author_failed",
@@ -1954,7 +2056,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     }
     if (effectiveAdvanceStage === "implement") {
       const implementRes = runOne("implement");
-      executed.push({ step: "implement", ok: implementRes.ok, haltedForApproval: implementRes.haltedForApproval || false, autoApproved: implementRes.autoApproved || false });
+      executed.push(executedStep(implementRes));
       if (implementRes.haltedForApproval) {
         return failedRun("implement", "implement halted for approval", implementRes, {
           checkpoint: "implement_blocked",
@@ -2044,7 +2146,7 @@ ${implementRes.stderr || ""}`;
       let verifyRes = { ok: true, step: "verify", reusedEvidence: canReuseVerifyEvidence };
       if (!canReuseVerifyEvidence) {
         verifyRes = runOne("verify");
-        executed.push({ step: "verify", ok: verifyRes.ok, haltedForApproval: verifyRes.haltedForApproval || false, autoApproved: verifyRes.autoApproved || false });
+        executed.push(executedStep(verifyRes));
         if (!verifyRes.ok || verifyRes.haltedForApproval) {
           return failedRun("verify", verifyRes.haltedForApproval ? "verify halted for approval" : "verify failed", verifyRes, {
             checkpoint: "verify_failed",
@@ -2053,7 +2155,7 @@ ${implementRes.stderr || ""}`;
           });
         }
       } else {
-        executed.push({ step: "verify", ok: true, reusedEvidence: true, haltedForApproval: false, autoApproved: false });
+        executed.push(executedStep(verifyRes, { reusedEvidence: true }));
       }
       state = readState(config.statePath);
       const verifyStatus = state?.verify_status || ((state?.after_cdn || "").trim() ? "evidence_captured" : "capture_incomplete");
@@ -2190,7 +2292,7 @@ ${implementRes.stderr || ""}`;
           details: { ...verifyDetails, shipGate }
         });
         const shipRes = runOne("ship");
-        executed.push({ step: "ship", ok: shipRes.ok, haltedForApproval: shipRes.haltedForApproval || false, autoApproved: shipRes.autoApproved || false });
+        executed.push(executedStep(shipRes));
         if (!shipRes.ok || shipRes.haltedForApproval) {
           const shipNextAction = shipRes?.error && String(shipRes.error).includes("temporary proof branch") ? "product bug: ship resolved a temporary proof branch; resolve the PR head branch before retrying ship" : "inspect the ship error, confirm the PR head branch and verified commit, then retry ship";
           return failedRun("ship", shipRes.haltedForApproval ? "ship halted for approval" : "ship failed", shipRes, {
@@ -2369,7 +2471,7 @@ ${implementRes.stderr || ""}`;
         return shipGateBlocked(state, executed, { shipAssessment: shipAssessment.raw });
       }
       const shipRes = runOne("ship");
-      executed.push({ step: "ship", ok: shipRes.ok, haltedForApproval: shipRes.haltedForApproval || false, autoApproved: shipRes.autoApproved || false });
+      executed.push(executedStep(shipRes));
       if (!shipRes.ok || shipRes.haltedForApproval) {
         return failedRun("ship", shipRes.haltedForApproval ? "ship halted for approval" : "ship failed", shipRes, {
           checkpoint: "ship_failed",
@@ -2495,7 +2597,7 @@ function createRiddleProofEngine(pluginConfig = {}) {
     }
   };
 }
-var import_node_child_process, import_node_fs2, import_node_path2;
+var import_node_child_process, import_node_fs2, import_node_path2, RUNTIME_EVENT_LIMIT;
 var init_proof_run_engine = __esm({
   "src/proof-run-engine.ts"() {
     "use strict";
@@ -2503,6 +2605,7 @@ var init_proof_run_engine = __esm({
     import_node_fs2 = require("fs");
     import_node_path2 = __toESM(require("path"), 1);
     init_proof_run_core();
+    RUNTIME_EVENT_LIMIT = 100;
   }
 });
 
@@ -2901,6 +3004,22 @@ function createHarnessStatePath(stateDir) {
   const stamp = timestamp2().replace(/\D/g, "").slice(0, 14) || "unknown";
   return import_node_path3.default.join(stateDir, `riddle-proof-run-${stamp}-${import_node_crypto2.default.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 = import_node_path3.default.dirname(harnessStatePath);
+    const base = import_node_path3.default.basename(harnessStatePath);
+    if (base.startsWith("riddle-proof-run-")) {
+      return import_node_path3.default.join(dir, base.replace("riddle-proof-run-", "riddle-proof-state-"));
+    }
+    return import_node_path3.default.join(dir, `${base}.engine-state.json`);
+  }
+  const stateDir = config?.stateDir || "/tmp";
+  const stamp = timestamp2().replace(/\D/g, "").slice(0, 14) || "unknown";
+  return import_node_path3.default.join(stateDir, `riddle-proof-state-${stamp}-${import_node_crypto2.default.randomUUID().slice(0, 8)}.json`);
+}
 function ensureParent(filePath) {
   (0, import_node_fs3.mkdirSync)(import_node_path3.default.dirname(filePath), { recursive: true });
 }
@@ -2943,6 +3062,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);
 }
@@ -3449,6 +3580,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(
@@ -3504,24 +3636,41 @@ async function runRiddleProofEngineHarness(input) {
         branch: state.branch || null
       }
     });
+    const engineCallStartedAt = timestamp2();
+    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: timestamp2()
+        }
+      });
       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;
@@ -3546,7 +3695,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: timestamp2()
       }
     });
     const routed = await routeCheckpoint(request, state, result, agent, input);

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-5GZZZ6JA.js";
+} from "./chunk-MLJJIKTP.js";
 import "./chunk-GVPCSXN7.js";
 import "./chunk-TMMKRKY5.js";
 export {