@riddledc/riddle-proof 0.4.5 → 0.5.0

package/README.md

@@ -21,6 +21,7 @@ tests.
 - State/event helpers for wrappers that need a stable run envelope
 - Runner harness for preflight -> setup -> implement -> prove -> judge -> ship -> notify
 - Stage heartbeat and run status snapshot helpers
+- Capture diagnostics helpers for redacted Riddle server preview evidence
 - Worktree metadata and proof artifact role contracts
 - Terminal ship metadata normalization
 - Stable result helpers
@@ -46,6 +47,7 @@ npm install @riddledc/riddle-proof
 ```ts
 import { createRunResult, createRunState } from "@riddledc/riddle-proof";
 import { runRiddleProof } from "@riddledc/riddle-proof/runner";
+import { createCaptureDiagnostic } from "@riddledc/riddle-proof/diagnostics";
 import { toRiddleProofRunParams } from "@riddledc/riddle-proof/openclaw";
 ```
 
@@ -76,6 +78,81 @@ way to a ready PR after proof and CI; `leave_draft: true` is only an explicit
 debug or user-request escape hatch. The notification adapter is where a host
 updates Discord, OpenClaw, GitHub, or another integration.
 
+## Capture Diagnostics
+
+`@riddledc/riddle-proof/diagnostics` standardizes the evidence contract around
+Riddle-backed capture calls. It is designed for state files, PR proof comments,
+and agent handoffs where a reviewer needs to know whether proof failed because
+the route was wrong, the preview was not ready, the capture script did not save
+artifacts, or the app runtime produced weak evidence.
+
+```ts
+import {
+  appendCaptureDiagnostic,
+  createCaptureDiagnostic,
+  summarizeCaptureArtifacts,
+} from "@riddledc/riddle-proof/diagnostics";
+
+const args = {
+  server_path: "/games/drum-sequencer?song=monkberry-moon-delight-tab&mix=profile",
+  wait_for_selector: "[data-proof-ready='true']",
+  script,
+};
+
+const payload = await runRiddleServerPreview(args);
+
+const diagnostic = createCaptureDiagnostic({
+  label: "after",
+  tool: "riddle_server_preview",
+  args,
+  payload,
+  route: "/games/drum-sequencer?song=monkberry-moon-delight-tab&mix=profile",
+});
+
+appendCaptureDiagnostic(state, { label: "after", tool: "riddle_server_preview", args, payload });
+console.log(summarizeCaptureArtifacts(payload));
+```
+
+The helper redacts sensitive keys such as authorization headers, cookies,
+local storage, API keys, secrets, passwords, and tokens. It preserves route,
+selector, script shape, artifact names, URLs, result keys, console summary, and
+artifact errors. Long strings and arrays are capped so diagnostics remain safe
+to keep in a run state.
+
+### Runtime Evidence Contract
+
+For browser previews, apps can expose deterministic proof data on
+`globalThis.__riddleProofEvidence`. Capture scripts can return that object or
+write it into a JSON artifact next to screenshots. Good evidence is usually a
+mix of:
+
+- The exact route or query params a human reviewer can open
+- A readiness selector or explicit ready flag
+- Screenshots and JSON artifacts saved by the capture script
+- Runtime metrics from `globalThis.__riddleProofEvidence`
+- Assertions that explain why the evidence is sufficient
+
+Metrics are guardrails, not a replacement for taste or product judgment. For a
+musical sequencer, useful proof might include the selected song and mix, the
+transport state, current playhead time, instrument lane readiness, measured
+frame drift, console errors, and screenshots of the intended view. The reviewer
+still decides whether it sounds good.
+
+### Server Preview Usage
+
+Server preview proof is most useful when the request, capture, and PR comment
+all point at the same reproducible page. Prefer exact paths such as:
+
+```text
+/games/drum-sequencer?song=monkberry-moon-delight-tab&mix=profile
+```
+
+Use `wait_for_selector` for a stable application-ready signal instead of a fixed
+sleep. Save screenshots and structured artifacts from the same capture script
+that performs the interaction. If proof is weak, keep the diagnostics history in
+the run state so the next agent can see the last route, tool status, artifact
+shape, and errors without rerunning blind.
+
 ## OpenClaw Adapter Boundary
 
 `@riddledc/riddle-proof/openclaw` translates the current
@@ -84,6 +161,10 @@ It preserves Discord routing metadata as `integration_context` and parses
 `assertions_json` into the shared assertions field. Compatibility params such as
 `ship_after_verify` and the explicit `leave_draft` escape hatch are preserved so
 the underlying runtime can distinguish "do not merge" from "keep this draft."
+Generic authenticated proof inputs are preserved as pass-through JSON strings:
+`auth_localStorage_json`, `auth_cookies_json`, and `auth_headers_json`. Use
+those for public integrations; reserve `use_auth` for a configured, site-specific
+auth helper.
 
 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

package/dist/chunk-DWQK7J4U.js

