@riddledc/riddle-proof 0.2.0 → 0.3.0

package/README.md

@@ -8,7 +8,7 @@ Proof standardizes evidence, proof assessment, ship gates, terminal results,
 and integration metadata.
 
 This package includes the reusable runner harness that drives a request through
-setup, implementation, proof capture, judgment, shipping, and notification
+preflight, setup, implementation, proof capture, judgment, shipping, and notification
 adapters. The current OpenClaw `proofed_change_run` implementation remains the
 reference workflow while adapter implementations are extracted behind parity
 tests.
@@ -19,7 +19,9 @@ tests.
 - Evidence bundle and proof assessment types
 - Adapter interfaces
 - State/event helpers for wrappers that need a stable run envelope
-- Runner harness for setup -> implement -> prove -> judge -> ship -> notify
+- Runner harness for preflight -> setup -> implement -> prove -> judge -> ship -> notify
+- Stage heartbeat and run status snapshot helpers
+- Worktree metadata and proof artifact role contracts
 - Terminal ship metadata normalization
 - Stable result helpers
 - OpenClaw parameter normalization via `@riddledc/riddle-proof/openclaw`
@@ -59,9 +61,14 @@ credentials or a coding agent. It calls adapters supplied by the host
 integration:
 
 ```text
-setup -> implement -> prove -> judge -> ship -> notify
+preflight -> setup -> implement -> prove -> judge -> ship -> notify
 ```
 
+The preflight adapter checks model/tool availability before proof work starts.
+The setup adapter should report the isolated worktree path, branch, and cleanup
+policy it chose. During the run, wrappers can emit `appendStageHeartbeat`
+events and return `createRunStatusSnapshot` for cheap observer status.
+
 The proof adapter is where a host wires Riddle server-backed capture. The ship
 adapter is where a host commits, pushes, opens or updates a PR, and waits for CI
 when configured. The notification adapter is where a host updates Discord,

package/dist/{chunk-2ZQNXVQC.js → chunk-5DC6YXN4.js}

