@riddledc/riddle-proof 0.5.52 → 0.5.54

package/README.md

@@ -64,6 +64,7 @@ Codex/CLI-style testing:
 ```sh
 riddle-proof-loop run --request-json request.json --checkpoint-mode yield
 riddle-proof-loop checkpoint --state-path /tmp/riddle-proof-run.json
+riddle-proof-loop checkpoint --state-path /tmp/riddle-proof-run.json --format markdown
 riddle-proof-loop run --request-json request.json --agent local
 riddle-proof-loop status --state-path /tmp/riddle-proof-run.json
 riddle-proof-loop respond --state-path /tmp/riddle-proof-run.json --response-json response.json

package/dist/checkpoint.cjs

@@ -499,8 +499,8 @@ function buildProofAssessmentCheckpointPacket(input) {
   const artifactContract = recordValue(proofAssessmentRequest.artifact_contract) || recordValue(bundle?.artifact_contract);
   const requiredSignals = recordValue(recordValue(artifactContract)?.required);
   const visualDelta = visualDeltaFromState(fullState);
-  const verificationMode = nonEmptyString(input.request.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(bundle?.verification_mode) || "proof";
-  const visualDeltaRequired = requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode);
+  const verificationMode = nonEmptyString(bundle?.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(input.request.verification_mode) || "proof";
+  const visualDeltaRequired = requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
   const evidenceIssueCode = visualDeltaIssueCode(visualDelta, visualDeltaRequired);
   const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.verify_summary) || "Verify captured evidence and needs a supervising proof assessment.";
   const recoveryHint = evidenceIssueCode ? "Required visual_delta evidence is incomplete. Keep this same run in verify/evidence recovery with decision=revise_capture and continue_with_stage=verify unless the evidence proves an implementation or recon problem." : "Assess whether the current artifacts prove the requested change, then choose the next stage.";

package/dist/checkpoint.js

@@ -13,7 +13,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-T5RHGGQ2.js";
+} from "./chunk-33XO42CY.js";
 import "./chunk-DUFDZJOF.js";
 export {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,

package/dist/{chunk-T5RHGGQ2.js → chunk-33XO42CY.js}

@@ -445,8 +445,8 @@ function buildProofAssessmentCheckpointPacket(input) {
   const artifactContract = recordValue(proofAssessmentRequest.artifact_contract) || recordValue(bundle?.artifact_contract);
   const requiredSignals = recordValue(recordValue(artifactContract)?.required);
   const visualDelta = visualDeltaFromState(fullState);
-  const verificationMode = nonEmptyString(input.request.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(bundle?.verification_mode) || "proof";
-  const visualDeltaRequired = requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode);
+  const verificationMode = nonEmptyString(bundle?.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(input.request.verification_mode) || "proof";
+  const visualDeltaRequired = requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
   const evidenceIssueCode = visualDeltaIssueCode(visualDelta, visualDeltaRequired);
   const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.verify_summary) || "Verify captured evidence and needs a supervising proof assessment.";
   const recoveryHint = evidenceIssueCode ? "Required visual_delta evidence is incomplete. Keep this same run in verify/evidence recovery with decision=revise_capture and continue_with_stage=verify unless the evidence proves an implementation or recon problem." : "Assess whether the current artifacts prove the requested change, then choose the next stage.";

package/dist/{chunk-53UPEUVU.js → chunk-3UHWI3FO.js}

@@ -1,6 +1,6 @@
 import {
   statePathsForRunState
-} from "./chunk-T5RHGGQ2.js";
+} from "./chunk-33XO42CY.js";
 import {
   compactRecord,
   isTerminalStatus,

package/dist/{chunk-KYGWIA7A.js → chunk-A2AWRZ5B.js}

@@ -2,7 +2,7 @@ import {
   visualDeltaForState,
   visualDeltaRequiredForState,
   visualDeltaShipGateReason
-} from "./chunk-4ASMX4R6.js";
+} from "./chunk-RFJ5BQF6.js";
 import {
   appendRunEvent,
   appendStageHeartbeat,
@@ -10,10 +10,10 @@ import {
   createRunStatusSnapshot,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-PVUZZ2P6.js";
+} from "./chunk-MO24D3PY.js";
 import {
   createRiddleProofRunCard
-} from "./chunk-53UPEUVU.js";
+} from "./chunk-3UHWI3FO.js";
 import {
   authorPacketPayloadFromCheckpointResponse,
   buildCheckpointPacketForEngineResult,
@@ -23,7 +23,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-T5RHGGQ2.js";
+} from "./chunk-33XO42CY.js";
 import {
   applyTerminalMetadata,
   compactRecord,

package/dist/{chunk-PVUZZ2P6.js → chunk-MO24D3PY.js}

@@ -1,6 +1,6 @@
 import {
   createRiddleProofRunCard
-} from "./chunk-53UPEUVU.js";
+} from "./chunk-3UHWI3FO.js";
 import {
   compactRecord,
   isTerminalStatus,
@@ -108,6 +108,7 @@ function normalizeRunParams(input) {
     leave_draft: input.leave_draft,
     engine_state_path: input.engine_state_path,
     harness_state_path: input.harness_state_path,
+    riddle_engine_module_url: input.riddle_engine_module_url,
     max_iterations: input.max_iterations,
     auto_approve: input.auto_approve,
     dry_run: input.dry_run,

package/dist/{chunk-4ASMX4R6.js → chunk-RFJ5BQF6.js}

@@ -355,6 +355,7 @@ function visualDeltaRequiredForState(state = {}) {
   const bundle = objectValue(state?.evidence_bundle);
   const contract = objectValue(bundle.artifact_contract);
   const required = objectValue(contract.required);
+  if (required.visual_delta === false) return false;
   return required.visual_delta === true || VISUAL_FIRST_MODES.has(normalizedVerificationMode(state));
 }
 function visualDeltaForState(state = {}) {

package/dist/{chunk-QBOKV3ES.js → chunk-RXFKKYWA.js}

@@ -3,7 +3,7 @@ import {
   appendStageHeartbeat,
   createRunState,
   setRunStatus
-} from "./chunk-PVUZZ2P6.js";
+} from "./chunk-MO24D3PY.js";
 import {
   createRunResult
 } from "./chunk-DUFDZJOF.js";

package/dist/chunk-UR6ADV4Y.js

@@ -0,0 +1,163 @@
+// src/riddle-client.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import path from "path";
+var DEFAULT_RIDDLE_API_BASE_URL = "https://api.riddledc.com";
+var DEFAULT_RIDDLE_API_KEY_FILE = "/tmp/riddle-api-key";
+var RiddleApiError = class extends Error {
+  constructor(pathname, status, body) {
+    super(`Riddle API ${pathname} failed HTTP ${status}: ${body}`);
+    this.name = "RiddleApiError";
+    this.status = status;
+    this.body = body;
+    this.path = pathname;
+  }
+};
+function normalizeBaseUrl(value) {
+  return (value || DEFAULT_RIDDLE_API_BASE_URL).replace(/\/$/, "");
+}
+function fetchFor(config = {}) {
+  return config.fetchImpl || fetch;
+}
+function resolveRiddleApiKey(config = {}) {
+  if (config.apiKey?.trim()) return config.apiKey.trim();
+  if (process.env.RIDDLE_API_KEY?.trim()) return process.env.RIDDLE_API_KEY.trim();
+  const keyFile = config.apiKeyFile || process.env.RIDDLE_API_KEY_FILE || DEFAULT_RIDDLE_API_KEY_FILE;
+  if (existsSync(keyFile)) {
+    const key = readFileSync(keyFile, "utf8").trim();
+    if (key) return key;
+  }
+  throw new Error(`Riddle API key missing. Set RIDDLE_API_KEY or write ${DEFAULT_RIDDLE_API_KEY_FILE}.`);
+}
+async function riddleRequestJson(config, pathname, init = {}) {
+  const response = await fetchFor(config)(`${normalizeBaseUrl(config.apiBaseUrl)}${pathname}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${resolveRiddleApiKey(config)}`,
+      "Content-Type": "application/json",
+      ...init.headers || {}
+    }
+  });
+  const text = await response.text();
+  let json = null;
+  try {
+    json = JSON.parse(text);
+  } catch {
+  }
+  if (!response.ok) throw new RiddleApiError(pathname, response.status, text);
+  return json ?? text;
+}
+async function deployRiddleStaticPreview(config, directory, label) {
+  if (!directory?.trim()) throw new Error("directory is required");
+  if (!label?.trim()) throw new Error("label is required");
+  const created = await riddleRequestJson(config, "/v1/preview", {
+    method: "POST",
+    body: JSON.stringify({ framework: "spa", label })
+  });
+  const id = String(created.id || "");
+  const uploadUrl = String(created.upload_url || "");
+  if (!id || !uploadUrl) throw new Error("Riddle preview create response was missing id or upload_url.");
+  const scratch = mkdtempSync(path.join(tmpdir(), "riddle-preview-upload-"));
+  const tarball = path.join(scratch, `${id}.tar.gz`);
+  try {
+    execFileSync("tar", ["czf", tarball, "-C", directory, "."], { stdio: "pipe" });
+    const upload = await fetchFor(config)(uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": "application/gzip" },
+      body: readFileSync(tarball)
+    });
+    if (!upload.ok) {
+      throw new RiddleApiError(uploadUrl, upload.status, await upload.text());
+    }
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+  const published = await riddleRequestJson(config, `/v1/preview/${id}/publish`, {
+    method: "POST"
+  });
+  return {
+    ok: true,
+    id: String(published.id || id),
+    label,
+    preview_url: String(published.preview_url || ""),
+    file_count: typeof published.file_count === "number" ? published.file_count : void 0,
+    total_bytes: typeof published.total_bytes === "number" ? published.total_bytes : void 0,
+    expires_at: typeof created.expires_at === "string" ? created.expires_at : void 0,
+    raw: published
+  };
+}
+function parseRiddleViewport(value) {
+  if (!value) return void 0;
+  const match = /^(\d+)x(\d+)$/.exec(value.trim());
+  if (!match) throw new Error("viewport must look like 1280x720");
+  return { width: Number(match[1]), height: Number(match[2]) };
+}
+async function runRiddleScript(config, input) {
+  if (!input.url?.trim()) throw new Error("url is required");
+  if (!input.script?.trim()) throw new Error("script is required");
+  const payload = {
+    url: input.url,
+    script: input.script,
+    sync: input.sync ?? false,
+    timeout_sec: input.timeoutSec || 120
+  };
+  if (input.viewport) payload.viewport = input.viewport;
+  if (input.include) payload.include = input.include;
+  if (input.options) payload.options = input.options;
+  return riddleRequestJson(config, "/v1/run", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+}
+function isTerminalRiddleJobStatus(status) {
+  return ["completed", "complete", "completed_error", "completed_timeout", "failed"].includes(String(status || ""));
+}
+async function pollRiddleJob(config, jobId, options = {}) {
+  if (!jobId?.trim()) throw new Error("jobId is required");
+  const attempts = options.attempts || (options.wait ? 60 : 1);
+  const intervalMs = options.intervalMs || 2e3;
+  let job = null;
+  for (let index = 0; index < attempts; index += 1) {
+    job = await riddleRequestJson(config, `/v1/jobs/${jobId}`);
+    if (isTerminalRiddleJobStatus(job.status)) break;
+    if (index + 1 < attempts) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+  const status = job?.status ? String(job.status) : null;
+  if (!isTerminalRiddleJobStatus(status)) {
+    return { ok: true, job_id: jobId, status, terminal: false, job };
+  }
+  const artifacts = await riddleRequestJson(config, `/v1/jobs/${jobId}/artifacts`);
+  return {
+    ok: status === "completed" || status === "complete",
+    job_id: jobId,
+    status,
+    terminal: true,
+    job,
+    artifacts
+  };
+}
+function createRiddleApiClient(config = {}) {
+  return {
+    requestJson: (pathname, init) => riddleRequestJson(config, pathname, init),
+    deployStaticPreview: (directory, label) => deployRiddleStaticPreview(config, directory, label),
+    runScript: (input) => runRiddleScript(config, input),
+    pollJob: (jobId, options) => pollRiddleJob(config, jobId, options)
+  };
+}
+
+export {
+  DEFAULT_RIDDLE_API_BASE_URL,
+  DEFAULT_RIDDLE_API_KEY_FILE,
+  RiddleApiError,
+  resolveRiddleApiKey,
+  riddleRequestJson,
+  deployRiddleStaticPreview,
+  parseRiddleViewport,
+  runRiddleScript,
+  isTerminalRiddleJobStatus,
+  pollRiddleJob,
+  createRiddleApiClient
+};