@@ -0,0 +1,150 @@
+// src/diagnostics.ts
+var RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION = "riddle-proof.capture-diagnostic.v1";
+var DEFAULT_DIAGNOSTIC_STRING_LIMIT = 2e3;
+var DEFAULT_DIAGNOSTIC_ARRAY_LIMIT = 50;
+var DEFAULT_DIAGNOSTIC_HISTORY_LIMIT = 20;
+var DEFAULT_REDACTED_VALUE = "[redacted]";
+var DEFAULT_SENSITIVE_KEY_PATTERN = /authorization|api_?key|apikey|cookie|header|localstorage|password|secret|token/i;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeSensitiveKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/_/g, "");
+}
+function isSensitiveKey(key, pattern) {
+  pattern.lastIndex = 0;
+  const rawMatch = pattern.test(key);
+  pattern.lastIndex = 0;
+  return rawMatch || pattern.test(normalizeSensitiveKey(key));
+}
+function truncateString(value, limit) {
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit)}... [truncated]`;
+}
+function sortedKeys(value) {
+  return isRecord(value) ? Object.keys(value).sort() : [];
+}
+function stringValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function artifactItems(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isRecord);
+}
+function artifactSummary(item, source) {
+  const artifact = item;
+  const metadata = isRecord(artifact.metadata) ? artifact.metadata : void 0;
+  return {
+    name: stringValue(artifact.name) || "",
+    kind: stringValue(artifact.kind),
+    role: stringValue(artifact.role),
+    url: stringValue(artifact.url),
+    path: stringValue(artifact.path),
+    content_type: stringValue(artifact.content_type),
+    size_bytes: numberValue(artifact.size_bytes),
+    metadata_keys: metadata ? Object.keys(metadata).sort() : void 0,
+    source
+  };
+}
+function artifactErrorMap(value, redaction) {
+  if (!isRecord(value)) return {};
+  const entries = Object.entries(value).map(([key, child]) => {
+    const redacted = redactForProofDiagnostics(child, redaction);
+    return [key, typeof redacted === "string" ? redacted : JSON.stringify(redacted)];
+  }).sort(([left], [right]) => left.localeCompare(right));
+  return Object.fromEntries(entries);
+}
+function redactForProofDiagnostics(value, options = {}) {
+  const stringLimit = Math.max(1, options.string_limit ?? DEFAULT_DIAGNOSTIC_STRING_LIMIT);
+  const arrayLimit = Math.max(0, options.array_limit ?? DEFAULT_DIAGNOSTIC_ARRAY_LIMIT);
+  const redactedValue = options.redacted_value || DEFAULT_REDACTED_VALUE;
+  const sensitiveKeyPattern = options.sensitive_key_pattern || DEFAULT_SENSITIVE_KEY_PATTERN;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function redact(child) {
+    if (child === null || child === void 0) return null;
+    if (typeof child === "string") return truncateString(child, stringLimit);
+    if (typeof child === "number") return Number.isFinite(child) ? child : null;
+    if (typeof child === "boolean") return child;
+    if (typeof child === "bigint" || typeof child === "symbol" || typeof child === "function") {
+      return truncateString(String(child), stringLimit);
+    }
+    if (Array.isArray(child)) {
+      return child.slice(0, arrayLimit).map((item) => redact(item));
+    }
+    if (isRecord(child)) {
+      if (seen.has(child)) return "[circular]";
+      seen.add(child);
+      const entries = [];
+      for (const [key, nested] of Object.entries(child)) {
+        entries.push([
+          key,
+          isSensitiveKey(key, sensitiveKeyPattern) ? redactedValue : redact(nested)
+        ]);
+      }
+      return Object.fromEntries(entries);
+    }
+    return truncateString(String(child), stringLimit);
+  }
+  return redact(value);
+}
+function summarizeCaptureArtifacts(payload) {
+  const record = isRecord(payload) ? payload : {};
+  const artifactJson = isRecord(record._artifact_json) ? record._artifact_json : {};
+  const proofJson = isRecord(record._proof_json) ? record._proof_json : isRecord(artifactJson["proof.json"]) ? artifactJson["proof.json"] : {};
+  const consoleJson = isRecord(record.console) ? record.console : isRecord(artifactJson["console.json"]) ? artifactJson["console.json"] : {};
+  const result = isRecord(record.result) ? record.result : isRecord(proofJson.result) ? proofJson.result : isRecord(proofJson.script_result) ? proofJson.script_result : isRecord(proofJson.return_value) ? proofJson.return_value : isRecord(proofJson.value) ? proofJson.value : {};
+  const consoleSummary = isRecord(consoleJson.summary) ? redactForProofDiagnostics(consoleJson.summary, { string_limit: 500 }) : void 0;
+  return {
+    outputs: artifactItems(record.outputs).slice(0, 20).map((item) => artifactSummary(item, "outputs")),
+    screenshots: artifactItems(record.screenshots).slice(0, 10).map((item) => artifactSummary(item, "screenshots")),
+    artifacts: artifactItems(record.artifacts).slice(0, 20).map((item) => artifactSummary(item, "artifacts")),
+    result_keys: sortedKeys(result),
+    artifact_json: sortedKeys(artifactJson),
+    artifact_errors: artifactErrorMap(record._artifact_errors),
+    proof_script_error: Boolean(proofJson.script_error),
+    console_summary: consoleSummary
+  };
+}
+function createCaptureDiagnostic(input) {
+  const payload = isRecord(input.payload) ? input.payload : {};
+  const redaction = input.redaction;
+  const error = input.error ?? payload.error ?? payload.stderr ?? payload.message ?? "";
+  return {
+    version: RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+    label: input.label,
+    tool: input.tool,
+    captured_at: input.captured_at || (/* @__PURE__ */ new Date()).toISOString(),
+    ok: typeof input.ok === "boolean" ? input.ok : typeof payload.ok === "boolean" ? payload.ok : void 0,
+    timeout: typeof input.timeout === "boolean" ? input.timeout : Boolean(payload.timeout),
+    error: truncateString(String(error ?? ""), redaction?.string_limit ?? DEFAULT_DIAGNOSTIC_STRING_LIMIT),
+    route: input.route,
+    preview_url: input.preview_url,
+    wait_for_selector: input.wait_for_selector,
+    args: redactForProofDiagnostics(input.args === void 0 ? {} : input.args, redaction),
+    artifact_summary: summarizeCaptureArtifacts(input.payload),
+    evidence: input.evidence === void 0 ? void 0 : redactForProofDiagnostics(input.evidence, redaction),
+    notes: input.notes?.map((note) => note.trim()).filter(Boolean)
+  };
+}
+function appendCaptureDiagnostic(state, input, historyLimit = DEFAULT_DIAGNOSTIC_HISTORY_LIMIT) {
+  const diagnostic = createCaptureDiagnostic(input);
+  const existing = Array.isArray(state.capture_diagnostics) ? state.capture_diagnostics : [];
+  state.capture_diagnostics = [...existing, diagnostic].slice(-Math.max(1, historyLimit));
+  return diagnostic;
+}
+
+export {
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  redactForProofDiagnostics,
+  summarizeCaptureArtifacts,
+  createCaptureDiagnostic,
+  appendCaptureDiagnostic
+};

package/dist/{chunk-SIQG3N6F.js → chunk-GVPCSXN7.js}

@@ -90,6 +90,9 @@ function normalizeRunParams(input) {
     server_port: input.server_port,
     server_path: input.server_path,
     use_auth: input.use_auth,
+    auth_localStorage_json: input.auth_localStorage_json,
+    auth_cookies_json: input.auth_cookies_json,
+    auth_headers_json: input.auth_headers_json,
     color_scheme: input.color_scheme,
     wait_for_selector: input.wait_for_selector,
     ship_mode: input.ship_mode,

package/dist/{chunk-75XY5SVT.js → chunk-LVP22WE4.js}

@@ -5,7 +5,7 @@ import {
   createRunStatusSnapshot,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-SIQG3N6F.js";
+} from "./chunk-GVPCSXN7.js";
 import {
   applyTerminalMetadata,
   compactRecord,
@@ -175,6 +175,9 @@ function initialRunParams(request, input, state) {
     server_port: request.server_port,
     server_path: request.server_path,
     use_auth: request.use_auth,
+    auth_localStorage_json: request.auth_localStorage_json,
+    auth_cookies_json: request.auth_cookies_json,
+    auth_headers_json: request.auth_headers_json,
     color_scheme: request.color_scheme,
     wait_for_selector: request.wait_for_selector,
     leave_draft: request.leave_draft || void 0,

package/dist/{chunk-PM5Q26Q6.js → chunk-VSEKLCNU.js}

@@ -3,7 +3,7 @@ import {
   appendStageHeartbeat,
   createRunState,
   setRunStatus
-} from "./chunk-SIQG3N6F.js";
+} from "./chunk-GVPCSXN7.js";
 import {
   createRunResult
 } from "./chunk-TMMKRKY5.js";

package/dist/diagnostics.cjs

@@ -0,0 +1,181 @@
+"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/diagnostics.ts
+var diagnostics_exports = {};
+__export(diagnostics_exports, {
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT: () => DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT: () => DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT: () => DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION: () => RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+  appendCaptureDiagnostic: () => appendCaptureDiagnostic,
+  createCaptureDiagnostic: () => createCaptureDiagnostic,
+  redactForProofDiagnostics: () => redactForProofDiagnostics,
+  summarizeCaptureArtifacts: () => summarizeCaptureArtifacts
+});
+module.exports = __toCommonJS(diagnostics_exports);
+var RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION = "riddle-proof.capture-diagnostic.v1";
+var DEFAULT_DIAGNOSTIC_STRING_LIMIT = 2e3;
+var DEFAULT_DIAGNOSTIC_ARRAY_LIMIT = 50;
+var DEFAULT_DIAGNOSTIC_HISTORY_LIMIT = 20;
+var DEFAULT_REDACTED_VALUE = "[redacted]";
+var DEFAULT_SENSITIVE_KEY_PATTERN = /authorization|api_?key|apikey|cookie|header|localstorage|password|secret|token/i;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeSensitiveKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/_/g, "");
+}
+function isSensitiveKey(key, pattern) {
+  pattern.lastIndex = 0;
+  const rawMatch = pattern.test(key);
+  pattern.lastIndex = 0;
+  return rawMatch || pattern.test(normalizeSensitiveKey(key));
+}
+function truncateString(value, limit) {
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit)}... [truncated]`;
+}
+function sortedKeys(value) {
+  return isRecord(value) ? Object.keys(value).sort() : [];
+}
+function stringValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function artifactItems(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isRecord);
+}
+function artifactSummary(item, source) {
+  const artifact = item;
+  const metadata = isRecord(artifact.metadata) ? artifact.metadata : void 0;
+  return {
+    name: stringValue(artifact.name) || "",
+    kind: stringValue(artifact.kind),
+    role: stringValue(artifact.role),
+    url: stringValue(artifact.url),
+    path: stringValue(artifact.path),
+    content_type: stringValue(artifact.content_type),
+    size_bytes: numberValue(artifact.size_bytes),
+    metadata_keys: metadata ? Object.keys(metadata).sort() : void 0,
+    source
+  };
+}
+function artifactErrorMap(value, redaction) {
+  if (!isRecord(value)) return {};
+  const entries = Object.entries(value).map(([key, child]) => {
+    const redacted = redactForProofDiagnostics(child, redaction);
+    return [key, typeof redacted === "string" ? redacted : JSON.stringify(redacted)];
+  }).sort(([left], [right]) => left.localeCompare(right));
+  return Object.fromEntries(entries);
+}
+function redactForProofDiagnostics(value, options = {}) {
+  const stringLimit = Math.max(1, options.string_limit ?? DEFAULT_DIAGNOSTIC_STRING_LIMIT);
+  const arrayLimit = Math.max(0, options.array_limit ?? DEFAULT_DIAGNOSTIC_ARRAY_LIMIT);
+  const redactedValue = options.redacted_value || DEFAULT_REDACTED_VALUE;
+  const sensitiveKeyPattern = options.sensitive_key_pattern || DEFAULT_SENSITIVE_KEY_PATTERN;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function redact(child) {
+    if (child === null || child === void 0) return null;
+    if (typeof child === "string") return truncateString(child, stringLimit);
+    if (typeof child === "number") return Number.isFinite(child) ? child : null;
+    if (typeof child === "boolean") return child;
+    if (typeof child === "bigint" || typeof child === "symbol" || typeof child === "function") {
+      return truncateString(String(child), stringLimit);
+    }
+    if (Array.isArray(child)) {
+      return child.slice(0, arrayLimit).map((item) => redact(item));
+    }
+    if (isRecord(child)) {
+      if (seen.has(child)) return "[circular]";
+      seen.add(child);
+      const entries = [];
+      for (const [key, nested] of Object.entries(child)) {
+        entries.push([
+          key,
+          isSensitiveKey(key, sensitiveKeyPattern) ? redactedValue : redact(nested)
+        ]);
+      }
+      return Object.fromEntries(entries);
+    }
+    return truncateString(String(child), stringLimit);
+  }
+  return redact(value);
+}
+function summarizeCaptureArtifacts(payload) {
+  const record = isRecord(payload) ? payload : {};
+  const artifactJson = isRecord(record._artifact_json) ? record._artifact_json : {};
+  const proofJson = isRecord(record._proof_json) ? record._proof_json : isRecord(artifactJson["proof.json"]) ? artifactJson["proof.json"] : {};
+  const consoleJson = isRecord(record.console) ? record.console : isRecord(artifactJson["console.json"]) ? artifactJson["console.json"] : {};
+  const result = isRecord(record.result) ? record.result : isRecord(proofJson.result) ? proofJson.result : isRecord(proofJson.script_result) ? proofJson.script_result : isRecord(proofJson.return_value) ? proofJson.return_value : isRecord(proofJson.value) ? proofJson.value : {};
+  const consoleSummary = isRecord(consoleJson.summary) ? redactForProofDiagnostics(consoleJson.summary, { string_limit: 500 }) : void 0;
+  return {
+    outputs: artifactItems(record.outputs).slice(0, 20).map((item) => artifactSummary(item, "outputs")),
+    screenshots: artifactItems(record.screenshots).slice(0, 10).map((item) => artifactSummary(item, "screenshots")),
+    artifacts: artifactItems(record.artifacts).slice(0, 20).map((item) => artifactSummary(item, "artifacts")),
+    result_keys: sortedKeys(result),
+    artifact_json: sortedKeys(artifactJson),
+    artifact_errors: artifactErrorMap(record._artifact_errors),
+    proof_script_error: Boolean(proofJson.script_error),
+    console_summary: consoleSummary
+  };
+}
+function createCaptureDiagnostic(input) {
+  const payload = isRecord(input.payload) ? input.payload : {};
+  const redaction = input.redaction;
+  const error = input.error ?? payload.error ?? payload.stderr ?? payload.message ?? "";
+  return {
+    version: RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+    label: input.label,
+    tool: input.tool,
+    captured_at: input.captured_at || (/* @__PURE__ */ new Date()).toISOString(),
+    ok: typeof input.ok === "boolean" ? input.ok : typeof payload.ok === "boolean" ? payload.ok : void 0,
+    timeout: typeof input.timeout === "boolean" ? input.timeout : Boolean(payload.timeout),
+    error: truncateString(String(error ?? ""), redaction?.string_limit ?? DEFAULT_DIAGNOSTIC_STRING_LIMIT),
+    route: input.route,
+    preview_url: input.preview_url,
+    wait_for_selector: input.wait_for_selector,
+    args: redactForProofDiagnostics(input.args === void 0 ? {} : input.args, redaction),
+    artifact_summary: summarizeCaptureArtifacts(input.payload),
+    evidence: input.evidence === void 0 ? void 0 : redactForProofDiagnostics(input.evidence, redaction),
+    notes: input.notes?.map((note) => note.trim()).filter(Boolean)
+  };
+}
+function appendCaptureDiagnostic(state, input, historyLimit = DEFAULT_DIAGNOSTIC_HISTORY_LIMIT) {
+  const diagnostic = createCaptureDiagnostic(input);
+  const existing = Array.isArray(state.capture_diagnostics) ? state.capture_diagnostics : [];
+  state.capture_diagnostics = [...existing, diagnostic].slice(-Math.max(1, historyLimit));
+  return diagnostic;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+  appendCaptureDiagnostic,
+  createCaptureDiagnostic,
+  redactForProofDiagnostics,
+  summarizeCaptureArtifacts
+});

package/dist/diagnostics.d.cts

@@ -0,0 +1,73 @@
+import { JsonValue } from './types.cjs';
+
+declare const RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION: "riddle-proof.capture-diagnostic.v1";
+declare const DEFAULT_DIAGNOSTIC_STRING_LIMIT = 2000;
+declare const DEFAULT_DIAGNOSTIC_ARRAY_LIMIT = 50;
+declare const DEFAULT_DIAGNOSTIC_HISTORY_LIMIT = 20;
+interface RiddleProofDiagnosticRedactionOptions {
+    string_limit?: number;
+    array_limit?: number;
+    redacted_value?: string;
+    sensitive_key_pattern?: RegExp;
+}
+interface RiddleProofArtifactSummary {
+    name: string;
+    kind?: string;
+    role?: string;
+    url?: string;
+    path?: string;
+    content_type?: string;
+    size_bytes?: number;
+    metadata_keys?: string[];
+    source?: "outputs" | "screenshots" | "artifacts" | (string & {});
+}
+interface RiddleProofCaptureArtifactSummary {
+    outputs: RiddleProofArtifactSummary[];
+    screenshots: RiddleProofArtifactSummary[];
+    artifacts: RiddleProofArtifactSummary[];
+    result_keys: string[];
+    artifact_json: string[];
+    artifact_errors: Record<string, string>;
+    proof_script_error: boolean;
+    console_summary?: JsonValue;
+}
+interface RiddleProofCaptureDiagnostic {
+    version: typeof RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION;
+    label?: string;
+    tool?: string;
+    captured_at: string;
+    ok?: boolean;
+    timeout?: boolean;
+    error?: string;
+    route?: string;
+    preview_url?: string;
+    wait_for_selector?: string;
+    args?: JsonValue;
+    artifact_summary: RiddleProofCaptureArtifactSummary;
+    evidence?: JsonValue;
+    notes?: string[];
+}
+interface CreateCaptureDiagnosticInput {
+    label?: string;
+    tool?: string;
+    captured_at?: string;
+    ok?: boolean;
+    timeout?: boolean;
+    error?: unknown;
+    args?: unknown;
+    payload?: unknown;
+    evidence?: unknown;
+    route?: string;
+    preview_url?: string;
+    wait_for_selector?: string;
+    notes?: string[];
+    redaction?: RiddleProofDiagnosticRedactionOptions;
+}
+declare function redactForProofDiagnostics(value: unknown, options?: RiddleProofDiagnosticRedactionOptions): JsonValue;
+declare function summarizeCaptureArtifacts(payload: unknown): RiddleProofCaptureArtifactSummary;
+declare function createCaptureDiagnostic(input: CreateCaptureDiagnosticInput): RiddleProofCaptureDiagnostic;
+declare function appendCaptureDiagnostic<T extends {
+    capture_diagnostics?: RiddleProofCaptureDiagnostic[];
+}>(state: T, input: CreateCaptureDiagnosticInput, historyLimit?: number): RiddleProofCaptureDiagnostic;
+
+export { type CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, type RiddleProofArtifactSummary, type RiddleProofCaptureArtifactSummary, type RiddleProofCaptureDiagnostic, type RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts };

package/dist/diagnostics.d.ts

@@ -0,0 +1,73 @@
+import { JsonValue } from './types.js';
+
+declare const RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION: "riddle-proof.capture-diagnostic.v1";
+declare const DEFAULT_DIAGNOSTIC_STRING_LIMIT = 2000;
+declare const DEFAULT_DIAGNOSTIC_ARRAY_LIMIT = 50;
+declare const DEFAULT_DIAGNOSTIC_HISTORY_LIMIT = 20;
+interface RiddleProofDiagnosticRedactionOptions {
+    string_limit?: number;
+    array_limit?: number;
+    redacted_value?: string;
+    sensitive_key_pattern?: RegExp;
+}
+interface RiddleProofArtifactSummary {
+    name: string;
+    kind?: string;
+    role?: string;
+    url?: string;
+    path?: string;
+    content_type?: string;
+    size_bytes?: number;
+    metadata_keys?: string[];
+    source?: "outputs" | "screenshots" | "artifacts" | (string & {});
+}
+interface RiddleProofCaptureArtifactSummary {
+    outputs: RiddleProofArtifactSummary[];
+    screenshots: RiddleProofArtifactSummary[];
+    artifacts: RiddleProofArtifactSummary[];
+    result_keys: string[];
+    artifact_json: string[];
+    artifact_errors: Record<string, string>;
+    proof_script_error: boolean;
+    console_summary?: JsonValue;
+}
+interface RiddleProofCaptureDiagnostic {
+    version: typeof RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION;
+    label?: string;
+    tool?: string;
+    captured_at: string;
+    ok?: boolean;
+    timeout?: boolean;
+    error?: string;
+    route?: string;
+    preview_url?: string;
+    wait_for_selector?: string;
+    args?: JsonValue;
+    artifact_summary: RiddleProofCaptureArtifactSummary;
+    evidence?: JsonValue;
+    notes?: string[];
+}
+interface CreateCaptureDiagnosticInput {
+    label?: string;
+    tool?: string;
+    captured_at?: string;
+    ok?: boolean;
+    timeout?: boolean;
+    error?: unknown;
+    args?: unknown;
+    payload?: unknown;
+    evidence?: unknown;
+    route?: string;
+    preview_url?: string;
+    wait_for_selector?: string;
+    notes?: string[];
+    redaction?: RiddleProofDiagnosticRedactionOptions;
+}
+declare function redactForProofDiagnostics(value: unknown, options?: RiddleProofDiagnosticRedactionOptions): JsonValue;
+declare function summarizeCaptureArtifacts(payload: unknown): RiddleProofCaptureArtifactSummary;
+declare function createCaptureDiagnostic(input: CreateCaptureDiagnosticInput): RiddleProofCaptureDiagnostic;
+declare function appendCaptureDiagnostic<T extends {
+    capture_diagnostics?: RiddleProofCaptureDiagnostic[];
+}>(state: T, input: CreateCaptureDiagnosticInput, historyLimit?: number): RiddleProofCaptureDiagnostic;
+
+export { type CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, type RiddleProofArtifactSummary, type RiddleProofCaptureArtifactSummary, type RiddleProofCaptureDiagnostic, type RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts };

package/dist/diagnostics.js

@@ -0,0 +1,20 @@
+import {
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+  appendCaptureDiagnostic,
+  createCaptureDiagnostic,
+  redactForProofDiagnostics,
+  summarizeCaptureArtifacts
+} from "./chunk-DWQK7J4U.js";
+export {
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+  appendCaptureDiagnostic,
+  createCaptureDiagnostic,
+  redactForProofDiagnostics,
+  summarizeCaptureArtifacts
+};

package/dist/engine-harness.cjs

@@ -302,6 +302,9 @@ function normalizeRunParams(input) {
     server_port: input.server_port,
     server_path: input.server_path,
     use_auth: input.use_auth,
+    auth_localStorage_json: input.auth_localStorage_json,
+    auth_cookies_json: input.auth_cookies_json,
+    auth_headers_json: input.auth_headers_json,
     color_scheme: input.color_scheme,
     wait_for_selector: input.wait_for_selector,
     ship_mode: input.ship_mode,
@@ -560,6 +563,9 @@ function initialRunParams(request, input, state) {
     server_port: request.server_port,
     server_path: request.server_path,
     use_auth: request.use_auth,
+    auth_localStorage_json: request.auth_localStorage_json,
+    auth_cookies_json: request.auth_cookies_json,
+    auth_headers_json: request.auth_headers_json,
     color_scheme: request.color_scheme,
     wait_for_selector: request.wait_for_selector,
     leave_draft: request.leave_draft || void 0,

package/dist/engine-harness.js

@@ -2,8 +2,8 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-75XY5SVT.js";
-import "./chunk-SIQG3N6F.js";
+} from "./chunk-LVP22WE4.js";
+import "./chunk-GVPCSXN7.js";
 import "./chunk-TMMKRKY5.js";
 export {
   createDisabledRiddleProofAgentAdapter,

package/dist/index.cjs

@@ -30,12 +30,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT: () => DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT: () => DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT: () => DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION: () => RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
   RIDDLE_PROOF_RUN_STATE_VERSION: () => RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendCaptureDiagnostic: () => appendCaptureDiagnostic,
   appendRunEvent: () => appendRunEvent,
   appendStageHeartbeat: () => appendStageHeartbeat,
   applyPrLifecycleState: () => applyPrLifecycleState,
   applyTerminalMetadata: () => applyTerminalMetadata,
   compactRecord: () => compactRecord,
+  createCaptureDiagnostic: () => createCaptureDiagnostic,
   createDisabledRiddleProofAgentAdapter: () => createDisabledRiddleProofAgentAdapter,
   createRunResult: () => createRunResult,
   createRunState: () => createRunState,
@@ -49,9 +55,11 @@ __export(index_exports, {
   normalizeTerminalMetadata: () => normalizeTerminalMetadata,
   readRiddleProofRunStatus: () => readRiddleProofRunStatus,
   recordValue: () => recordValue,
+  redactForProofDiagnostics: () => redactForProofDiagnostics,
   runRiddleProof: () => runRiddleProof,
   runRiddleProofEngineHarness: () => runRiddleProofEngineHarness,
-  setRunStatus: () => setRunStatus
+  setRunStatus: () => setRunStatus,
+  summarizeCaptureArtifacts: () => summarizeCaptureArtifacts
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -350,6 +358,9 @@ function normalizeRunParams(input) {
     server_port: input.server_port,
     server_path: input.server_path,
     use_auth: input.use_auth,
+    auth_localStorage_json: input.auth_localStorage_json,
+    auth_cookies_json: input.auth_cookies_json,
+    auth_headers_json: input.auth_headers_json,
     color_scheme: input.color_scheme,
     wait_for_selector: input.wait_for_selector,
     ship_mode: input.ship_mode,
@@ -1111,6 +1122,9 @@ function initialRunParams(request, input, state) {
     server_port: request.server_port,
     server_path: request.server_path,
     use_auth: request.use_auth,
+    auth_localStorage_json: request.auth_localStorage_json,
+    auth_cookies_json: request.auth_cookies_json,
+    auth_headers_json: request.auth_headers_json,
     color_scheme: request.color_scheme,
     wait_for_selector: request.wait_for_selector,
     leave_draft: request.leave_draft || void 0,
@@ -1634,14 +1648,160 @@ async function runRiddleProofEngineHarness(input) {
     }
   });
 }
+
+// src/diagnostics.ts
+var RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION = "riddle-proof.capture-diagnostic.v1";
+var DEFAULT_DIAGNOSTIC_STRING_LIMIT = 2e3;
+var DEFAULT_DIAGNOSTIC_ARRAY_LIMIT = 50;
+var DEFAULT_DIAGNOSTIC_HISTORY_LIMIT = 20;
+var DEFAULT_REDACTED_VALUE = "[redacted]";
+var DEFAULT_SENSITIVE_KEY_PATTERN = /authorization|api_?key|apikey|cookie|header|localstorage|password|secret|token/i;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeSensitiveKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/_/g, "");
+}
+function isSensitiveKey(key, pattern) {
+  pattern.lastIndex = 0;
+  const rawMatch = pattern.test(key);
+  pattern.lastIndex = 0;
+  return rawMatch || pattern.test(normalizeSensitiveKey(key));
+}
+function truncateString(value, limit) {
+  if (value.length <= limit) return value;
+  return `${value.slice(0, limit)}... [truncated]`;
+}
+function sortedKeys(value) {
+  return isRecord(value) ? Object.keys(value).sort() : [];
+}
+function stringValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function artifactItems(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isRecord);
+}
+function artifactSummary(item, source) {
+  const artifact = item;
+  const metadata = isRecord(artifact.metadata) ? artifact.metadata : void 0;
+  return {
+    name: stringValue(artifact.name) || "",
+    kind: stringValue(artifact.kind),
+    role: stringValue(artifact.role),
+    url: stringValue(artifact.url),
+    path: stringValue(artifact.path),
+    content_type: stringValue(artifact.content_type),
+    size_bytes: numberValue(artifact.size_bytes),
+    metadata_keys: metadata ? Object.keys(metadata).sort() : void 0,
+    source
+  };
+}
+function artifactErrorMap(value, redaction) {
+  if (!isRecord(value)) return {};
+  const entries = Object.entries(value).map(([key, child]) => {
+    const redacted = redactForProofDiagnostics(child, redaction);
+    return [key, typeof redacted === "string" ? redacted : JSON.stringify(redacted)];
+  }).sort(([left], [right]) => left.localeCompare(right));
+  return Object.fromEntries(entries);
+}
+function redactForProofDiagnostics(value, options = {}) {
+  const stringLimit = Math.max(1, options.string_limit ?? DEFAULT_DIAGNOSTIC_STRING_LIMIT);
+  const arrayLimit = Math.max(0, options.array_limit ?? DEFAULT_DIAGNOSTIC_ARRAY_LIMIT);
+  const redactedValue = options.redacted_value || DEFAULT_REDACTED_VALUE;
+  const sensitiveKeyPattern = options.sensitive_key_pattern || DEFAULT_SENSITIVE_KEY_PATTERN;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function redact(child) {
+    if (child === null || child === void 0) return null;
+    if (typeof child === "string") return truncateString(child, stringLimit);
+    if (typeof child === "number") return Number.isFinite(child) ? child : null;
+    if (typeof child === "boolean") return child;
+    if (typeof child === "bigint" || typeof child === "symbol" || typeof child === "function") {
+      return truncateString(String(child), stringLimit);
+    }
+    if (Array.isArray(child)) {
+      return child.slice(0, arrayLimit).map((item) => redact(item));
+    }
+    if (isRecord(child)) {
+      if (seen.has(child)) return "[circular]";
+      seen.add(child);
+      const entries = [];
+      for (const [key, nested] of Object.entries(child)) {
+        entries.push([
+          key,
+          isSensitiveKey(key, sensitiveKeyPattern) ? redactedValue : redact(nested)
+        ]);
+      }
+      return Object.fromEntries(entries);
+    }
+    return truncateString(String(child), stringLimit);
+  }
+  return redact(value);
+}
+function summarizeCaptureArtifacts(payload) {
+  const record = isRecord(payload) ? payload : {};
+  const artifactJson = isRecord(record._artifact_json) ? record._artifact_json : {};
+  const proofJson = isRecord(record._proof_json) ? record._proof_json : isRecord(artifactJson["proof.json"]) ? artifactJson["proof.json"] : {};
+  const consoleJson = isRecord(record.console) ? record.console : isRecord(artifactJson["console.json"]) ? artifactJson["console.json"] : {};
+  const result = isRecord(record.result) ? record.result : isRecord(proofJson.result) ? proofJson.result : isRecord(proofJson.script_result) ? proofJson.script_result : isRecord(proofJson.return_value) ? proofJson.return_value : isRecord(proofJson.value) ? proofJson.value : {};
+  const consoleSummary = isRecord(consoleJson.summary) ? redactForProofDiagnostics(consoleJson.summary, { string_limit: 500 }) : void 0;
+  return {
+    outputs: artifactItems(record.outputs).slice(0, 20).map((item) => artifactSummary(item, "outputs")),
+    screenshots: artifactItems(record.screenshots).slice(0, 10).map((item) => artifactSummary(item, "screenshots")),
+    artifacts: artifactItems(record.artifacts).slice(0, 20).map((item) => artifactSummary(item, "artifacts")),
+    result_keys: sortedKeys(result),
+    artifact_json: sortedKeys(artifactJson),
+    artifact_errors: artifactErrorMap(record._artifact_errors),
+    proof_script_error: Boolean(proofJson.script_error),
+    console_summary: consoleSummary
+  };
+}
+function createCaptureDiagnostic(input) {
+  const payload = isRecord(input.payload) ? input.payload : {};
+  const redaction = input.redaction;
+  const error = input.error ?? payload.error ?? payload.stderr ?? payload.message ?? "";
+  return {
+    version: RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+    label: input.label,
+    tool: input.tool,
+    captured_at: input.captured_at || (/* @__PURE__ */ new Date()).toISOString(),
+    ok: typeof input.ok === "boolean" ? input.ok : typeof payload.ok === "boolean" ? payload.ok : void 0,
+    timeout: typeof input.timeout === "boolean" ? input.timeout : Boolean(payload.timeout),
+    error: truncateString(String(error ?? ""), redaction?.string_limit ?? DEFAULT_DIAGNOSTIC_STRING_LIMIT),
+    route: input.route,
+    preview_url: input.preview_url,
+    wait_for_selector: input.wait_for_selector,
+    args: redactForProofDiagnostics(input.args === void 0 ? {} : input.args, redaction),
+    artifact_summary: summarizeCaptureArtifacts(input.payload),
+    evidence: input.evidence === void 0 ? void 0 : redactForProofDiagnostics(input.evidence, redaction),
+    notes: input.notes?.map((note) => note.trim()).filter(Boolean)
+  };
+}
+function appendCaptureDiagnostic(state, input, historyLimit = DEFAULT_DIAGNOSTIC_HISTORY_LIMIT) {
+  const diagnostic = createCaptureDiagnostic(input);
+  const existing = Array.isArray(state.capture_diagnostics) ? state.capture_diagnostics : [];
+  state.capture_diagnostics = [...existing, diagnostic].slice(-Math.max(1, historyLimit));
+  return diagnostic;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
   RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendCaptureDiagnostic,
   appendRunEvent,
   appendStageHeartbeat,
   applyPrLifecycleState,
   applyTerminalMetadata,
   compactRecord,
+  createCaptureDiagnostic,
   createDisabledRiddleProofAgentAdapter,
   createRunResult,
   createRunState,
@@ -1655,7 +1815,9 @@ async function runRiddleProofEngineHarness(input) {
   normalizeTerminalMetadata,
   readRiddleProofRunStatus,
   recordValue,
+  redactForProofDiagnostics,
   runRiddleProof,
   runRiddleProofEngineHarness,
-  setRunStatus
+  setRunStatus,
+  summarizeCaptureArtifacts
 });

