@riddledc/riddle-proof 0.5.37 → 0.5.39

package/README.md

@@ -82,21 +82,25 @@ updates Discord, OpenClaw, GitHub, or another integration.
 
 The packaged proof-run setup uses isolated git worktrees for before and after
 states. By default those worktrees now live under
-`/tmp/.riddle-proof-worktrees`, with dependency caches under the matching local
-temp root. This keeps repeated `node_modules` cache materialization on local
-scratch storage instead of walking large dependency trees on EFS or other shared
-workspace filesystems.
+`/var/tmp/riddle-proof/.riddle-proof-worktrees`, with dependency caches under
+the matching disk-backed scratch root. This keeps repeated `node_modules` cache
+materialization off tmpfs `/tmp` and away from EFS or other shared workspace
+filesystems.
 
 Set `RIDDLE_PROOF_WORKTREE_ROOT` to choose an explicit location. Set
 `RIDDLE_PROOF_USE_WORKSPACE_WORKTREE_ROOT=1` to keep the previous behavior of
-placing proof worktrees next to the active repository.
+placing proof worktrees next to the active repository. Set
+`RIDDLE_PROOF_SCRATCH_ROOT` to choose the scratch parent, or
+`RIDDLE_PROOF_USE_TMP_SCRATCH=1` to force tmp-backed scratch for a short-lived
+test.
 
 When local scratch storage is low, setup prunes stale
 `riddle-proof-*` worktrees from the scratch root before creating the next run.
 This preserves the dependency cache for speed while avoiding old failed runs
-filling `/tmp`. Set `RIDDLE_PROOF_KEEP_SCRATCH_WORKTREES=1` to disable that
-cleanup for debugging, or tune the low-space threshold with
-`RIDDLE_PROOF_MIN_SCRATCH_FREE_MB`.
+filling the scratch disk. Setup also records scratch disk snapshots in the run
+state so disk blockers are visible during proof inspection. Set
+`RIDDLE_PROOF_KEEP_SCRATCH_WORKTREES=1` to disable that cleanup for debugging,
+or tune the low-space threshold with `RIDDLE_PROOF_MIN_SCRATCH_FREE_MB`.
 
 ## Capture Diagnostics
 

package/dist/checkpoint.cjs

