@riddledc/riddle-proof 0.5.2 → 0.5.3

package/dist/proof-run-engine.d.ts

@@ -262,7 +262,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "ship" | "setup" | "recon" | "author" | "implement" | "verify" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -342,7 +342,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "ship" | "setup" | "recon" | "author" | "implement" | "verify" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -589,7 +589,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "ship" | "setup" | "recon" | "author" | "implement" | "verify" | "run";
     state_path: string;
     stage: any;
     summary: string;

package/dist/proof-run-engine.js

@@ -95,6 +95,88 @@ function updateState(statePath, mutate) {
   writeState(statePath, state);
   return state;
 }
+var RUNTIME_EVENT_LIMIT = 100;
+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: path.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: path.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();
@@ -557,53 +639,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(
-        execFileSync(lobsterCommand, [...lobsterPrefix, "run", "--file", workflowFile(config.riddleProofDir, step), "--args-json", JSON.stringify(args)], {
+        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(
-        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(
+          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 = {}) => {
@@ -729,7 +832,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"
@@ -939,7 +1042,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",
@@ -987,7 +1090,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",
@@ -1102,7 +1205,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",
@@ -1192,7 +1295,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",
@@ -1201,7 +1304,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");
@@ -1338,7 +1441,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, {
@@ -1517,7 +1620,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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",

package/runtime/lib/preflight.py

@@ -239,6 +239,19 @@ if missing:
     print('MISSING: ' + ', '.join(missing))
 print('=' * 50)
 
+# The TypeScript harness writes runtime observability fields before Lobster
+# starts. Preflight initializes the main state file, so preserve those fields
+# rather than making status polling go blind during setup.
+if os.path.exists(STATE_FILE):
+    try:
+        with open(STATE_FILE) as existing_state_file:
+            existing_state = json.load(existing_state_file)
+    except Exception:
+        existing_state = {}
+    for runtime_key in ('current_runtime_step', 'last_runtime_step', 'runtime_events', 'runtime_updated_at'):
+        if runtime_key in existing_state:
+            s[runtime_key] = existing_state[runtime_key]
+
 save_state(s)
 
 if missing: