@riddledc/riddle-proof 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RiddleDC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @riddledc/riddle-proof
+
+Reusable contracts and helpers for Riddle Proof: evidence-backed workflows for
+agent-authored changes.
+
+Riddle Proof is agent-agnostic. Bring a coding agent through an adapter; Riddle
+Proof standardizes evidence, proof assessment, ship gates, terminal results,
+and integration metadata.
+
+This package is intentionally small at first. The current OpenClaw
+`proofed_change_run` implementation remains the reference workflow while
+reusable contracts and low-risk helpers are extracted here.
+
+## Initial Scope
+
+- Run/result/state/event types
+- Evidence bundle and proof assessment types
+- Adapter interfaces
+- State/event helpers for wrappers that need a stable run envelope
+- Terminal ship metadata normalization
+- Stable result helpers
+- OpenClaw parameter normalization via `@riddledc/riddle-proof/openclaw`
+
+## Non-Goals
+
+- Supplying a coding agent
+- Replacing the working OpenClaw plugin in place
+- Invoking OpenClaw plugins from inside other plugins
+
+Future wrappers can consume this package from OpenClaw, Discord, CLI, GitHub
+Actions, or Riddle-hosted workflows.
+
+## OpenClaw Adapter Boundary
+
+`@riddledc/riddle-proof/openclaw` translates the current
+`proofed_change_run`-style tool params into generic `RiddleProofRunParams`.
+It preserves Discord routing metadata as `integration_context` and parses
+`assertions_json` into the shared assertions field.
+
+The adapter does not invoke another OpenClaw plugin and does not supply a
+coding agent. It is the reusable mapping layer a future OpenClaw wrapper can
+call before handing the request to its configured implementation, judge, ship,
+and notification adapters.

package/dist/chunk-2ZQNXVQC.js

@@ -0,0 +1,81 @@
+// src/result.ts
+function isTerminalStatus(status) {
+  return status === "blocked" || status === "failed" || status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function isSuccessfulStatus(status) {
+  return status !== "blocked" && status !== "failed";
+}
+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;
+}
+function normalizeTerminalMetadata(input) {
+  const riddleState = recordValue(input.riddleState) || {};
+  const result = recordValue(input.engineResult) || {};
+  const contract = recordValue(result.checkpointContract) || {};
+  const details = recordValue(input.checkpointDetails) || recordValue(contract.details) || {};
+  const markedReady = riddleState.marked_ready ?? result.marked_ready ?? result.markedReady ?? details.marked_ready ?? details.markedReady;
+  const finalized = riddleState.finalized ?? result.finalized ?? details.finalized;
+  return compactRecord({
+    pr_url: nonEmptyString(riddleState.pr_url) || nonEmptyString(result.pr_url) || nonEmptyString(result.prUrl) || nonEmptyString(details.pr_url) || nonEmptyString(details.prUrl),
+    marked_ready: typeof markedReady === "boolean" ? markedReady : void 0,
+    notification: recordValue(riddleState.notification) || recordValue(riddleState.discord_notification) || recordValue(result.notification) || recordValue(result.discord_notification),
+    proof_decision: nonEmptyString(riddleState.proof_decision) || nonEmptyString(result.proof_decision),
+    merge_recommendation: nonEmptyString(riddleState.merge_recommendation) || nonEmptyString(result.merge_recommendation),
+    finalized: typeof finalized === "boolean" ? finalized : void 0
+  });
+}
+function applyTerminalMetadata(state, metadata) {
+  const prUrl = nonEmptyString(metadata.pr_url);
+  if (prUrl) state.pr_url = prUrl;
+  if (typeof metadata.marked_ready === "boolean") state.marked_ready = metadata.marked_ready;
+  const notification = recordValue(metadata.notification);
+  if (notification) state.notification = notification;
+  const proofDecision = nonEmptyString(metadata.proof_decision);
+  if (proofDecision) state.proof_decision = proofDecision;
+  const mergeRecommendation = nonEmptyString(metadata.merge_recommendation);
+  if (mergeRecommendation) state.merge_recommendation = mergeRecommendation;
+  if (typeof metadata.finalized === "boolean") state.finalized = metadata.finalized;
+  return state;
+}
+function createRunResult(input) {
+  const status = input.status || input.state.status;
+  const ok = isSuccessfulStatus(status);
+  const state = input.metadata ? applyTerminalMetadata(input.state, input.metadata) : input.state;
+  state.status = status;
+  state.ok = ok;
+  return compactRecord({
+    ok,
+    status,
+    state_path: input.state_path ?? state.state_path ?? null,
+    iterations: state.iterations,
+    last_checkpoint: state.last_checkpoint ?? null,
+    last_summary: input.last_summary ?? null,
+    event_count: state.events.length,
+    pr_url: state.pr_url,
+    marked_ready: state.marked_ready,
+    notification: state.notification,
+    proof_decision: state.proof_decision,
+    merge_recommendation: state.merge_recommendation,
+    finalized: state.finalized,
+    blocker: state.blocker,
+    evidence_bundle: input.evidence_bundle,
+    raw: input.raw
+  });
+}
+
+export {
+  isTerminalStatus,
+  isSuccessfulStatus,
+  compactRecord,
+  nonEmptyString,
+  recordValue,
+  normalizeTerminalMetadata,
+  applyTerminalMetadata,
+  createRunResult
+};