@@ -0,0 +1,230 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/checkpoint.ts
+var checkpoint_exports = {};
+__export(checkpoint_exports, {
+  RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION: () => RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
+  RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION: () => RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
+  authorPacketPayloadFromCheckpointResponse: () => authorPacketPayloadFromCheckpointResponse,
+  buildAuthorCheckpointPacket: () => buildAuthorCheckpointPacket,
+  normalizeCheckpointResponse: () => normalizeCheckpointResponse
+});
+module.exports = __toCommonJS(checkpoint_exports);
+var import_node_crypto = __toESM(require("crypto"), 1);
+
+// src/result.ts
+function compactRecord(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0 && value !== null && value !== ""));
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// src/checkpoint.ts
+var RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION = "riddle-proof.checkpoint.v1";
+var RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION = "riddle-proof.checkpoint_response.v1";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function jsonCloneRecord(value) {
+  const record = recordValue(value);
+  if (!record) return void 0;
+  try {
+    return JSON.parse(JSON.stringify(record));
+  } catch {
+    return { ...record };
+  }
+}
+function compactText(value, limit = 1600) {
+  const text = nonEmptyString(value);
+  if (!text) return void 0;
+  return text.length <= limit ? text : `${text.slice(0, limit - 20).trimEnd()}...`;
+}
+function responseSchemaForAuthorPacket() {
+  return {
+    type: "object",
+    required: ["version", "run_id", "checkpoint", "decision", "summary", "payload", "created_at"],
+    additionalProperties: false,
+    properties: {
+      version: { const: RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION },
+      run_id: { type: "string" },
+      checkpoint: { type: "string" },
+      resume_token: { type: "string" },
+      decision: {
+        type: "string",
+        enum: ["author_packet", "needs_recon", "blocked", "human_review"]
+      },
+      summary: { type: "string" },
+      payload: {
+        type: "object",
+        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan and capture_script."
+      },
+      reasons: { type: "array", items: { type: "string" } },
+      continue_with_stage: { type: "string", enum: ["author", "recon"] },
+      source: {
+        type: "object",
+        properties: {
+          kind: { type: "string" },
+          session_id: { type: "string" },
+          user_id: { type: "string" }
+        }
+      },
+      created_at: { type: "string" }
+    }
+  };
+}
+function resumeTokenFor(input) {
+  const hash = import_node_crypto.default.createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 24);
+  return `rpchk_${hash}`;
+}
+function artifactsFromState(state) {
+  const artifacts = [];
+  for (const role of ["before", "prod", "after"]) {
+    const url = nonEmptyString(state?.[`${role}_cdn`]);
+    if (url) artifacts.push({ role, url, name: `${role}.png`, mime_type: "image/png" });
+  }
+  const authorRequest = recordValue(state?.author_request);
+  const latestAttempt = recordValue(authorRequest?.latest_attempt);
+  const observations = recordValue(latestAttempt?.observations);
+  for (const [label, observation] of Object.entries(observations || {})) {
+    const record = recordValue(observation);
+    const url = nonEmptyString(record?.url);
+    if (url && !artifacts.some((artifact) => artifact.url === url)) {
+      artifacts.push({
+        role: label === "before" || label === "prod" ? label : "json",
+        url,
+        name: `${label}-observation`,
+        summary: compactText(record?.reason, 240)
+      });
+    }
+  }
+  return artifacts.slice(0, 16);
+}
+function buildAuthorCheckpointPacket(input) {
+  const checkpoint = nonEmptyString(input.engineResult.checkpoint) || "author_supervisor_judgment";
+  const stage = "author";
+  const runId = input.runState.run_id || "unknown";
+  const fullState = input.fullRiddleState || {};
+  const decisionDetails = recordValue(input.engineResult.decisionRequest?.details);
+  const authorRequest = recordValue(fullState.author_request) || recordValue(fullState.proof_plan_request) || recordValue(decisionDetails?.authorRequest) || {};
+  const fallbackDefaults = recordValue(authorRequest.fallback_defaults) || {};
+  const reconResults = recordValue(fullState.recon_results);
+  const checkpointContract = recordValue(input.engineResult.checkpointContract);
+  const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.author_summary) || "Author checkpoint needs a supervising proof packet.";
+  return {
+    version: RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
+    run_id: runId,
+    state_path: input.runState.state_path,
+    stage,
+    checkpoint,
+    kind: "author_proof",
+    summary,
+    question: "Author the proof packet for this Riddle Proof run. Return a CheckpointResponse with decision=author_packet and payload containing proof_plan and capture_script.",
+    change_request: input.request.change_request || nonEmptyString(fullState.change_request) || "",
+    context: input.request.context,
+    artifacts: artifactsFromState(fullState),
+    state_excerpt: compactRecord({
+      repo: input.request.repo || fullState.repo,
+      branch: input.request.branch || fullState.branch,
+      verification_mode: input.request.verification_mode || fullState.verification_mode,
+      reference: input.request.reference || fullState.reference,
+      server_path: fullState.server_path,
+      wait_for_selector: fullState.wait_for_selector,
+      author_summary: fullState.author_summary,
+      author_request: jsonCloneRecord(authorRequest),
+      recon_baseline_understanding: jsonCloneRecord(fullState.recon_baseline_understanding),
+      fallback_defaults: jsonCloneRecord(fallbackDefaults)
+    }),
+    evidence_excerpt: compactRecord({
+      recon_results: jsonCloneRecord(reconResults),
+      checkpoint_contract: jsonCloneRecord(checkpointContract)
+    }),
+    allowed_decisions: ["author_packet", "needs_recon", "blocked", "human_review"],
+    response_schema: responseSchemaForAuthorPacket(),
+    routing_hint: {
+      suggested_role: "proof_author",
+      visibility: input.visibility || "quiet",
+      urgency: "normal",
+      can_auto_answer: input.visibility !== "manual"
+    },
+    resume_token: resumeTokenFor({
+      runId,
+      statePath: input.engineResult.state_path || input.request.engine_state_path || null,
+      checkpoint,
+      stage
+    }),
+    created_at: input.created_at || timestamp()
+  };
+}
+function normalizeCheckpointResponse(value) {
+  const record = recordValue(value);
+  if (!record) return null;
+  const version = nonEmptyString(record.version);
+  const runId = nonEmptyString(record.run_id);
+  const checkpoint = nonEmptyString(record.checkpoint);
+  const decision = nonEmptyString(record.decision);
+  const summary = nonEmptyString(record.summary);
+  if (version !== RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION || !runId || !checkpoint || !decision || !summary) {
+    return null;
+  }
+  return compactRecord({
+    version: RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
+    run_id: runId,
+    checkpoint,
+    resume_token: nonEmptyString(record.resume_token),
+    decision,
+    summary,
+    payload: jsonCloneRecord(record.payload),
+    reasons: Array.isArray(record.reasons) ? record.reasons.filter((item) => typeof item === "string") : void 0,
+    continue_with_stage: nonEmptyString(record.continue_with_stage),
+    source: jsonCloneRecord(record.source),
+    created_at: nonEmptyString(record.created_at) || timestamp()
+  });
+}
+function authorPacketPayloadFromCheckpointResponse(response) {
+  if (response.decision !== "author_packet") return null;
+  const payload = recordValue(response.payload);
+  if (!payload) return null;
+  const nested = recordValue(payload.author_packet);
+  const candidate = nested || payload;
+  if (!nonEmptyString(candidate.proof_plan) || !nonEmptyString(candidate.capture_script)) return null;
+  return candidate;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
+  RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
+  authorPacketPayloadFromCheckpointResponse,
+  buildAuthorCheckpointPacket,
+  normalizeCheckpointResponse
+});