@@ -52,7 +52,11 @@ function createRunResult(input) {
   return compactRecord({
     ok,
     status,
+    run_id: state.run_id,
     state_path: input.state_path ?? state.state_path ?? null,
+    worktree_path: state.worktree_path ?? null,
+    branch: state.branch ?? null,
+    current_stage: state.current_stage ?? null,
     iterations: state.iterations,
     last_checkpoint: state.last_checkpoint ?? null,
     last_summary: input.last_summary ?? null,

package/dist/{chunk-EPVZKWUS.js → chunk-IQIEOQZF.js}

@@ -2,13 +2,24 @@ import {
   compactRecord,
   nonEmptyString,
   recordValue
-} from "./chunk-2ZQNXVQC.js";
+} from "./chunk-5DC6YXN4.js";
 
 // src/state.ts
 var RIDDLE_PROOF_RUN_STATE_VERSION = "riddle-proof.run-state.v1";
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function createRunId(createdAt) {
+  const stamp = createdAt.replace(/\D/g, "").slice(0, 14) || "unknown";
+  const entropy = Math.random().toString(36).slice(2, 8) || "run";
+  return `rp_${stamp}_${entropy}`;
+}
+function elapsedMs(start, end) {
+  const startMs = start ? Date.parse(start) : NaN;
+  const endMs = end ? Date.parse(end) : NaN;
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) return void 0;
+  return Math.max(0, endMs - startMs);
+}
 function normalizeIntegrationContext(input, fallbackSource) {
   const value = recordValue(input);
   if (!value) {
@@ -59,7 +70,12 @@ function createRunState(input) {
   const createdAt = input.created_at || timestamp();
   return compactRecord({
     version: RIDDLE_PROOF_RUN_STATE_VERSION,
+    run_id: input.run_id || createRunId(createdAt),
     state_path: input.state_path,
+    worktree_path: input.worktree_path,
+    branch: input.branch || input.request.branch,
+    current_stage: input.current_stage ?? null,
+    stage_started_at: input.stage_started_at ?? null,
     status: input.status || "running",
     created_at: createdAt,
     updated_at: input.updated_at || createdAt,
@@ -87,9 +103,49 @@ function appendRunEvent(state, input) {
     details: event.details
   }));
   if (input.checkpoint !== void 0) state.last_checkpoint = input.checkpoint;
+  if (input.stage !== void 0) {
+    if (state.current_stage !== input.stage) state.stage_started_at = event.ts;
+    state.current_stage = input.stage;
+  }
   state.updated_at = event.ts;
   return state;
 }
+function appendStageHeartbeat(state, input) {
+  const at = input.ts || timestamp();
+  return appendRunEvent(state, {
+    ts: at,
+    kind: "stage.heartbeat",
+    checkpoint: input.checkpoint || `${input.stage}_heartbeat`,
+    stage: input.stage,
+    summary: input.summary || `${input.stage} stage is active.`,
+    details: compactRecord({
+      elapsed_ms: elapsedMs(state.created_at, at),
+      stage_elapsed_ms: elapsedMs(state.stage_started_at, at),
+      wait_reason: input.wait_reason,
+      blocker: input.blocker,
+      ...input.details
+    })
+  });
+}
+function createRunStatusSnapshot(state, at = timestamp()) {
+  const latestEvent = state.events[state.events.length - 1];
+  const runId = state.run_id || "unknown";
+  return compactRecord({
+    run_id: runId,
+    status: state.status,
+    current_stage: state.current_stage ?? null,
+    state_path: state.state_path ?? null,
+    worktree_path: state.worktree_path ?? null,
+    branch: state.branch ?? null,
+    iterations: state.iterations,
+    last_checkpoint: state.last_checkpoint ?? null,
+    updated_at: state.updated_at,
+    elapsed_ms: elapsedMs(state.created_at, at),
+    stage_elapsed_ms: elapsedMs(state.stage_started_at, at),
+    blocker: state.blocker,
+    latest_event: latestEvent
+  });
+}
 function setRunStatus(state, status, at = timestamp()) {
   state.status = status;
   state.ok = status !== "blocked" && status !== "failed";
@@ -103,5 +159,7 @@ export {
   normalizeRunParams,
   createRunState,
   appendRunEvent,
+  appendStageHeartbeat,
+  createRunStatusSnapshot,
   setRunStatus
 };

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

@@ -1,11 +1,12 @@
 import {
   appendRunEvent,
+  appendStageHeartbeat,
   createRunState,
   setRunStatus
-} from "./chunk-EPVZKWUS.js";
+} from "./chunk-IQIEOQZF.js";
 import {
   createRunResult
-} from "./chunk-2ZQNXVQC.js";
+} from "./chunk-5DC6YXN4.js";
 
 // src/runner.ts
 function errorDetails(error) {
@@ -84,7 +85,8 @@ async function notifyIfConfigured(input) {
 async function runRiddleProof(input) {
   const state = input.state || createRunState({
     request: input.request,
-    state_path: input.state_path
+    state_path: input.state_path,
+    worktree_path: input.workdir
   });
   const adapters = input.adapters || {};
   const maxIterations = Math.max(1, Math.trunc(input.max_iterations ?? 1));
@@ -94,12 +96,70 @@ async function runRiddleProof(input) {
     stage: "setup",
     summary: "Riddle Proof run started.",
     details: {
+      run_id: state.run_id,
+      state_path: state.state_path,
+      worktree_path: state.worktree_path,
+      branch: state.branch,
       max_iterations: maxIterations,
       ship_mode: state.request.ship_mode || "none"
     }
   });
+  appendStageHeartbeat(state, {
+    stage: "setup",
+    summary: "Setup stage is active.",
+    details: {
+      run_id: state.run_id,
+      state_path: state.state_path,
+      worktree_path: state.worktree_path,
+      branch: state.branch
+    }
+  });
   let workdir = input.workdir;
   let evidenceContext;
+  if (adapters.preflight) {
+    appendRunEvent(state, {
+      kind: "preflight.started",
+      checkpoint: "preflight_started",
+      stage: "preflight",
+      summary: "Riddle Proof preflight adapter started."
+    });
+    try {
+      const preflight = await adapters.preflight.preflight({ request: state.request, state });
+      if (!preflight.ok) {
+        return blockRun({
+          state,
+          stage: "preflight",
+          blocker: adapterBlocker(
+            "preflight_failed",
+            "The preflight adapter found blocking tool or model configuration issues.",
+            "preflight_failed",
+            {
+              blockers: preflight.blockers,
+              warnings: preflight.warnings,
+              degraded_capabilities: preflight.degraded_capabilities
+            }
+          ),
+          raw: { preflight }
+        });
+      }
+      appendRunEvent(state, {
+        kind: "preflight.completed",
+        checkpoint: "preflight_completed",
+        stage: "preflight",
+        summary: "Riddle Proof preflight adapter completed.",
+        details: {
+          warnings: preflight.warnings,
+          degraded_capabilities: preflight.degraded_capabilities
+        }
+      });
+    } catch (error) {
+      return blockRun({
+        state,
+        stage: "preflight",
+        blocker: adapterBlocker("preflight_exception", "The preflight adapter threw an exception.", "preflight_failed", errorDetails(error))
+      });
+    }
+  }
   if (adapters.setup) {
     appendRunEvent(state, {
       kind: "setup.started",
@@ -122,7 +182,9 @@ async function runRiddleProof(input) {
           raw: { setup }
         });
       }
-      workdir = setup.workdir || workdir;
+      workdir = setup.worktree_path || setup.workdir || workdir;
+      state.worktree_path = setup.worktree_path || setup.workdir || state.worktree_path;
+      state.branch = setup.branch || state.branch;
       evidenceContext = setup.evidence_context;
       appendRunEvent(state, {
         kind: "setup.completed",
@@ -131,6 +193,9 @@ async function runRiddleProof(input) {
         summary: "Riddle Proof setup adapter completed.",
         details: {
           has_workdir: Boolean(workdir),
+          worktree_path: state.worktree_path,
+          branch: state.branch,
+          cleanup_policy: setup.cleanup_policy,
           has_evidence_context: Boolean(evidenceContext)
         }
       });
@@ -183,6 +248,11 @@ async function runRiddleProof(input) {
   let assessment;
   for (let attempt = 0; attempt < maxIterations; attempt += 1) {
     state.iterations += 1;
+    appendStageHeartbeat(state, {
+      stage: "implement",
+      summary: "Implementation stage is active.",
+      details: { iteration: state.iterations }
+    });
     appendRunEvent(state, {
       kind: "implementation.started",
       checkpoint: "implementation_started",
@@ -229,6 +299,13 @@ async function runRiddleProof(input) {
         tests_run: implementation.tests_run
       }
     });
+    appendStageHeartbeat(state, {
+      stage: "prove",
+      summary: "Proof capture stage is active.",
+      details: {
+        verification_mode: state.request.verification_mode
+      }
+    });
     appendRunEvent(state, {
       kind: "proof.started",
       checkpoint: "proof_started",
@@ -278,6 +355,13 @@ async function runRiddleProof(input) {
       stage: "verify",
       summary: "Judge adapter started."
     });
+    appendStageHeartbeat(state, {
+      stage: "verify",
+      summary: "Verification stage is active.",
+      details: {
+        verification_mode: evidenceBundle.verification_mode
+      }
+    });
     try {
       assessment = await adapters.judge.assessProof({ state, evidence_bundle: evidenceBundle });
       state.proof_decision = assessment.decision;
@@ -367,6 +451,10 @@ async function runRiddleProof(input) {
     stage: "ship",
     summary: "Ship adapter started."
   });
+  appendStageHeartbeat(state, {
+    stage: "ship",
+    summary: "Ship stage is active."
+  });
   let metadata;
   try {
     metadata = await adapters.ship.ship({ state, assessment });

package/dist/index.cjs

@@ -22,10 +22,12 @@ var index_exports = {};
 __export(index_exports, {
   RIDDLE_PROOF_RUN_STATE_VERSION: () => RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent: () => appendRunEvent,
+  appendStageHeartbeat: () => appendStageHeartbeat,
   applyTerminalMetadata: () => applyTerminalMetadata,
   compactRecord: () => compactRecord,
   createRunResult: () => createRunResult,
   createRunState: () => createRunState,
+  createRunStatusSnapshot: () => createRunStatusSnapshot,
   isSuccessfulStatus: () => isSuccessfulStatus,
   isTerminalStatus: () => isTerminalStatus,
   nonEmptyString: () => nonEmptyString,
@@ -92,7 +94,11 @@ function createRunResult(input) {
   return compactRecord({
     ok,
     status,
+    run_id: state.run_id,
     state_path: input.state_path ?? state.state_path ?? null,
+    worktree_path: state.worktree_path ?? null,
+    branch: state.branch ?? null,
+    current_stage: state.current_stage ?? null,
     iterations: state.iterations,
     last_checkpoint: state.last_checkpoint ?? null,
     last_summary: input.last_summary ?? null,
@@ -114,6 +120,17 @@ var RIDDLE_PROOF_RUN_STATE_VERSION = "riddle-proof.run-state.v1";
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function createRunId(createdAt) {
+  const stamp = createdAt.replace(/\D/g, "").slice(0, 14) || "unknown";
+  const entropy = Math.random().toString(36).slice(2, 8) || "run";
+  return `rp_${stamp}_${entropy}`;
+}
+function elapsedMs(start, end) {
+  const startMs = start ? Date.parse(start) : NaN;
+  const endMs = end ? Date.parse(end) : NaN;
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) return void 0;
+  return Math.max(0, endMs - startMs);
+}
 function normalizeIntegrationContext(input, fallbackSource) {
   const value = recordValue(input);
   if (!value) {
@@ -164,7 +181,12 @@ function createRunState(input) {
   const createdAt = input.created_at || timestamp();
   return compactRecord({
     version: RIDDLE_PROOF_RUN_STATE_VERSION,
+    run_id: input.run_id || createRunId(createdAt),
     state_path: input.state_path,
+    worktree_path: input.worktree_path,
+    branch: input.branch || input.request.branch,
+    current_stage: input.current_stage ?? null,
+    stage_started_at: input.stage_started_at ?? null,
     status: input.status || "running",
     created_at: createdAt,
     updated_at: input.updated_at || createdAt,
@@ -192,9 +214,49 @@ function appendRunEvent(state, input) {
     details: event.details
   }));
   if (input.checkpoint !== void 0) state.last_checkpoint = input.checkpoint;
+  if (input.stage !== void 0) {
+    if (state.current_stage !== input.stage) state.stage_started_at = event.ts;
+    state.current_stage = input.stage;
+  }
   state.updated_at = event.ts;
   return state;
 }
+function appendStageHeartbeat(state, input) {
+  const at = input.ts || timestamp();
+  return appendRunEvent(state, {
+    ts: at,
+    kind: "stage.heartbeat",
+    checkpoint: input.checkpoint || `${input.stage}_heartbeat`,
+    stage: input.stage,
+    summary: input.summary || `${input.stage} stage is active.`,
+    details: compactRecord({
+      elapsed_ms: elapsedMs(state.created_at, at),
+      stage_elapsed_ms: elapsedMs(state.stage_started_at, at),
+      wait_reason: input.wait_reason,
+      blocker: input.blocker,
+      ...input.details
+    })
+  });
+}
+function createRunStatusSnapshot(state, at = timestamp()) {
+  const latestEvent = state.events[state.events.length - 1];
+  const runId = state.run_id || "unknown";
+  return compactRecord({
+    run_id: runId,
+    status: state.status,
+    current_stage: state.current_stage ?? null,
+    state_path: state.state_path ?? null,
+    worktree_path: state.worktree_path ?? null,
+    branch: state.branch ?? null,
+    iterations: state.iterations,
+    last_checkpoint: state.last_checkpoint ?? null,
+    updated_at: state.updated_at,
+    elapsed_ms: elapsedMs(state.created_at, at),
+    stage_elapsed_ms: elapsedMs(state.stage_started_at, at),
+    blocker: state.blocker,
+    latest_event: latestEvent
+  });
+}
 function setRunStatus(state, status, at = timestamp()) {
   state.status = status;
   state.ok = status !== "blocked" && status !== "failed";
@@ -279,7 +341,8 @@ async function notifyIfConfigured(input) {
 async function runRiddleProof(input) {
   const state = input.state || createRunState({
     request: input.request,
-    state_path: input.state_path
+    state_path: input.state_path,
+    worktree_path: input.workdir
   });
   const adapters = input.adapters || {};
   const maxIterations = Math.max(1, Math.trunc(input.max_iterations ?? 1));
@@ -289,12 +352,70 @@ async function runRiddleProof(input) {
     stage: "setup",
     summary: "Riddle Proof run started.",
     details: {
+      run_id: state.run_id,
+      state_path: state.state_path,
+      worktree_path: state.worktree_path,
+      branch: state.branch,
       max_iterations: maxIterations,
       ship_mode: state.request.ship_mode || "none"
     }
   });
+  appendStageHeartbeat(state, {
+    stage: "setup",
+    summary: "Setup stage is active.",
+    details: {
+      run_id: state.run_id,
+      state_path: state.state_path,
+      worktree_path: state.worktree_path,
+      branch: state.branch
+    }
+  });
   let workdir = input.workdir;
   let evidenceContext;
+  if (adapters.preflight) {
+    appendRunEvent(state, {
+      kind: "preflight.started",
+      checkpoint: "preflight_started",
+      stage: "preflight",
+      summary: "Riddle Proof preflight adapter started."
+    });
+    try {
+      const preflight = await adapters.preflight.preflight({ request: state.request, state });
+      if (!preflight.ok) {
+        return blockRun({
+          state,
+          stage: "preflight",
+          blocker: adapterBlocker(
+            "preflight_failed",
+            "The preflight adapter found blocking tool or model configuration issues.",
+            "preflight_failed",
+            {
+              blockers: preflight.blockers,
+              warnings: preflight.warnings,
+              degraded_capabilities: preflight.degraded_capabilities
+            }
+          ),
+          raw: { preflight }
+        });
+      }
+      appendRunEvent(state, {
+        kind: "preflight.completed",
+        checkpoint: "preflight_completed",
+        stage: "preflight",
+        summary: "Riddle Proof preflight adapter completed.",
+        details: {
+          warnings: preflight.warnings,
+          degraded_capabilities: preflight.degraded_capabilities
+        }
+      });
+    } catch (error) {
+      return blockRun({
+        state,
+        stage: "preflight",
+        blocker: adapterBlocker("preflight_exception", "The preflight adapter threw an exception.", "preflight_failed", errorDetails(error))
+      });
+    }
+  }
   if (adapters.setup) {
     appendRunEvent(state, {
       kind: "setup.started",
@@ -317,7 +438,9 @@ async function runRiddleProof(input) {
           raw: { setup }
         });
       }
-      workdir = setup.workdir || workdir;
+      workdir = setup.worktree_path || setup.workdir || workdir;
+      state.worktree_path = setup.worktree_path || setup.workdir || state.worktree_path;
+      state.branch = setup.branch || state.branch;
       evidenceContext = setup.evidence_context;
       appendRunEvent(state, {
         kind: "setup.completed",
@@ -326,6 +449,9 @@ async function runRiddleProof(input) {
         summary: "Riddle Proof setup adapter completed.",
         details: {
           has_workdir: Boolean(workdir),
+          worktree_path: state.worktree_path,
+          branch: state.branch,
+          cleanup_policy: setup.cleanup_policy,
           has_evidence_context: Boolean(evidenceContext)
         }
       });
@@ -378,6 +504,11 @@ async function runRiddleProof(input) {
   let assessment;
   for (let attempt = 0; attempt < maxIterations; attempt += 1) {
     state.iterations += 1;
+    appendStageHeartbeat(state, {
+      stage: "implement",
+      summary: "Implementation stage is active.",
+      details: { iteration: state.iterations }
+    });
     appendRunEvent(state, {
       kind: "implementation.started",
       checkpoint: "implementation_started",
@@ -424,6 +555,13 @@ async function runRiddleProof(input) {
         tests_run: implementation.tests_run
       }
     });
+    appendStageHeartbeat(state, {
+      stage: "prove",
+      summary: "Proof capture stage is active.",
+      details: {
+        verification_mode: state.request.verification_mode
+      }
+    });
     appendRunEvent(state, {
       kind: "proof.started",
       checkpoint: "proof_started",
@@ -473,6 +611,13 @@ async function runRiddleProof(input) {
       stage: "verify",
       summary: "Judge adapter started."
     });
+    appendStageHeartbeat(state, {
+      stage: "verify",
+      summary: "Verification stage is active.",
+      details: {
+        verification_mode: evidenceBundle.verification_mode
+      }
+    });
     try {
       assessment = await adapters.judge.assessProof({ state, evidence_bundle: evidenceBundle });
       state.proof_decision = assessment.decision;
@@ -562,6 +707,10 @@ async function runRiddleProof(input) {
     stage: "ship",
     summary: "Ship adapter started."
   });
+  appendStageHeartbeat(state, {
+    stage: "ship",
+    summary: "Ship stage is active."
+  });
   let metadata;
   try {
     metadata = await adapters.ship.ship({ state, assessment });
@@ -600,10 +749,12 @@ async function runRiddleProof(input) {
 0 && (module.exports = {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
+  appendStageHeartbeat,
   applyTerminalMetadata,
   compactRecord,
   createRunResult,
   createRunState,
+  createRunStatusSnapshot,
   isSuccessfulStatus,
   isTerminalStatus,
   nonEmptyString,

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-export { EvidenceArtifact, EvidenceReference, ImplementationAdapter, ImplementationAdapterInput, ImplementationAdapterResult, IntegrationContext, JsonObject, JsonPrimitive, JsonValue, JudgeAdapter, NotificationAdapter, ProofAdapter, ProofAdapterInput, ProofAdapterResult, RiddleProofAssessment, RiddleProofBlocker, RiddleProofDecision, RiddleProofEvent, RiddleProofEvidenceBundle, RiddleProofRunParams, RiddleProofRunResult, RiddleProofRunState, RiddleProofStage, RiddleProofStatus, RiddleProofTerminalMetadata, RiddleProofVerificationMode, SetupAdapter, SetupAdapterInput, SetupAdapterResult, ShipAdapter } from './types.cjs';
+export { EvidenceArtifact, EvidenceReference, ImplementationAdapter, ImplementationAdapterInput, ImplementationAdapterResult, IntegrationContext, JsonObject, JsonPrimitive, JsonValue, JudgeAdapter, NotificationAdapter, PreflightAdapter, PreflightAdapterInput, PreflightAdapterResult, ProofAdapter, ProofAdapterInput, ProofAdapterResult, RiddleProofArtifactRole, RiddleProofAssessment, RiddleProofBlocker, RiddleProofDecision, RiddleProofEvent, RiddleProofEvidenceBundle, RiddleProofRunParams, RiddleProofRunResult, RiddleProofRunState, RiddleProofRunStatusSnapshot, RiddleProofStage, RiddleProofStatus, RiddleProofTerminalMetadata, RiddleProofVerificationMode, SetupAdapter, SetupAdapterInput, SetupAdapterResult, ShipAdapter } from './types.cjs';
 export { TerminalMetadataInput, applyTerminalMetadata, compactRecord, createRunResult, isSuccessfulStatus, isTerminalStatus, nonEmptyString, normalizeTerminalMetadata, recordValue } from './result.cjs';
-export { CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, RunEventInput, appendRunEvent, createRunState, normalizeIntegrationContext, normalizeRunParams, setRunStatus } from './state.cjs';
+export { CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, RunEventInput, appendRunEvent, appendStageHeartbeat, createRunState, createRunStatusSnapshot, normalizeIntegrationContext, normalizeRunParams, setRunStatus } from './state.cjs';
 export { RiddleProofRunnerAdapters, RunRiddleProofInput, runRiddleProof } from './runner.cjs';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { EvidenceArtifact, EvidenceReference, ImplementationAdapter, ImplementationAdapterInput, ImplementationAdapterResult, IntegrationContext, JsonObject, JsonPrimitive, JsonValue, JudgeAdapter, NotificationAdapter, ProofAdapter, ProofAdapterInput, ProofAdapterResult, RiddleProofAssessment, RiddleProofBlocker, RiddleProofDecision, RiddleProofEvent, RiddleProofEvidenceBundle, RiddleProofRunParams, RiddleProofRunResult, RiddleProofRunState, RiddleProofStage, RiddleProofStatus, RiddleProofTerminalMetadata, RiddleProofVerificationMode, SetupAdapter, SetupAdapterInput, SetupAdapterResult, ShipAdapter } from './types.js';
+export { EvidenceArtifact, EvidenceReference, ImplementationAdapter, ImplementationAdapterInput, ImplementationAdapterResult, IntegrationContext, JsonObject, JsonPrimitive, JsonValue, JudgeAdapter, NotificationAdapter, PreflightAdapter, PreflightAdapterInput, PreflightAdapterResult, ProofAdapter, ProofAdapterInput, ProofAdapterResult, RiddleProofArtifactRole, RiddleProofAssessment, RiddleProofBlocker, RiddleProofDecision, RiddleProofEvent, RiddleProofEvidenceBundle, RiddleProofRunParams, RiddleProofRunResult, RiddleProofRunState, RiddleProofRunStatusSnapshot, RiddleProofStage, RiddleProofStatus, RiddleProofTerminalMetadata, RiddleProofVerificationMode, SetupAdapter, SetupAdapterInput, SetupAdapterResult, ShipAdapter } from './types.js';
 export { TerminalMetadataInput, applyTerminalMetadata, compactRecord, createRunResult, isSuccessfulStatus, isTerminalStatus, nonEmptyString, normalizeTerminalMetadata, recordValue } from './result.js';
-export { CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, RunEventInput, appendRunEvent, createRunState, normalizeIntegrationContext, normalizeRunParams, setRunStatus } from './state.js';
+export { CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, RunEventInput, appendRunEvent, appendStageHeartbeat, createRunState, createRunStatusSnapshot, normalizeIntegrationContext, normalizeRunParams, setRunStatus } from './state.js';
 export { RiddleProofRunnerAdapters, RunRiddleProofInput, runRiddleProof } from './runner.js';

package/dist/index.js

@@ -1,14 +1,16 @@
 import {
   runRiddleProof
-} from "./chunk-GWGXPNON.js";
+} from "./chunk-P3FUU5X4.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
+  appendStageHeartbeat,
   createRunState,
+  createRunStatusSnapshot,
   normalizeIntegrationContext,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-EPVZKWUS.js";
+} from "./chunk-IQIEOQZF.js";
 import {
   applyTerminalMetadata,
   compactRecord,
@@ -18,15 +20,17 @@ import {
   nonEmptyString,
   normalizeTerminalMetadata,
   recordValue
-} from "./chunk-2ZQNXVQC.js";
+} from "./chunk-5DC6YXN4.js";
 import "./chunk-6F4PWJZI.js";
 export {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
+  appendStageHeartbeat,
   applyTerminalMetadata,
   compactRecord,
   createRunResult,
   createRunState,
+  createRunStatusSnapshot,
   isSuccessfulStatus,
   isTerminalStatus,
   nonEmptyString,

package/dist/openclaw.js

@@ -1,10 +1,10 @@
 import {
   normalizeIntegrationContext,
   normalizeRunParams
-} from "./chunk-EPVZKWUS.js";
+} from "./chunk-IQIEOQZF.js";
 import {
   compactRecord
-} from "./chunk-2ZQNXVQC.js";
+} from "./chunk-5DC6YXN4.js";
 
 // src/openclaw.ts
 function parseOpenClawAssertions(value) {

package/dist/result.cjs

@@ -83,7 +83,11 @@ function createRunResult(input) {
   return compactRecord({
     ok,
     status,
+    run_id: state.run_id,
     state_path: input.state_path ?? state.state_path ?? null,
+    worktree_path: state.worktree_path ?? null,
+    branch: state.branch ?? null,
+    current_stage: state.current_stage ?? null,
     iterations: state.iterations,
     last_checkpoint: state.last_checkpoint ?? null,
     last_summary: input.last_summary ?? null,

package/dist/result.js

@@ -7,7 +7,7 @@ import {
   nonEmptyString,
   normalizeTerminalMetadata,
   recordValue
-} from "./chunk-2ZQNXVQC.js";
+} from "./chunk-5DC6YXN4.js";
 export {
   applyTerminalMetadata,
   compactRecord,