package/dist/index.d.cts

@@ -3,3 +3,4 @@ export { TerminalMetadataInput, applyTerminalMetadata, compactRecord, createRunR
 export { CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, RunEventInput, appendRunEvent, appendStageHeartbeat, applyPrLifecycleState, createRunState, createRunStatusSnapshot, normalizeIntegrationContext, normalizePrLifecycleState, normalizeRunParams, setRunStatus } from './state.cjs';
 export { RiddleProofRunnerAdapters, RunRiddleProofInput, runRiddleProof } from './runner.cjs';
 export { RiddleProofAgentAdapter, RiddleProofAgentPayload, RiddleProofEngine, RiddleProofEngineHarnessConfig, RiddleProofEngineHarnessContext, RiddleProofEngineResult, RiddleProofShipMode, RiddleProofWorkflowParams, RunRiddleProofEngineHarnessInput, createDisabledRiddleProofAgentAdapter, readRiddleProofRunStatus, runRiddleProofEngineHarness } from './engine-harness.cjs';
+export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.cjs';

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export { TerminalMetadataInput, applyTerminalMetadata, compactRecord, createRunR
 export { CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, RunEventInput, appendRunEvent, appendStageHeartbeat, applyPrLifecycleState, createRunState, createRunStatusSnapshot, normalizeIntegrationContext, normalizePrLifecycleState, normalizeRunParams, setRunStatus } from './state.js';
 export { RiddleProofRunnerAdapters, RunRiddleProofInput, runRiddleProof } from './runner.js';
 export { RiddleProofAgentAdapter, RiddleProofAgentPayload, RiddleProofEngine, RiddleProofEngineHarnessConfig, RiddleProofEngineHarnessContext, RiddleProofEngineResult, RiddleProofShipMode, RiddleProofWorkflowParams, RunRiddleProofEngineHarnessInput, createDisabledRiddleProofAgentAdapter, readRiddleProofRunStatus, runRiddleProofEngineHarness } from './engine-harness.js';
+export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.js';

package/dist/index.js

@@ -1,11 +1,21 @@
+import {
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+  appendCaptureDiagnostic,
+  createCaptureDiagnostic,
+  redactForProofDiagnostics,
+  summarizeCaptureArtifacts
+} from "./chunk-DWQK7J4U.js";
 import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-75XY5SVT.js";
+} from "./chunk-LVP22WE4.js";
 import {
   runRiddleProof
-} from "./chunk-PM5Q26Q6.js";
+} from "./chunk-VSEKLCNU.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
@@ -17,7 +27,7 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-SIQG3N6F.js";
+} from "./chunk-GVPCSXN7.js";
 import {
   applyTerminalMetadata,
   compactRecord,
@@ -30,12 +40,18 @@ import {
 } from "./chunk-TMMKRKY5.js";
 import "./chunk-6F4PWJZI.js";
 export {
+  DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
+  DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,
+  DEFAULT_DIAGNOSTIC_STRING_LIMIT,
+  RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
   RIDDLE_PROOF_RUN_STATE_VERSION,
+  appendCaptureDiagnostic,
   appendRunEvent,
   appendStageHeartbeat,
   applyPrLifecycleState,
   applyTerminalMetadata,
   compactRecord,
+  createCaptureDiagnostic,
   createDisabledRiddleProofAgentAdapter,
   createRunResult,
   createRunState,
@@ -49,7 +65,9 @@ export {
   normalizeTerminalMetadata,
   readRiddleProofRunStatus,
   recordValue,
+  redactForProofDiagnostics,
   runRiddleProof,
   runRiddleProofEngineHarness,
-  setRunStatus
+  setRunStatus,
+  summarizeCaptureArtifacts
 };

package/dist/openclaw.cjs

@@ -78,6 +78,9 @@ function normalizeRunParams(input) {
     server_port: input.server_port,
     server_path: input.server_path,
     use_auth: input.use_auth,
+    auth_localStorage_json: input.auth_localStorage_json,
+    auth_cookies_json: input.auth_cookies_json,
+    auth_headers_json: input.auth_headers_json,
     color_scheme: input.color_scheme,
     wait_for_selector: input.wait_for_selector,
     ship_mode: input.ship_mode,
@@ -142,6 +145,9 @@ function toRiddleProofRunParams(params) {
     server_port: params.server_port,
     server_path: params.server_path,
     use_auth: params.use_auth,
+    auth_localStorage_json: params.auth_localStorage_json,
+    auth_cookies_json: params.auth_cookies_json,
+    auth_headers_json: params.auth_headers_json,
     color_scheme: params.color_scheme,
     wait_for_selector: params.wait_for_selector,
     ship_mode: params.ship_mode || (params.ship_after_verify ? "ship" : void 0),

package/dist/openclaw.d.cts

@@ -24,6 +24,9 @@ interface OpenClawProofedChangeParams {
     server_port?: number;
     server_path?: string;
     use_auth?: boolean;
+    auth_localStorage_json?: string;
+    auth_cookies_json?: string;
+    auth_headers_json?: string;
     color_scheme?: "dark" | "light" | (string & {});
     wait_for_selector?: string;
     ship_after_verify?: boolean;

package/dist/openclaw.d.ts

@@ -24,6 +24,9 @@ interface OpenClawProofedChangeParams {
     server_port?: number;
     server_path?: string;
     use_auth?: boolean;
+    auth_localStorage_json?: string;
+    auth_cookies_json?: string;
+    auth_headers_json?: string;
     color_scheme?: "dark" | "light" | (string & {});
     wait_for_selector?: string;
     ship_after_verify?: boolean;

package/dist/openclaw.js

@@ -1,7 +1,7 @@
 import {
   normalizeIntegrationContext,
   normalizeRunParams
-} from "./chunk-SIQG3N6F.js";
+} from "./chunk-GVPCSXN7.js";
 import {
   compactRecord
 } from "./chunk-TMMKRKY5.js";
@@ -57,6 +57,9 @@ function toRiddleProofRunParams(params) {
     server_port: params.server_port,
     server_path: params.server_path,
     use_auth: params.use_auth,
+    auth_localStorage_json: params.auth_localStorage_json,
+    auth_cookies_json: params.auth_cookies_json,
+    auth_headers_json: params.auth_headers_json,
     color_scheme: params.color_scheme,
     wait_for_selector: params.wait_for_selector,
     ship_mode: params.ship_mode || (params.ship_after_verify ? "ship" : void 0),

package/dist/runner.cjs

@@ -184,6 +184,9 @@ function normalizeRunParams(input) {
     server_port: input.server_port,
     server_path: input.server_path,
     use_auth: input.use_auth,
+    auth_localStorage_json: input.auth_localStorage_json,
+    auth_cookies_json: input.auth_cookies_json,
+    auth_headers_json: input.auth_headers_json,
     color_scheme: input.color_scheme,
     wait_for_selector: input.wait_for_selector,
     ship_mode: input.ship_mode,

package/dist/runner.js

@@ -1,7 +1,7 @@
 import {
   runRiddleProof
-} from "./chunk-PM5Q26Q6.js";
-import "./chunk-SIQG3N6F.js";
+} from "./chunk-VSEKLCNU.js";
+import "./chunk-GVPCSXN7.js";
 import "./chunk-TMMKRKY5.js";
 export {
   runRiddleProof

package/dist/state.cjs

@@ -130,6 +130,9 @@ function normalizeRunParams(input) {
     server_port: input.server_port,
     server_path: input.server_path,
     use_auth: input.use_auth,
+    auth_localStorage_json: input.auth_localStorage_json,
+    auth_cookies_json: input.auth_cookies_json,
+    auth_headers_json: input.auth_headers_json,
     color_scheme: input.color_scheme,
     wait_for_selector: input.wait_for_selector,
     ship_mode: input.ship_mode,

package/dist/state.js

@@ -9,7 +9,7 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-SIQG3N6F.js";
+} from "./chunk-GVPCSXN7.js";
 import "./chunk-TMMKRKY5.js";
 export {
   RIDDLE_PROOF_RUN_STATE_VERSION,

package/dist/types.d.cts

@@ -33,6 +33,9 @@ interface RiddleProofRunParams {
     server_port?: number;
     server_path?: string;
     use_auth?: boolean;
+    auth_localStorage_json?: string;
+    auth_cookies_json?: string;
+    auth_headers_json?: string;
     color_scheme?: "dark" | "light" | (string & {});
     wait_for_selector?: string;
     ship_mode?: "none" | "ship";

package/dist/types.d.ts

@@ -33,6 +33,9 @@ interface RiddleProofRunParams {
     server_port?: number;
     server_path?: string;
     use_auth?: boolean;
+    auth_localStorage_json?: string;
+    auth_cookies_json?: string;
+    auth_headers_json?: string;
     color_scheme?: "dark" | "light" | (string & {});
     wait_for_selector?: string;
     ship_mode?: "none" | "ship";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",
@@ -44,6 +44,11 @@
       "import": "./dist/engine-harness.js",
       "require": "./dist/engine-harness.cjs"
     },
+    "./diagnostics": {
+      "types": "./dist/diagnostics.d.ts",
+      "import": "./dist/diagnostics.js",
+      "require": "./dist/diagnostics.cjs"
+    },
     "./openclaw": {
       "types": "./dist/openclaw.d.ts",
       "import": "./dist/openclaw.js",
@@ -65,7 +70,7 @@
     "typescript": "^5.4.5"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/types.ts src/result.ts src/state.ts src/runner.ts src/engine-harness.ts src/openclaw.ts --format cjs,esm --dts --out-dir dist --clean",
+    "build": "tsup src/index.ts src/types.ts src/result.ts src/state.ts src/runner.ts src/engine-harness.ts src/diagnostics.ts src/openclaw.ts --format cjs,esm --dts --out-dir dist --clean",
     "clean": "rm -rf dist",
     "lint": "echo 'lint: (not configured)'",
     "test": "npm run build && node test.js"