package/dist/checkpoint.d.cts

@@ -0,0 +1,22 @@
+import { RiddleProofCheckpointResponse, RiddleProofRunParams, RiddleProofRunState, RiddleProofCheckpointPacket } from './types.cjs';
+
+declare const RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION: "riddle-proof.checkpoint.v1";
+declare const RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION: "riddle-proof.checkpoint_response.v1";
+declare function buildAuthorCheckpointPacket(input: {
+    request: RiddleProofRunParams;
+    runState: RiddleProofRunState;
+    engineResult: {
+        state_path?: string | null;
+        checkpoint?: string | null;
+        checkpointContract?: Record<string, unknown> | null;
+        decisionRequest?: Record<string, unknown> | null;
+        summary?: string;
+    };
+    fullRiddleState?: Record<string, unknown> | null;
+    visibility?: "liveblog" | "quiet" | "terminal_only" | "manual" | string;
+    created_at?: string;
+}): RiddleProofCheckpointPacket;
+declare function normalizeCheckpointResponse(value: unknown): RiddleProofCheckpointResponse | null;
+declare function authorPacketPayloadFromCheckpointResponse(response: RiddleProofCheckpointResponse): Record<string, unknown> | null;
+
+export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, normalizeCheckpointResponse };

package/dist/checkpoint.d.ts

@@ -0,0 +1,22 @@
+import { RiddleProofCheckpointResponse, RiddleProofRunParams, RiddleProofRunState, RiddleProofCheckpointPacket } from './types.js';
+
+declare const RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION: "riddle-proof.checkpoint.v1";
+declare const RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION: "riddle-proof.checkpoint_response.v1";
+declare function buildAuthorCheckpointPacket(input: {
+    request: RiddleProofRunParams;
+    runState: RiddleProofRunState;
+    engineResult: {
+        state_path?: string | null;
+        checkpoint?: string | null;
+        checkpointContract?: Record<string, unknown> | null;
+        decisionRequest?: Record<string, unknown> | null;
+        summary?: string;
+    };
+    fullRiddleState?: Record<string, unknown> | null;
+    visibility?: "liveblog" | "quiet" | "terminal_only" | "manual" | string;
+    created_at?: string;
+}): RiddleProofCheckpointPacket;
+declare function normalizeCheckpointResponse(value: unknown): RiddleProofCheckpointResponse | null;
+declare function authorPacketPayloadFromCheckpointResponse(response: RiddleProofCheckpointResponse): Record<string, unknown> | null;
+
+export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, normalizeCheckpointResponse };