package/dist/chunk-EPVZKWUS.js

@@ -0,0 +1,107 @@
+import {
+  compactRecord,
+  nonEmptyString,
+  recordValue
+} from "./chunk-2ZQNXVQC.js";
+
+// src/state.ts
+var RIDDLE_PROOF_RUN_STATE_VERSION = "riddle-proof.run-state.v1";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeIntegrationContext(input, fallbackSource) {
+  const value = recordValue(input);
+  if (!value) {
+    return fallbackSource ? { source: fallbackSource } : void 0;
+  }
+  const metadata = recordValue(value.metadata);
+  return compactRecord({
+    source: nonEmptyString(value.source) || fallbackSource,
+    channel_id: nonEmptyString(value.channel_id),
+    thread_id: nonEmptyString(value.thread_id),
+    message_id: nonEmptyString(value.message_id),
+    source_url: nonEmptyString(value.source_url),
+    metadata: metadata && Object.keys(metadata).length ? metadata : void 0
+  });
+}
+function normalizeRunParams(input) {
+  return compactRecord({
+    repo: input.repo,
+    branch: input.branch,
+    change_request: input.change_request,
+    commit_message: input.commit_message,
+    prod_url: input.prod_url,
+    capture_script: input.capture_script,
+    success_criteria: input.success_criteria,
+    assertions: input.assertions,
+    verification_mode: input.verification_mode,
+    reference: input.reference,
+    base_branch: input.base_branch,
+    before_ref: input.before_ref,
+    allow_static_preview_fallback: input.allow_static_preview_fallback,
+    context: input.context,
+    reviewer: input.reviewer,
+    mode: input.mode,
+    build_command: input.build_command,
+    build_output: input.build_output,
+    server_image: input.server_image,
+    server_command: input.server_command,
+    server_port: input.server_port,
+    server_path: input.server_path,
+    use_auth: input.use_auth,
+    color_scheme: input.color_scheme,
+    wait_for_selector: input.wait_for_selector,
+    ship_mode: input.ship_mode,
+    integration_context: normalizeIntegrationContext(input.integration_context)
+  });
+}
+function createRunState(input) {
+  const createdAt = input.created_at || timestamp();
+  return compactRecord({
+    version: RIDDLE_PROOF_RUN_STATE_VERSION,
+    state_path: input.state_path,
+    status: input.status || "running",
+    created_at: createdAt,
+    updated_at: input.updated_at || createdAt,
+    request: normalizeRunParams(input.request),
+    iterations: input.iterations ?? 0,
+    last_checkpoint: input.last_checkpoint ?? null,
+    events: input.events ? [...input.events] : []
+  });
+}
+function appendRunEvent(state, input) {
+  const event = {
+    ts: input.ts || timestamp(),
+    kind: input.kind,
+    checkpoint: input.checkpoint,
+    stage: input.stage,
+    summary: input.summary,
+    details: input.details
+  };
+  state.events.push(compactRecord({
+    ts: event.ts,
+    kind: event.kind,
+    checkpoint: event.checkpoint,
+    stage: event.stage,
+    summary: event.summary,
+    details: event.details
+  }));
+  if (input.checkpoint !== void 0) state.last_checkpoint = input.checkpoint;
+  state.updated_at = event.ts;
+  return state;
+}
+function setRunStatus(state, status, at = timestamp()) {
+  state.status = status;
+  state.ok = status !== "blocked" && status !== "failed";
+  state.updated_at = at;
+  return state;
+}
+
+export {
+  RIDDLE_PROOF_RUN_STATE_VERSION,
+  normalizeIntegrationContext,
+  normalizeRunParams,
+  createRunState,
+  appendRunEvent,
+  setRunStatus
+};

