@riddledc/riddle-proof 0.8.24 → 0.8.25

package/README.md

@@ -225,6 +225,23 @@ The same pack also points at the local generic core suite:
 python3 packages/riddle-proof/runtime/tests/trust_boundary_regression.py
 ```
 
+Use the pack runner to validate the local generic core first and generate the
+small serial OpenClaw handoff from the same manifest:
+
+```sh
+riddle-proof-loop regression-pack run \
+  --pack oc-flow-regression \
+  --local-core true \
+  --format markdown \
+  --output artifacts/riddle-proof/oc-flow-regression
+```
+
+The command writes `regression-pack-result.json`, `summary.md`, and
+`oc-handoff.md` when `--output` / `--output-dir` is set. The OC handoff prompt
+is generated only as wrapper/runtime validation guidance; the browser evidence,
+required cases, forbidden lifecycle markers, and version gate remain owned by
+the generic pack manifest.
+
 Before counting live wrapper runs, use the pack's runtime gate: verify
 `riddle_proof_status` reports the loaded `@riddledc/openclaw-riddle-proof` and
 `@riddledc/riddle-proof` versions. Disk package versions alone are not enough.

package/dist/advanced/index.d.cts

@@ -1,5 +1,5 @@
 export { b as runner } from '../runner-4LJ5z0D-.cjs';
 export { l as engineHarness } from '../engine-harness-LBfqbFSe.cjs';
 export { p as proofRunCore } from '../proof-run-core-C8FDUhle.cjs';
-export { p as proofRunEngine } from '../proof-run-engine-DI1qBmMf.cjs';
+export { p as proofRunEngine } from '../proof-run-engine-D80hVFMf.cjs';
 import '../types.cjs';

package/dist/advanced/index.d.ts

@@ -1,5 +1,5 @@
 export { b as runner } from '../runner-BdQpOkZD.js';
 export { l as engineHarness } from '../engine-harness-CMACHP6A.js';
 export { p as proofRunCore } from '../proof-run-core-C8FDUhle.js';
-export { p as proofRunEngine } from '../proof-run-engine-Vh9uESqh.js';
+export { p as proofRunEngine } from '../proof-run-engine-By7oLsF-.js';
 import '../types.js';

package/dist/advanced/proof-run-engine.d.cts

@@ -1,2 +1,2 @@
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-DI1qBmMf.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-D80hVFMf.cjs';
 import '../proof-run-core-C8FDUhle.cjs';

package/dist/advanced/proof-run-engine.d.ts

@@ -1,2 +1,2 @@
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-Vh9uESqh.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-By7oLsF-.js';
 import '../proof-run-core-C8FDUhle.js';

package/dist/{chunk-UTQJHWCQ.js → chunk-27AB2TEQ.js}

@@ -32,7 +32,8 @@ import {
 } from "./chunk-EEIYUZXE.js";
 
 // src/cli.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
 import path from "path";
 var RIDDLE_PROFILE_BALANCE_PREFLIGHT_MIN_SECONDS_PER_JOB = 30;
 var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
@@ -73,6 +74,7 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "intervalMs",
   "job",
   "jobId",
+  "localCore",
   "maxIterations",
   "navigationTimeout",
   "output",
@@ -82,6 +84,8 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "pollAttempts",
   "pollIntervalMs",
   "port",
+  "pack",
+  "packFile",
   "profile",
   "progressEveryMs",
   "quiet",
@@ -132,6 +136,7 @@ function usage() {
     "  riddle-proof-loop run-profile --profile <file|json|-> --url <base-url> [--base-url <base-url>] [--runner riddle] [--viewport-name <name[,name...]>] [--strict true|false; default false] [--split-viewports true|false; default false] [--balance-preflight true|false; default true] [--poll-attempts n] [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json] [--quiet]",
     "  riddle-proof-loop run-profile aggregate --profile <file|json|-> --url <base-url> [--base-url <base-url>] --input-dir <dir>|--inputs <path[,path...]> [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json]",
     "  riddle-proof-loop run-profile recover --profile <file|json|-> --url <base-url> [--base-url <base-url>] --job <job-id> [--viewport-name <name[,name...]>] [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json]",
+    "  riddle-proof-loop regression-pack run [--pack oc-flow-regression|--pack-file <file>] [--local-core true|false; default true] [--format json|markdown|compact-json; default json] [--output <dir>|--output-dir <dir>]",
     "  riddle-proof-loop profile-body-assertions --artifact <file|url|-> --candidates-json <file|json|-> [--required-json <file|json|->] [--format json|body-contains]",
     "  riddle-proof-loop profile-http-status-preflight --profile <file|json|-> --url <base-url> [--format json|summary]",
     "  riddle-proof-loop riddle-preview-deploy <build-dir> <label> [--framework spa|static]",
@@ -210,6 +215,27 @@ function runProfileViewportNamesOption(options) {
 }
 var DEFAULT_PROFILE_UNSUBMITTED_RETRY_TIMEOUT_MS = 9e4;
 var DEFAULT_PROFILE_UNSUBMITTED_RETRIES = 2;
+function cliPackageRoot() {
+  const entryPath = process.argv[1] ? (() => {
+    try {
+      return realpathSync(process.argv[1]);
+    } catch {
+      return process.argv[1];
+    }
+  })() : "";
+  const candidates = [
+    entryPath ? path.resolve(path.dirname(entryPath), "..") : "",
+    path.resolve(process.cwd(), "packages", "riddle-proof"),
+    process.cwd()
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, "runtime", "tests", "trust_boundary_regression.py")) && existsSync(path.join(candidate, "examples", "regression-packs"))) {
+      return candidate;
+    }
+  }
+  return candidates[0] || process.cwd();
+}
+var CLI_PACKAGE_ROOT = cliPackageRoot();
 function optionNumber(options, ...keys) {
   for (const key of keys) {
     const value = optionString(options, key);
@@ -290,6 +316,292 @@ function writeRunProfileResult(result, options) {
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
 }
+function regressionPackResultFormatOption(options) {
+  const format = optionString(options, "format") ?? optionString(options, "resultFormat") ?? "json";
+  if (format === "md" || format === "summary") return "markdown";
+  if (format === "json" || format === "compact-json" || format === "markdown") return format;
+  throw new Error("--format must be json, compact-json, or markdown.");
+}
+function regressionPackPathForCli(options) {
+  const packFile = optionString(options, "packFile");
+  if (packFile) return path.resolve(packFile);
+  const pack = optionString(options, "pack") || "oc-flow-regression";
+  if (existsSync(pack)) return path.resolve(pack);
+  const normalized = pack.endsWith(".json") ? pack : `${pack}.json`;
+  return path.join(CLI_PACKAGE_ROOT, "examples", "regression-packs", normalized);
+}
+function readRegressionPackForCli(options) {
+  const filePath = regressionPackPathForCli(options);
+  if (!existsSync(filePath)) throw new Error(`Regression pack not found: ${filePath}`);
+  const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+  if (parsed.version !== "riddle-proof.regression-pack.v1") {
+    throw new Error(`${filePath} is not a riddle-proof.regression-pack.v1 manifest.`);
+  }
+  return { filePath, pack: parsed };
+}
+function regressionPackStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+function regressionPackRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function regressionPackCommandForLocalCore(pack) {
+  const suite = regressionPackRecord(pack.local_core_suite);
+  return cliString(suite.command) || "python3 packages/riddle-proof/runtime/tests/trust_boundary_regression.py";
+}
+function regressionPackLocalCoreScriptPath() {
+  return path.join(CLI_PACKAGE_ROOT, "runtime", "tests", "trust_boundary_regression.py");
+}
+function tailLines(text, limit = 40) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  return lines.slice(-limit);
+}
+function parseRegressionPackLocalCoreStdout(stdout) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    const start = stdout.indexOf("{");
+    const end = stdout.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      return JSON.parse(stdout.slice(start, end + 1));
+    }
+    throw new Error("Local core suite did not emit parseable JSON.");
+  }
+}
+function regressionPackCaseNames(result) {
+  const results = Array.isArray(result.results) ? result.results : [];
+  return results.map((item) => cliString(regressionPackRecord(item).name)).filter((item) => Boolean(item));
+}
+function regressionPackFailedCaseNames(result) {
+  const failed = Array.isArray(result.failed) ? result.failed : [];
+  const namedFailed = failed.map((item) => cliString(regressionPackRecord(item).name)).filter((item) => Boolean(item));
+  if (namedFailed.length) return namedFailed;
+  const results = Array.isArray(result.results) ? result.results : [];
+  return results.map(regressionPackRecord).filter((item) => item.ok === false).map((item) => cliString(item.name)).filter((item) => Boolean(item));
+}
+function regressionPackMarkersSeen(result, markers) {
+  const encoded = JSON.stringify(result);
+  return markers.filter((marker) => encoded.includes(marker));
+}
+function runRegressionPackLocalCore(pack) {
+  const script = regressionPackLocalCoreScriptPath();
+  const suite = regressionPackRecord(pack.local_core_suite);
+  const requiredCases = regressionPackStringArray(suite.required_cases);
+  const forbiddenMarkers = regressionPackStringArray(pack.forbidden_terminal_markers);
+  const command = regressionPackCommandForLocalCore(pack);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!existsSync(script)) {
+    return {
+      requested: true,
+      ok: false,
+      command,
+      started_at: startedAt,
+      finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: `Local core suite script not found: ${script}`,
+      required_cases: requiredCases,
+      missing_required_cases: requiredCases,
+      forbidden_terminal_markers_seen: []
+    };
+  }
+  const child = spawnSync("python3", [script], {
+    cwd: CLI_PACKAGE_ROOT,
+    encoding: "utf-8",
+    timeout: 12e4
+  });
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let parsed = null;
+  let parseError;
+  try {
+    parsed = parseRegressionPackLocalCoreStdout(child.stdout || "");
+  } catch (error) {
+    parseError = error instanceof Error ? error.message : String(error);
+  }
+  const caseNames = parsed ? regressionPackCaseNames(parsed) : [];
+  const missingRequiredCases = requiredCases.filter((caseId) => !caseNames.includes(caseId));
+  const failedCases = parsed ? regressionPackFailedCaseNames(parsed) : [];
+  const markersSeen = parsed ? regressionPackMarkersSeen(parsed, forbiddenMarkers) : [];
+  const ok = child.status === 0 && parsed?.ok === true && !missingRequiredCases.length && !failedCases.length && !markersSeen.length;
+  return {
+    requested: true,
+    ok,
+    command,
+    executed: {
+      binary: "python3",
+      args: [path.relative(CLI_PACKAGE_ROOT, script)],
+      cwd: CLI_PACKAGE_ROOT
+    },
+    exit_code: child.status,
+    signal: child.signal,
+    started_at: startedAt,
+    finished_at: finishedAt,
+    suite: cliString(parsed?.suite) || null,
+    case_count: typeof parsed?.case_count === "number" ? parsed.case_count : caseNames.length,
+    passed_case_count: caseNames.length - failedCases.length,
+    required_cases: requiredCases,
+    observed_cases: caseNames,
+    missing_required_cases: missingRequiredCases,
+    failed_cases: failedCases,
+    forbidden_terminal_markers_seen: markersSeen,
+    parse_error: parseError,
+    stderr_tail: tailLines(child.stderr || ""),
+    stdout_tail: ok ? void 0 : tailLines(child.stdout || "")
+  };
+}
+function openClawHandoffPromptForRegressionPack(pack, input) {
+  const minimumVersions = regressionPackRecord(pack.minimum_versions);
+  const runtimeGate = regressionPackRecord(pack.runtime_gate);
+  const liveSuite = regressionPackRecord(pack.openclaw_live_suite);
+  const target = regressionPackRecord(liveSuite.target);
+  const cases = Array.isArray(liveSuite.cases) ? liveSuite.cases.map(regressionPackRecord) : [];
+  const fields = regressionPackStringArray(liveSuite.result_log_fields);
+  const forbiddenMarkers = regressionPackStringArray(pack.forbidden_terminal_markers);
+  const lines = [
+    "Run the Riddle Proof OC flow regression pack in small serial chunks.",
+    "",
+    `First call ${cliString(runtimeGate.tool) || "riddle_proof_status"} and count only fresh loaded-runtime runs. Required loaded versions are at least:`,
+    ...Object.entries(minimumVersions).map(([name, version]) => `- ${name}: ${version}`),
+    "",
+    "Target/default flags:",
+    ...Object.entries(target).map(([key, value]) => `- ${key}: ${JSON.stringify(value)}`),
+    "",
+    "Rules:",
+    "- Run cases serially, not as one broad parallel batch.",
+    "- If loaded metadata is stale, stop and restart/reload the gateway before counting results.",
+    "- If any generic lifecycle marker appears, report the exact marker and artifact, then stop the counted batch.",
+    `- Forbidden terminal markers: ${forbiddenMarkers.join(", ") || "none"}.`,
+    fields.length ? `- Log fields for every counted run: ${fields.join(", ")}.` : "",
+    "",
+    "Cases:",
+    ...cases.map((testCase, index) => {
+      const expect = regressionPackRecord(testCase.expect);
+      return [
+        `${index + 1}. ${cliString(testCase.id) || "unnamed-case"}: ${cliString(testCase.intent) || "no intent"}`,
+        `   Expect: ${JSON.stringify(expect)}`
+      ].join("\n");
+    }),
+    "",
+    input.localCoreOk ? "Local generic core suite is green, so OC should only be validating wrapper/runtime behavior." : "Local generic core suite is not green or was not run; do not count OC failures as wrapper-only until local core is green."
+  ].filter((line) => line !== "");
+  return lines.join("\n");
+}
+function compactRegressionPackRunResult(result) {
+  const localCore = regressionPackRecord(result.local_core);
+  const openClaw = regressionPackRecord(result.openclaw_live_suite);
+  return {
+    version: result.version,
+    pack_id: result.pack_id,
+    ok: result.ok,
+    local_core: {
+      requested: localCore.requested,
+      ok: localCore.ok,
+      command: localCore.command,
+      case_count: localCore.case_count,
+      missing_required_cases: localCore.missing_required_cases,
+      failed_cases: localCore.failed_cases,
+      forbidden_terminal_markers_seen: localCore.forbidden_terminal_markers_seen
+    },
+    openclaw_live_case_count: openClaw.case_count,
+    output_dir: result.output_dir
+  };
+}
+function regressionPackRunMarkdown(result) {
+  const localCore = regressionPackRecord(result.local_core);
+  const runtimeGate = regressionPackRecord(result.runtime_gate);
+  const minimumVersions = regressionPackRecord(result.minimum_versions);
+  const openClaw = regressionPackRecord(result.openclaw_live_suite);
+  const lines = [
+    `# ${cliString(result.public_name) || cliString(result.pack_id) || "Riddle Proof Regression Pack"}`,
+    "",
+    `Status: ${result.ok ? "passed" : "failed"}`,
+    `Pack: ${cliString(result.pack_id) || "unknown"}`,
+    "",
+    "## Local Core",
+    "",
+    `- requested: ${localCore.requested === true}`,
+    `- ok: ${localCore.ok === true}`,
+    `- command: ${cliString(localCore.command) || "n/a"}`,
+    `- cases: ${localCore.case_count ?? "n/a"}`,
+    `- missing required: ${regressionPackStringArray(localCore.missing_required_cases).join(", ") || "none"}`,
+    `- failed cases: ${regressionPackStringArray(localCore.failed_cases).join(", ") || "none"}`,
+    `- forbidden markers seen: ${regressionPackStringArray(localCore.forbidden_terminal_markers_seen).join(", ") || "none"}`,
+    "",
+    "## Runtime Gate",
+    "",
+    `- tool: ${cliString(runtimeGate.tool) || "n/a"}`,
+    ...Object.entries(minimumVersions).map(([name, version]) => `- ${name}: ${version}`),
+    "",
+    "## OpenClaw Live Suite",
+    "",
+    `- case count: ${openClaw.case_count ?? "n/a"}`,
+    `- result log fields: ${regressionPackStringArray(openClaw.result_log_fields).join(", ") || "n/a"}`,
+    "",
+    "## OC Handoff Prompt",
+    "",
+    "```text",
+    cliString(result.openclaw_handoff_prompt) || "",
+    "```",
+    ""
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function writeRegressionPackOutput(outputDir, result) {
+  if (!outputDir) return;
+  mkdirSync(outputDir, { recursive: true });
+  writeFileSync(path.join(outputDir, "regression-pack-result.json"), `${JSON.stringify(result, null, 2)}
+`);
+  writeFileSync(path.join(outputDir, "summary.md"), regressionPackRunMarkdown(result));
+  writeFileSync(path.join(outputDir, "oc-handoff.md"), `${cliString(result.openclaw_handoff_prompt) || ""}
+`);
+}
+function runRegressionPackForCli(options) {
+  const { filePath, pack } = readRegressionPackForCli(options);
+  const localCoreRequested = optionBoolean(options, "localCore") ?? true;
+  const localCore = localCoreRequested ? runRegressionPackLocalCore(pack) : { requested: false, ok: true, command: regressionPackCommandForLocalCore(pack) };
+  const liveSuite = regressionPackRecord(pack.openclaw_live_suite);
+  const liveCases = Array.isArray(liveSuite.cases) ? liveSuite.cases : [];
+  const localCoreRecord = regressionPackRecord(localCore);
+  const localCoreValidated = localCoreRecord.requested === true && localCoreRecord.ok === true;
+  const ok = localCoreRequested ? localCoreValidated : true;
+  const result = {
+    version: "riddle-proof.regression-pack-run-result.v1",
+    ok,
+    local_core_validated: localCoreValidated,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    pack_path: filePath,
+    pack_id: cliString(pack.pack_id) || null,
+    public_name: cliString(pack.public_name) || null,
+    description: cliString(pack.description) || null,
+    minimum_versions: regressionPackRecord(pack.minimum_versions),
+    runtime_gate: regressionPackRecord(pack.runtime_gate),
+    forbidden_terminal_markers: regressionPackStringArray(pack.forbidden_terminal_markers),
+    local_core: localCore,
+    openclaw_live_suite: {
+      target: regressionPackRecord(liveSuite.target),
+      result_log_fields: regressionPackStringArray(liveSuite.result_log_fields),
+      case_count: liveCases.length,
+      case_ids: liveCases.map((item) => cliString(regressionPackRecord(item).id)).filter(Boolean)
+    },
+    openclaw_handoff_prompt: openClawHandoffPromptForRegressionPack(pack, { localCoreOk: localCoreValidated }),
+    output_dir: profileOutputDirOption(options) || null
+  };
+  writeRegressionPackOutput(profileOutputDirOption(options), result);
+  return result;
+}
+function writeRegressionPackRunResult(result, options) {
+  const format = regressionPackResultFormatOption(options);
+  if (format === "markdown") {
+    process.stdout.write(regressionPackRunMarkdown(result));
+    return;
+  }
+  if (format === "compact-json") {
+    process.stdout.write(`${JSON.stringify(compactRegressionPackRunResult(result), null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+}
 function previewFrameworkOption(options) {
   const framework = optionString(options, "framework") ?? "static";
   if (framework === "spa" || framework === "static") return framework;
@@ -3954,6 +4266,14 @@ async function main() {
     process.exitCode = profileStatusExitCode(profile, result.status);
     return;
   }
+  if (command === "regression-pack") {
+    const action = positional[1] || "run";
+    if (action !== "run") throw new Error("Only `regression-pack run` is supported.");
+    const result = runRegressionPackForCli(options);
+    writeRegressionPackRunResult(result, options);
+    process.exitCode = result.ok ? 0 : 1;
+    return;
+  }
   if (command === "profile-http-status-preflight") {
     const profile = normalizeProfileForCli(options);
     const result = await preflightRiddleProofProfileHttpStatusChecks(profile);

package/dist/cli/index.js

@@ -1,4 +1,4 @@
-import "../chunk-UTQJHWCQ.js";
+import "../chunk-27AB2TEQ.js";
 import "../chunk-PEWAIEER.js";
 import "../chunk-TWTEUS7R.js";
 import "../chunk-2DW2LBUD.js";

package/dist/cli.cjs

@@ -3156,6 +3156,7 @@ var init_proof_run_engine = __esm({
 });
 
 // src/cli.ts
+var import_node_child_process5 = require("child_process");
 var import_node_fs6 = require("fs");
 var import_node_path6 = __toESM(require("path"), 1);
 
@@ -16851,6 +16852,7 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "intervalMs",
   "job",
   "jobId",
+  "localCore",
   "maxIterations",
   "navigationTimeout",
   "output",
@@ -16860,6 +16862,8 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "pollAttempts",
   "pollIntervalMs",
   "port",
+  "pack",
+  "packFile",
   "profile",
   "progressEveryMs",
   "quiet",
@@ -16910,6 +16914,7 @@ function usage() {
     "  riddle-proof-loop run-profile --profile <file|json|-> --url <base-url> [--base-url <base-url>] [--runner riddle] [--viewport-name <name[,name...]>] [--strict true|false; default false] [--split-viewports true|false; default false] [--balance-preflight true|false; default true] [--poll-attempts n] [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json] [--quiet]",
     "  riddle-proof-loop run-profile aggregate --profile <file|json|-> --url <base-url> [--base-url <base-url>] --input-dir <dir>|--inputs <path[,path...]> [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json]",
     "  riddle-proof-loop run-profile recover --profile <file|json|-> --url <base-url> [--base-url <base-url>] --job <job-id> [--viewport-name <name[,name...]>] [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json]",
+    "  riddle-proof-loop regression-pack run [--pack oc-flow-regression|--pack-file <file>] [--local-core true|false; default true] [--format json|markdown|compact-json; default json] [--output <dir>|--output-dir <dir>]",
     "  riddle-proof-loop profile-body-assertions --artifact <file|url|-> --candidates-json <file|json|-> [--required-json <file|json|->] [--format json|body-contains]",
     "  riddle-proof-loop profile-http-status-preflight --profile <file|json|-> --url <base-url> [--format json|summary]",
     "  riddle-proof-loop riddle-preview-deploy <build-dir> <label> [--framework spa|static]",
@@ -16988,6 +16993,27 @@ function runProfileViewportNamesOption(options) {
 }
 var DEFAULT_PROFILE_UNSUBMITTED_RETRY_TIMEOUT_MS = 9e4;
 var DEFAULT_PROFILE_UNSUBMITTED_RETRIES = 2;
+function cliPackageRoot() {
+  const entryPath = process.argv[1] ? (() => {
+    try {
+      return (0, import_node_fs6.realpathSync)(process.argv[1]);
+    } catch {
+      return process.argv[1];
+    }
+  })() : "";
+  const candidates = [
+    entryPath ? import_node_path6.default.resolve(import_node_path6.default.dirname(entryPath), "..") : "",
+    import_node_path6.default.resolve(process.cwd(), "packages", "riddle-proof"),
+    process.cwd()
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    if ((0, import_node_fs6.existsSync)(import_node_path6.default.join(candidate, "runtime", "tests", "trust_boundary_regression.py")) && (0, import_node_fs6.existsSync)(import_node_path6.default.join(candidate, "examples", "regression-packs"))) {
+      return candidate;
+    }
+  }
+  return candidates[0] || process.cwd();
+}
+var CLI_PACKAGE_ROOT = cliPackageRoot();
 function optionNumber(options, ...keys) {
   for (const key of keys) {
     const value = optionString(options, key);
@@ -17068,6 +17094,292 @@ function writeRunProfileResult(result, options) {
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
 }
+function regressionPackResultFormatOption(options) {
+  const format = optionString(options, "format") ?? optionString(options, "resultFormat") ?? "json";
+  if (format === "md" || format === "summary") return "markdown";
+  if (format === "json" || format === "compact-json" || format === "markdown") return format;
+  throw new Error("--format must be json, compact-json, or markdown.");
+}
+function regressionPackPathForCli(options) {
+  const packFile = optionString(options, "packFile");
+  if (packFile) return import_node_path6.default.resolve(packFile);
+  const pack = optionString(options, "pack") || "oc-flow-regression";
+  if ((0, import_node_fs6.existsSync)(pack)) return import_node_path6.default.resolve(pack);
+  const normalized = pack.endsWith(".json") ? pack : `${pack}.json`;
+  return import_node_path6.default.join(CLI_PACKAGE_ROOT, "examples", "regression-packs", normalized);
+}
+function readRegressionPackForCli(options) {
+  const filePath = regressionPackPathForCli(options);
+  if (!(0, import_node_fs6.existsSync)(filePath)) throw new Error(`Regression pack not found: ${filePath}`);
+  const parsed = JSON.parse((0, import_node_fs6.readFileSync)(filePath, "utf-8"));
+  if (parsed.version !== "riddle-proof.regression-pack.v1") {
+    throw new Error(`${filePath} is not a riddle-proof.regression-pack.v1 manifest.`);
+  }
+  return { filePath, pack: parsed };
+}
+function regressionPackStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+function regressionPackRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function regressionPackCommandForLocalCore(pack) {
+  const suite = regressionPackRecord(pack.local_core_suite);
+  return cliString(suite.command) || "python3 packages/riddle-proof/runtime/tests/trust_boundary_regression.py";
+}
+function regressionPackLocalCoreScriptPath() {
+  return import_node_path6.default.join(CLI_PACKAGE_ROOT, "runtime", "tests", "trust_boundary_regression.py");
+}
+function tailLines(text, limit = 40) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  return lines.slice(-limit);
+}
+function parseRegressionPackLocalCoreStdout(stdout) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    const start = stdout.indexOf("{");
+    const end = stdout.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      return JSON.parse(stdout.slice(start, end + 1));
+    }
+    throw new Error("Local core suite did not emit parseable JSON.");
+  }
+}
+function regressionPackCaseNames(result) {
+  const results = Array.isArray(result.results) ? result.results : [];
+  return results.map((item) => cliString(regressionPackRecord(item).name)).filter((item) => Boolean(item));
+}
+function regressionPackFailedCaseNames(result) {
+  const failed = Array.isArray(result.failed) ? result.failed : [];
+  const namedFailed = failed.map((item) => cliString(regressionPackRecord(item).name)).filter((item) => Boolean(item));
+  if (namedFailed.length) return namedFailed;
+  const results = Array.isArray(result.results) ? result.results : [];
+  return results.map(regressionPackRecord).filter((item) => item.ok === false).map((item) => cliString(item.name)).filter((item) => Boolean(item));
+}
+function regressionPackMarkersSeen(result, markers) {
+  const encoded = JSON.stringify(result);
+  return markers.filter((marker) => encoded.includes(marker));
+}
+function runRegressionPackLocalCore(pack) {
+  const script = regressionPackLocalCoreScriptPath();
+  const suite = regressionPackRecord(pack.local_core_suite);
+  const requiredCases = regressionPackStringArray(suite.required_cases);
+  const forbiddenMarkers = regressionPackStringArray(pack.forbidden_terminal_markers);
+  const command = regressionPackCommandForLocalCore(pack);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!(0, import_node_fs6.existsSync)(script)) {
+    return {
+      requested: true,
+      ok: false,
+      command,
+      started_at: startedAt,
+      finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: `Local core suite script not found: ${script}`,
+      required_cases: requiredCases,
+      missing_required_cases: requiredCases,
+      forbidden_terminal_markers_seen: []
+    };
+  }
+  const child = (0, import_node_child_process5.spawnSync)("python3", [script], {
+    cwd: CLI_PACKAGE_ROOT,
+    encoding: "utf-8",
+    timeout: 12e4
+  });
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let parsed = null;
+  let parseError;
+  try {
+    parsed = parseRegressionPackLocalCoreStdout(child.stdout || "");
+  } catch (error) {
+    parseError = error instanceof Error ? error.message : String(error);
+  }
+  const caseNames = parsed ? regressionPackCaseNames(parsed) : [];
+  const missingRequiredCases = requiredCases.filter((caseId) => !caseNames.includes(caseId));
+  const failedCases = parsed ? regressionPackFailedCaseNames(parsed) : [];
+  const markersSeen = parsed ? regressionPackMarkersSeen(parsed, forbiddenMarkers) : [];
+  const ok = child.status === 0 && parsed?.ok === true && !missingRequiredCases.length && !failedCases.length && !markersSeen.length;
+  return {
+    requested: true,
+    ok,
+    command,
+    executed: {
+      binary: "python3",
+      args: [import_node_path6.default.relative(CLI_PACKAGE_ROOT, script)],
+      cwd: CLI_PACKAGE_ROOT
+    },
+    exit_code: child.status,
+    signal: child.signal,
+    started_at: startedAt,
+    finished_at: finishedAt,
+    suite: cliString(parsed?.suite) || null,
+    case_count: typeof parsed?.case_count === "number" ? parsed.case_count : caseNames.length,
+    passed_case_count: caseNames.length - failedCases.length,
+    required_cases: requiredCases,
+    observed_cases: caseNames,
+    missing_required_cases: missingRequiredCases,
+    failed_cases: failedCases,
+    forbidden_terminal_markers_seen: markersSeen,
+    parse_error: parseError,
+    stderr_tail: tailLines(child.stderr || ""),
+    stdout_tail: ok ? void 0 : tailLines(child.stdout || "")
+  };
+}
+function openClawHandoffPromptForRegressionPack(pack, input) {
+  const minimumVersions = regressionPackRecord(pack.minimum_versions);
+  const runtimeGate = regressionPackRecord(pack.runtime_gate);
+  const liveSuite = regressionPackRecord(pack.openclaw_live_suite);
+  const target = regressionPackRecord(liveSuite.target);
+  const cases = Array.isArray(liveSuite.cases) ? liveSuite.cases.map(regressionPackRecord) : [];
+  const fields = regressionPackStringArray(liveSuite.result_log_fields);
+  const forbiddenMarkers = regressionPackStringArray(pack.forbidden_terminal_markers);
+  const lines = [
+    "Run the Riddle Proof OC flow regression pack in small serial chunks.",
+    "",
+    `First call ${cliString(runtimeGate.tool) || "riddle_proof_status"} and count only fresh loaded-runtime runs. Required loaded versions are at least:`,
+    ...Object.entries(minimumVersions).map(([name, version]) => `- ${name}: ${version}`),
+    "",
+    "Target/default flags:",
+    ...Object.entries(target).map(([key, value]) => `- ${key}: ${JSON.stringify(value)}`),
+    "",
+    "Rules:",
+    "- Run cases serially, not as one broad parallel batch.",
+    "- If loaded metadata is stale, stop and restart/reload the gateway before counting results.",
+    "- If any generic lifecycle marker appears, report the exact marker and artifact, then stop the counted batch.",
+    `- Forbidden terminal markers: ${forbiddenMarkers.join(", ") || "none"}.`,
+    fields.length ? `- Log fields for every counted run: ${fields.join(", ")}.` : "",
+    "",
+    "Cases:",
+    ...cases.map((testCase, index) => {
+      const expect = regressionPackRecord(testCase.expect);
+      return [
+        `${index + 1}. ${cliString(testCase.id) || "unnamed-case"}: ${cliString(testCase.intent) || "no intent"}`,
+        `   Expect: ${JSON.stringify(expect)}`
+      ].join("\n");
+    }),
+    "",
+    input.localCoreOk ? "Local generic core suite is green, so OC should only be validating wrapper/runtime behavior." : "Local generic core suite is not green or was not run; do not count OC failures as wrapper-only until local core is green."
+  ].filter((line) => line !== "");
+  return lines.join("\n");
+}
+function compactRegressionPackRunResult(result) {
+  const localCore = regressionPackRecord(result.local_core);
+  const openClaw = regressionPackRecord(result.openclaw_live_suite);
+  return {
+    version: result.version,
+    pack_id: result.pack_id,
+    ok: result.ok,
+    local_core: {
+      requested: localCore.requested,
+      ok: localCore.ok,
+      command: localCore.command,
+      case_count: localCore.case_count,
+      missing_required_cases: localCore.missing_required_cases,
+      failed_cases: localCore.failed_cases,
+      forbidden_terminal_markers_seen: localCore.forbidden_terminal_markers_seen
+    },
+    openclaw_live_case_count: openClaw.case_count,
+    output_dir: result.output_dir
+  };
+}
+function regressionPackRunMarkdown(result) {
+  const localCore = regressionPackRecord(result.local_core);
+  const runtimeGate = regressionPackRecord(result.runtime_gate);
+  const minimumVersions = regressionPackRecord(result.minimum_versions);
+  const openClaw = regressionPackRecord(result.openclaw_live_suite);
+  const lines = [
+    `# ${cliString(result.public_name) || cliString(result.pack_id) || "Riddle Proof Regression Pack"}`,
+    "",
+    `Status: ${result.ok ? "passed" : "failed"}`,
+    `Pack: ${cliString(result.pack_id) || "unknown"}`,
+    "",
+    "## Local Core",
+    "",
+    `- requested: ${localCore.requested === true}`,
+    `- ok: ${localCore.ok === true}`,
+    `- command: ${cliString(localCore.command) || "n/a"}`,
+    `- cases: ${localCore.case_count ?? "n/a"}`,
+    `- missing required: ${regressionPackStringArray(localCore.missing_required_cases).join(", ") || "none"}`,
+    `- failed cases: ${regressionPackStringArray(localCore.failed_cases).join(", ") || "none"}`,
+    `- forbidden markers seen: ${regressionPackStringArray(localCore.forbidden_terminal_markers_seen).join(", ") || "none"}`,
+    "",
+    "## Runtime Gate",
+    "",
+    `- tool: ${cliString(runtimeGate.tool) || "n/a"}`,
+    ...Object.entries(minimumVersions).map(([name, version]) => `- ${name}: ${version}`),
+    "",
+    "## OpenClaw Live Suite",
+    "",
+    `- case count: ${openClaw.case_count ?? "n/a"}`,
+    `- result log fields: ${regressionPackStringArray(openClaw.result_log_fields).join(", ") || "n/a"}`,
+    "",
+    "## OC Handoff Prompt",
+    "",
+    "```text",
+    cliString(result.openclaw_handoff_prompt) || "",
+    "```",
+    ""
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function writeRegressionPackOutput(outputDir, result) {
+  if (!outputDir) return;
+  (0, import_node_fs6.mkdirSync)(outputDir, { recursive: true });
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "regression-pack-result.json"), `${JSON.stringify(result, null, 2)}
+`);
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "summary.md"), regressionPackRunMarkdown(result));
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "oc-handoff.md"), `${cliString(result.openclaw_handoff_prompt) || ""}
+`);
+}
+function runRegressionPackForCli(options) {
+  const { filePath, pack } = readRegressionPackForCli(options);
+  const localCoreRequested = optionBoolean(options, "localCore") ?? true;
+  const localCore = localCoreRequested ? runRegressionPackLocalCore(pack) : { requested: false, ok: true, command: regressionPackCommandForLocalCore(pack) };
+  const liveSuite = regressionPackRecord(pack.openclaw_live_suite);
+  const liveCases = Array.isArray(liveSuite.cases) ? liveSuite.cases : [];
+  const localCoreRecord = regressionPackRecord(localCore);
+  const localCoreValidated = localCoreRecord.requested === true && localCoreRecord.ok === true;
+  const ok = localCoreRequested ? localCoreValidated : true;
+  const result = {
+    version: "riddle-proof.regression-pack-run-result.v1",
+    ok,
+    local_core_validated: localCoreValidated,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    pack_path: filePath,
+    pack_id: cliString(pack.pack_id) || null,
+    public_name: cliString(pack.public_name) || null,
+    description: cliString(pack.description) || null,
+    minimum_versions: regressionPackRecord(pack.minimum_versions),
+    runtime_gate: regressionPackRecord(pack.runtime_gate),
+    forbidden_terminal_markers: regressionPackStringArray(pack.forbidden_terminal_markers),
+    local_core: localCore,
+    openclaw_live_suite: {
+      target: regressionPackRecord(liveSuite.target),
+      result_log_fields: regressionPackStringArray(liveSuite.result_log_fields),
+      case_count: liveCases.length,
+      case_ids: liveCases.map((item) => cliString(regressionPackRecord(item).id)).filter(Boolean)
+    },
+    openclaw_handoff_prompt: openClawHandoffPromptForRegressionPack(pack, { localCoreOk: localCoreValidated }),
+    output_dir: profileOutputDirOption(options) || null
+  };
+  writeRegressionPackOutput(profileOutputDirOption(options), result);
+  return result;
+}
+function writeRegressionPackRunResult(result, options) {
+  const format = regressionPackResultFormatOption(options);
+  if (format === "markdown") {
+    process.stdout.write(regressionPackRunMarkdown(result));
+    return;
+  }
+  if (format === "compact-json") {
+    process.stdout.write(`${JSON.stringify(compactRegressionPackRunResult(result), null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+}
 function previewFrameworkOption(options) {
   const framework = optionString(options, "framework") ?? "static";
   if (framework === "spa" || framework === "static") return framework;
@@ -20732,6 +21044,14 @@ async function main() {
     process.exitCode = profileStatusExitCode(profile, result.status);
     return;
   }
+  if (command === "regression-pack") {
+    const action = positional[1] || "run";
+    if (action !== "run") throw new Error("Only `regression-pack run` is supported.");
+    const result = runRegressionPackForCli(options);
+    writeRegressionPackRunResult(result, options);
+    process.exitCode = result.ok ? 0 : 1;
+    return;
+  }
   if (command === "profile-http-status-preflight") {
     const profile = normalizeProfileForCli(options);
     const result = await preflightRiddleProofProfileHttpStatusChecks(profile);

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-UTQJHWCQ.js";
+import "./chunk-27AB2TEQ.js";
 import "./chunk-PEWAIEER.js";
 import "./chunk-TWTEUS7R.js";
 import "./chunk-2DW2LBUD.js";

package/dist/{proof-run-engine-Vh9uESqh.d.ts → proof-run-engine-By7oLsF-.d.ts}

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -382,7 +382,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -659,7 +659,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup";
     state_path: string;
     stage: any;
     summary: string;

package/dist/{proof-run-engine-DI1qBmMf.d.cts → proof-run-engine-D80hVFMf.d.cts}

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -382,7 +382,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -659,7 +659,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup";
     state_path: string;
     stage: any;
     summary: string;

package/dist/proof-run-engine.d.cts

@@ -1,2 +1,2 @@
 import './proof-run-core-C8FDUhle.cjs';
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-DI1qBmMf.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-D80hVFMf.cjs';

package/dist/proof-run-engine.d.ts

@@ -1,2 +1,2 @@
 import './proof-run-core-C8FDUhle.js';
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-Vh9uESqh.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-By7oLsF-.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.8.24",
+  "version": "0.8.25",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",