package/dist/checkpoint.js

@@ -0,0 +1,15 @@
+import {
+  RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
+  RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
+  authorPacketPayloadFromCheckpointResponse,
+  buildAuthorCheckpointPacket,
+  normalizeCheckpointResponse
+} from "./chunk-UQPTCP4D.js";
+import "./chunk-Z7QUCDPT.js";
+export {
+  RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
+  RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
+  authorPacketPayloadFromCheckpointResponse,
+  buildAuthorCheckpointPacket,
+  normalizeCheckpointResponse
+};

package/dist/{chunk-GN7HSZ6G.js → chunk-ORRP7CXT.js}

@@ -1,3 +1,8 @@
+import {
+  authorPacketPayloadFromCheckpointResponse,
+  buildAuthorCheckpointPacket,
+  normalizeCheckpointResponse
+} from "./chunk-UQPTCP4D.js";
 import {
   appendRunEvent,
   appendStageHeartbeat,
@@ -5,7 +10,7 @@ import {
   createRunStatusSnapshot,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-OASB3CYU.js";
+} from "./chunk-Z3BWCHFV.js";
 import {
   applyTerminalMetadata,
   compactRecord,
@@ -13,7 +18,7 @@ import {
   nonEmptyString,
   normalizeTerminalMetadata,
   recordValue
-} from "./chunk-J2MERROF.js";
+} from "./chunk-Z7QUCDPT.js";
 import {
   visualDeltaShipGateReason
 } from "./chunk-4YCWZVBN.js";
@@ -403,6 +408,150 @@ function blockerResult(state, result, blocker) {
     }
   });
 }