package/dist/index.cjs

@@ -0,0 +1,219 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RIDDLE_PROOF_RUN_STATE_VERSION: () => RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendRunEvent: () => appendRunEvent,
+  applyTerminalMetadata: () => applyTerminalMetadata,
+  compactRecord: () => compactRecord,
+  createRunResult: () => createRunResult,
+  createRunState: () => createRunState,
+  isSuccessfulStatus: () => isSuccessfulStatus,
+  isTerminalStatus: () => isTerminalStatus,
+  nonEmptyString: () => nonEmptyString,
+  normalizeIntegrationContext: () => normalizeIntegrationContext,
+  normalizeRunParams: () => normalizeRunParams,
+  normalizeTerminalMetadata: () => normalizeTerminalMetadata,
+  recordValue: () => recordValue,
+  setRunStatus: () => setRunStatus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/result.ts
+function isTerminalStatus(status) {
+  return status === "blocked" || status === "failed" || status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function isSuccessfulStatus(status) {
+  return status !== "blocked" && status !== "failed";
+}
+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;
+}
+function normalizeTerminalMetadata(input) {
+  const riddleState = recordValue(input.riddleState) || {};
+  const result = recordValue(input.engineResult) || {};
+  const contract = recordValue(result.checkpointContract) || {};
+  const details = recordValue(input.checkpointDetails) || recordValue(contract.details) || {};
+  const markedReady = riddleState.marked_ready ?? result.marked_ready ?? result.markedReady ?? details.marked_ready ?? details.markedReady;
+  const finalized = riddleState.finalized ?? result.finalized ?? details.finalized;
+  return compactRecord({
+    pr_url: nonEmptyString(riddleState.pr_url) || nonEmptyString(result.pr_url) || nonEmptyString(result.prUrl) || nonEmptyString(details.pr_url) || nonEmptyString(details.prUrl),
+    marked_ready: typeof markedReady === "boolean" ? markedReady : void 0,
+    notification: recordValue(riddleState.notification) || recordValue(riddleState.discord_notification) || recordValue(result.notification) || recordValue(result.discord_notification),
+    proof_decision: nonEmptyString(riddleState.proof_decision) || nonEmptyString(result.proof_decision),
+    merge_recommendation: nonEmptyString(riddleState.merge_recommendation) || nonEmptyString(result.merge_recommendation),
+    finalized: typeof finalized === "boolean" ? finalized : void 0
+  });
+}
+function applyTerminalMetadata(state, metadata) {
+  const prUrl = nonEmptyString(metadata.pr_url);
+  if (prUrl) state.pr_url = prUrl;
+  if (typeof metadata.marked_ready === "boolean") state.marked_ready = metadata.marked_ready;
+  const notification = recordValue(metadata.notification);
+  if (notification) state.notification = notification;
+  const proofDecision = nonEmptyString(metadata.proof_decision);
+  if (proofDecision) state.proof_decision = proofDecision;
+  const mergeRecommendation = nonEmptyString(metadata.merge_recommendation);
+  if (mergeRecommendation) state.merge_recommendation = mergeRecommendation;
+  if (typeof metadata.finalized === "boolean") state.finalized = metadata.finalized;
+  return state;
+}
+function createRunResult(input) {
+  const status = input.status || input.state.status;
+  const ok = isSuccessfulStatus(status);
+  const state = input.metadata ? applyTerminalMetadata(input.state, input.metadata) : input.state;
+  state.status = status;
+  state.ok = ok;
+  return compactRecord({
+    ok,
+    status,
+    state_path: input.state_path ?? state.state_path ?? null,
+    iterations: state.iterations,
+    last_checkpoint: state.last_checkpoint ?? null,
+    last_summary: input.last_summary ?? null,
+    event_count: state.events.length,
+    pr_url: state.pr_url,
+    marked_ready: state.marked_ready,
+    notification: state.notification,
+    proof_decision: state.proof_decision,
+    merge_recommendation: state.merge_recommendation,
+    finalized: state.finalized,
+    blocker: state.blocker,
+    evidence_bundle: input.evidence_bundle,
+    raw: input.raw
+  });
+}
+
+// src/state.ts
+var RIDDLE_PROOF_RUN_STATE_VERSION = "riddle-proof.run-state.v1";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeIntegrationContext(input, fallbackSource) {
+  const value = recordValue(input);
+  if (!value) {
+    return fallbackSource ? { source: fallbackSource } : void 0;
+  }
+  const metadata = recordValue(value.metadata);
+  return compactRecord({
+    source: nonEmptyString(value.source) || fallbackSource,
+    channel_id: nonEmptyString(value.channel_id),
+    thread_id: nonEmptyString(value.thread_id),
+    message_id: nonEmptyString(value.message_id),
+    source_url: nonEmptyString(value.source_url),
+    metadata: metadata && Object.keys(metadata).length ? metadata : void 0
+  });
+}
+function normalizeRunParams(input) {
+  return compactRecord({
+    repo: input.repo,
+    branch: input.branch,
+    change_request: input.change_request,
+    commit_message: input.commit_message,
+    prod_url: input.prod_url,
+    capture_script: input.capture_script,
+    success_criteria: input.success_criteria,
+    assertions: input.assertions,
+    verification_mode: input.verification_mode,
+    reference: input.reference,
+    base_branch: input.base_branch,
+    before_ref: input.before_ref,
+    allow_static_preview_fallback: input.allow_static_preview_fallback,
+    context: input.context,
+    reviewer: input.reviewer,
+    mode: input.mode,
+    build_command: input.build_command,
+    build_output: input.build_output,
+    server_image: input.server_image,
+    server_command: input.server_command,
+    server_port: input.server_port,
+    server_path: input.server_path,
+    use_auth: input.use_auth,
+    color_scheme: input.color_scheme,
+    wait_for_selector: input.wait_for_selector,
+    ship_mode: input.ship_mode,
+    integration_context: normalizeIntegrationContext(input.integration_context)
+  });
+}
+function createRunState(input) {
+  const createdAt = input.created_at || timestamp();
+  return compactRecord({
+    version: RIDDLE_PROOF_RUN_STATE_VERSION,
+    state_path: input.state_path,
+    status: input.status || "running",
+    created_at: createdAt,
+    updated_at: input.updated_at || createdAt,
+    request: normalizeRunParams(input.request),
+    iterations: input.iterations ?? 0,
+    last_checkpoint: input.last_checkpoint ?? null,
+    events: input.events ? [...input.events] : []
+  });
+}
+function appendRunEvent(state, input) {
+  const event = {
+    ts: input.ts || timestamp(),
+    kind: input.kind,
+    checkpoint: input.checkpoint,
+    stage: input.stage,
+    summary: input.summary,
+    details: input.details
+  };
+  state.events.push(compactRecord({
+    ts: event.ts,
+    kind: event.kind,
+    checkpoint: event.checkpoint,
+    stage: event.stage,
+    summary: event.summary,
+    details: event.details
+  }));
+  if (input.checkpoint !== void 0) state.last_checkpoint = input.checkpoint;
+  state.updated_at = event.ts;
+  return state;
+}
+function setRunStatus(state, status, at = timestamp()) {
+  state.status = status;
+  state.ok = status !== "blocked" && status !== "failed";
+  state.updated_at = at;
+  return state;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendRunEvent,
+  applyTerminalMetadata,
+  compactRecord,
+  createRunResult,
+  createRunState,
+  isSuccessfulStatus,
+  isTerminalStatus,
+  nonEmptyString,
+  normalizeIntegrationContext,
+  normalizeRunParams,
+  normalizeTerminalMetadata,
+  recordValue,
+  setRunStatus
+});

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export { EvidenceArtifact, EvidenceReference, ImplementationAdapter, ImplementationAdapterInput, ImplementationAdapterResult, IntegrationContext, JsonObject, JsonPrimitive, JsonValue, JudgeAdapter, NotificationAdapter, RiddleProofAssessment, RiddleProofBlocker, RiddleProofDecision, RiddleProofEvent, RiddleProofEvidenceBundle, RiddleProofRunParams, RiddleProofRunResult, RiddleProofRunState, RiddleProofStage, RiddleProofStatus, RiddleProofTerminalMetadata, RiddleProofVerificationMode, 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';

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { EvidenceArtifact, EvidenceReference, ImplementationAdapter, ImplementationAdapterInput, ImplementationAdapterResult, IntegrationContext, JsonObject, JsonPrimitive, JsonValue, JudgeAdapter, NotificationAdapter, RiddleProofAssessment, RiddleProofBlocker, RiddleProofDecision, RiddleProofEvent, RiddleProofEvidenceBundle, RiddleProofRunParams, RiddleProofRunResult, RiddleProofRunState, RiddleProofStage, RiddleProofStatus, RiddleProofTerminalMetadata, RiddleProofVerificationMode, 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';

package/dist/index.js

@@ -0,0 +1,35 @@
+import {
+  RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendRunEvent,
+  createRunState,
+  normalizeIntegrationContext,
+  normalizeRunParams,
+  setRunStatus
+} from "./chunk-EPVZKWUS.js";
+import {
+  applyTerminalMetadata,
+  compactRecord,
+  createRunResult,
+  isSuccessfulStatus,
+  isTerminalStatus,
+  nonEmptyString,
+  normalizeTerminalMetadata,
+  recordValue
+} from "./chunk-2ZQNXVQC.js";
+import "./chunk-6F4PWJZI.js";
+export {
+  RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendRunEvent,
+  applyTerminalMetadata,
+  compactRecord,
+  createRunResult,
+  createRunState,
+  isSuccessfulStatus,
+  isTerminalStatus,
+  nonEmptyString,
+  normalizeIntegrationContext,
+  normalizeRunParams,
+  normalizeTerminalMetadata,
+  recordValue,
+  setRunStatus
+};

package/dist/openclaw.cjs

@@ -0,0 +1,150 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/openclaw.ts
+var openclaw_exports = {};
+__export(openclaw_exports, {
+  openClawIntegrationContext: () => openClawIntegrationContext,
+  parseOpenClawAssertions: () => parseOpenClawAssertions,
+  toRiddleProofRunParams: () => toRiddleProofRunParams
+});
+module.exports = __toCommonJS(openclaw_exports);
+
+// 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/state.ts
+function normalizeIntegrationContext(input, fallbackSource) {
+  const value = recordValue(input);
+  if (!value) {
+    return fallbackSource ? { source: fallbackSource } : void 0;
+  }
+  const metadata = recordValue(value.metadata);
+  return compactRecord({
+    source: nonEmptyString(value.source) || fallbackSource,
+    channel_id: nonEmptyString(value.channel_id),
+    thread_id: nonEmptyString(value.thread_id),
+    message_id: nonEmptyString(value.message_id),
+    source_url: nonEmptyString(value.source_url),
+    metadata: metadata && Object.keys(metadata).length ? metadata : void 0
+  });
+}
+function normalizeRunParams(input) {
+  return compactRecord({
+    repo: input.repo,
+    branch: input.branch,
+    change_request: input.change_request,
+    commit_message: input.commit_message,
+    prod_url: input.prod_url,
+    capture_script: input.capture_script,
+    success_criteria: input.success_criteria,
+    assertions: input.assertions,
+    verification_mode: input.verification_mode,
+    reference: input.reference,
+    base_branch: input.base_branch,
+    before_ref: input.before_ref,
+    allow_static_preview_fallback: input.allow_static_preview_fallback,
+    context: input.context,
+    reviewer: input.reviewer,
+    mode: input.mode,
+    build_command: input.build_command,
+    build_output: input.build_output,
+    server_image: input.server_image,
+    server_command: input.server_command,
+    server_port: input.server_port,
+    server_path: input.server_path,
+    use_auth: input.use_auth,
+    color_scheme: input.color_scheme,
+    wait_for_selector: input.wait_for_selector,
+    ship_mode: input.ship_mode,
+    integration_context: normalizeIntegrationContext(input.integration_context)
+  });
+}
+
+// src/openclaw.ts
+function parseOpenClawAssertions(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return trimmed;
+  }
+}
+function openClawIntegrationContext(params) {
+  const hasDiscordContext = Boolean(params.discord_channel || params.discord_thread_id || params.discord_message_id || params.discord_source_url);
+  return normalizeIntegrationContext({
+    source: hasDiscordContext ? "discord" : "openclaw",
+    channel_id: params.discord_channel,
+    thread_id: params.discord_thread_id,
+    message_id: params.discord_message_id,
+    source_url: params.discord_source_url,
+    metadata: compactRecord({
+      wrapper: "openclaw",
+      tool: "proofed_change_run"
+    })
+  }, "openclaw");
+}
+function toRiddleProofRunParams(params) {
+  return normalizeRunParams({
+    repo: params.repo,
+    branch: params.branch,
+    change_request: params.change_request,
+    commit_message: params.commit_message,
+    prod_url: params.prod_url,
+    capture_script: params.capture_script,
+    success_criteria: params.success_criteria,
+    assertions: parseOpenClawAssertions(params.assertions_json),
+    verification_mode: params.verification_mode,
+    reference: params.reference,
+    base_branch: params.base_branch,
+    before_ref: params.before_ref,
+    allow_static_preview_fallback: params.allow_static_preview_fallback,
+    context: params.context,
+    reviewer: params.reviewer,
+    mode: params.mode,
+    build_command: params.build_command,
+    build_output: params.build_output,
+    server_image: params.server_image,
+    server_command: params.server_command,
+    server_port: params.server_port,
+    server_path: params.server_path,
+    use_auth: params.use_auth,
+    color_scheme: params.color_scheme,
+    wait_for_selector: params.wait_for_selector,
+    ship_mode: params.ship_mode || (params.ship_after_verify ? "ship" : void 0),
+    integration_context: openClawIntegrationContext(params)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openClawIntegrationContext,
+  parseOpenClawAssertions,
+  toRiddleProofRunParams
+});