+function checkpointAwaitingResult(state, result, visibility) {
+  const packet = buildAuthorCheckpointPacket({
+    request: state.request,
+    runState: state,
+    engineResult: result,
+    fullRiddleState: fullRiddleState(result, state),
+    visibility
+  });
+  const at = timestamp();
+  state.checkpoint_packet = packet;
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, packet }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.packet.created",
+    checkpoint: packet.checkpoint,
+    stage: packet.stage,
+    summary: packet.summary,
+    details: compactRecord({
+      kind: packet.kind,
+      routing_hint: packet.routing_hint,
+      resume_token: packet.resume_token
+    })
+  });
+  setRunStatus(state, "awaiting_checkpoint", at);
+  persist(state);
+  return createRunResult({
+    state,
+    status: "awaiting_checkpoint",
+    last_summary: packet.summary,
+    raw: {
+      engine_state_path: result.state_path || state.request.engine_state_path || null,
+      last_result: result,
+      checkpoint_packet: packet
+    }
+  });
+}
+function appendCheckpointResponse(state, response, input = {}) {
+  const at = timestamp();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  if (input.clear_packet !== false) {
+    state.checkpoint_packet = void 0;
+  }
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.accepted",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "author",
+    summary: input.summary || response.summary,
+    details: compactRecord({
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  setRunStatus(state, "running", at);
+  persist(state);
+}
+function checkpointResponseContinuation(state, value) {
+  if (!value) return {};
+  const packet = state.checkpoint_packet;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) {
+    return {
+      blocker: {
+        code: "checkpoint_response_invalid",
+        checkpoint: packet?.checkpoint || state.last_checkpoint || null,
+        message: "Checkpoint response was not a valid riddle-proof.checkpoint_response.v1 object.",
+        details: { checkpoint_packet: packet || null }
+      }
+    };
+  }
+  if (!packet) {
+    return {
+      blocker: {
+        code: "checkpoint_response_without_packet",
+        checkpoint: response.checkpoint,
+        message: "A checkpoint response was supplied, but the run state has no pending checkpoint packet.",
+        details: { response }
+      }
+    };
+  }
+  if (response.run_id !== packet.run_id || response.checkpoint !== packet.checkpoint) {
+    return {
+      blocker: {
+        code: "checkpoint_response_mismatch",
+        checkpoint: packet.checkpoint,
+        message: "Checkpoint response does not match the pending checkpoint packet.",
+        details: {
+          expected: { run_id: packet.run_id, checkpoint: packet.checkpoint },
+          actual: { run_id: response.run_id, checkpoint: response.checkpoint }
+        }
+      }
+    };
+  }
+  if (packet.resume_token && response.resume_token !== packet.resume_token) {
+    return {
+      blocker: {
+        code: "checkpoint_response_resume_token_mismatch",
+        checkpoint: packet.checkpoint,
+        message: "Checkpoint response resume_token does not match the pending checkpoint packet.",
+        details: { expected_resume_token: packet.resume_token, actual_resume_token: response.resume_token || null }
+      }
+    };
+  }
+  const base = {
+    action: "run",
+    state_path: state.request.engine_state_path || packet.state_path || "",
+    continue_from_checkpoint: true
+  };
+  if (response.decision === "author_packet") {
+    const payload = authorPacketPayloadFromCheckpointResponse(response);
+    if (!payload) {
+      return {
+        blocker: {
+          code: "checkpoint_author_packet_missing",
+          checkpoint: packet.checkpoint,
+          message: "Checkpoint response decision=author_packet did not include a proof_plan and capture_script payload.",
+          details: { response }
+        }
+      };
+    }
+    appendCheckpointResponse(state, response);
+    return { next: { ...base, author_packet_json: jsonParam(payload) } };
+  }
+  if (response.decision === "needs_recon") {
+    appendCheckpointResponse(state, response);
+    return { next: { ...base, advance_stage: "recon" } };
+  }
+  appendCheckpointResponse(state, response, { clear_packet: false });
+  return {
+    blocker: {
+      code: `checkpoint_response_${response.decision}`,
+      checkpoint: packet.checkpoint,
+      message: response.summary || `Checkpoint response stopped the run with decision=${response.decision}.`,
+      details: { response }
+    }
+  };
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -651,6 +800,9 @@ async function routeCheckpoint(request, state, result, agent, input) {
   const continueStage = checkpointContinueStage(result);
   const checkpointContinuesToAuthor = continueStage === "author";
   if (checkpoint === "author_supervisor_judgment" || checkpoint === "verify_capture_retry" || checkpoint === "verify_agent_retry" && checkpointContinuesToAuthor) {
+    if (input.checkpoint_mode === "yield") {
+      return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
+    }
     const packet = await agent.authorProofPacket(context);
     const blocker = requirePayload("author_packet", packet, state, result);
     if (blocker) return { blocker };
@@ -752,6 +904,10 @@ 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 checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
+  if (checkpointContinuation.blocker) {
+    return blockerResult(state, null, checkpointContinuation.blocker);
+  }
   const request = state.request;
   const agent = input.agent || createDisabledRiddleProofAgentAdapter();
   const maxIterations = Math.max(
@@ -773,6 +929,8 @@ async function runRiddleProofEngineHarness(input) {
       engine_state_path: request.engine_state_path || null,
       max_iterations: maxIterations,
       ship_mode: effectiveShipMode(request, input.config),
+      checkpoint_mode: input.checkpoint_mode || "auto",
+      checkpoint_visibility: input.checkpoint_visibility || null,
       leave_draft: request.leave_draft || false
     }
   });
@@ -787,7 +945,7 @@ async function runRiddleProofEngineHarness(input) {
       message
     });
   }
-  let nextParams = input.resume_params || initialRunParams(request, input, state);
+  let nextParams = input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state);
   let lastResult = null;
   const stageIterations = {};
   for (let index = 0; index < maxIterations; index += 1) {

package/dist/{chunk-MQ2BHHLX.js → chunk-RDTMR7XR.js}

@@ -3,10 +3,10 @@ import {
   appendStageHeartbeat,
   createRunState,
   setRunStatus
-} from "./chunk-OASB3CYU.js";
+} from "./chunk-Z3BWCHFV.js";
 import {
   createRunResult
-} from "./chunk-J2MERROF.js";
+} from "./chunk-Z7QUCDPT.js";
 
 // src/runner.ts
 function errorDetails(error) {