@riddledc/riddle-proof 0.8.34 → 0.8.36

package/dist/cli.cjs

@@ -9147,6 +9147,8 @@ function normalizeSetupAction(input, index) {
     expect_changed: booleanValue(valueFromOwn(input, "expect_changed", "expectChanged", "should_change", "shouldChange", "changed")),
     until_path: untilPath,
     until_expected_value: hasUntilExpectedValue ? toJsonValue(valueFromOwn(input, "until_expected_value", "untilExpectedValue", "until_expected", "untilExpected", "until_value", "untilValue", "expected_value", "expectedValue", "expected")) : void 0,
+    expected_path: stringFromOwn(input, "expected_path", "expectedPath", "expected_terminal_path", "expectedTerminalPath"),
+    expected_url: stringFromOwn(input, "expected_url", "expectedUrl", "expected_terminal_url", "expectedTerminalUrl"),
     max_calls: maxCalls,
     tap_burst_size: tapBurstSize,
     settle_ms: settleMs,
@@ -11488,6 +11490,80 @@ function routePathMatches(observed, expected, targetUrl) {
   if (normalizedObserved === normalizedExpected) return true;
   return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
 }
+function setupActionExpectedRoute(action) {
+  const expectedUrl = typeof action.expected_url === "string" && action.expected_url.trim()
+    ? action.expected_url.trim()
+    : typeof action.expectedUrl === "string" && action.expectedUrl.trim()
+      ? action.expectedUrl.trim()
+      : "";
+  const expectedPath = typeof action.expected_path === "string" && action.expected_path.trim()
+    ? action.expected_path.trim()
+    : typeof action.expectedPath === "string" && action.expectedPath.trim()
+      ? action.expectedPath.trim()
+      : "";
+  if (!expectedUrl && !expectedPath) return null;
+  return { expected_url: expectedUrl || undefined, expected_path: expectedPath || undefined };
+}
+function setupUrlMatchesExpectedRoute(href, expected) {
+  if (!expected) return true;
+  let observedUrl;
+  try {
+    observedUrl = new URL(href, targetUrl);
+  } catch {
+    return false;
+  }
+  if (expected.expected_url) {
+    let expectedUrl;
+    try {
+      expectedUrl = new URL(expected.expected_url, targetUrl);
+    } catch {
+      return false;
+    }
+    return observedUrl.href === expectedUrl.href;
+  }
+  const expectedPath = expected.expected_path || "/";
+  if (/[?#]/.test(expectedPath)) {
+    const observedRoute = observedUrl.pathname + observedUrl.search + observedUrl.hash;
+    const normalizedObservedRoute = observedRoute === "/" ? "/" : observedRoute.replace(/\/+(?=[?#]|$)/, "");
+    const normalizedExpectedRoute = expectedPath === "/" ? "/" : expectedPath.replace(/\/+(?=[?#]|$)/, "");
+    return normalizedObservedRoute === normalizedExpectedRoute;
+  }
+  return routePathMatches(observedUrl.pathname, expectedPath, targetUrl);
+}
+function setupObservedRouteEvidence(expected, waitError) {
+  let observedUrl = page.url();
+  let observedPath = "";
+  let observedRoute = "";
+  try {
+    const url = new URL(observedUrl, targetUrl);
+    observedUrl = url.href;
+    observedPath = url.pathname;
+    observedRoute = url.pathname + url.search + url.hash;
+  } catch {
+    observedPath = "";
+    observedRoute = "";
+  }
+  return {
+    expected_url: expected && expected.expected_url || undefined,
+    expected_path: expected && expected.expected_path || undefined,
+    observed_url: observedUrl,
+    observed_path: observedPath,
+    observed_route: observedRoute,
+    route_matched: setupUrlMatchesExpectedRoute(observedUrl, expected),
+    route_wait_error: waitError ? String(waitError && waitError.message ? waitError.message : waitError).slice(0, 1000) : undefined,
+  };
+}
+async function waitForSetupActionRoute(action, timeout) {
+  const expected = setupActionExpectedRoute(action);
+  if (!expected) return null;
+  let waitError;
+  try {
+    await page.waitForURL((url) => setupUrlMatchesExpectedRoute(url.href, expected), { timeout: Math.min(timeout, 20000) });
+  } catch (error) {
+    waitError = error;
+  }
+  return setupObservedRouteEvidence(expected, waitError);
+}
 function routeOk(route, targetUrl) {
   return Boolean(route && (route.matched || routePathMatches(route.observed, route.expected_path, targetUrl)) && !route.error && (route.http_status == null || route.http_status < 400));
 }
@@ -14381,11 +14457,22 @@ async function executeSetupAction(action, ordinal, viewport) {
       const prepared = await resolveSetupTapTarget(action, base, scope, timeout);
       if (prepared.result) return prepared.result;
       await dispatchSetupTapPoint(prepared.target.point, prepared.target.pointerType, prepared.target.durationMs);
+      const routeEvidence = await waitForSetupActionRoute(action, timeout);
+      if (routeEvidence && !routeEvidence.route_matched) {
+        return {
+          ...base,
+          ...setupScopeEvidence(scope),
+          ...setupTapTargetEvidence(prepared.target),
+          ...routeEvidence,
+          reason: "expected_route_not_reached",
+        };
+      }
       return {
         ...base,
         ...setupScopeEvidence(scope),
         ok: true,
         ...setupTapTargetEvidence(prepared.target),
+        ...routeEvidence,
       };
     }
     if (type === "tap_until") {
@@ -15246,6 +15333,26 @@ async function executeSetupAction(action, ordinal, viewport) {
           : { x: box.x + box.width / 2, y: box.y + box.height / 2 };
         if (clickCount > 1) await page.mouse.click(fallbackPoint.x, fallbackPoint.y, { clickCount });
         else await page.mouse.click(fallbackPoint.x, fallbackPoint.y);
+        const routeEvidence = await waitForSetupActionRoute(action, timeout);
+        if (routeEvidence && !routeEvidence.route_matched) {
+          return {
+            ...base,
+            ...setupScopeEvidence(scope),
+            count,
+            target_index: targetIndex,
+            text: matchedText,
+            force: action.force === true || undefined,
+            fallback_to_tap: true,
+            input_dispatch: "playwright_mouse",
+            click_error: String(error && error.message ? error.message : error).slice(0, 1000),
+            click_count: clickCount > 1 ? clickCount : undefined,
+            coordinate_mode: mode,
+            x: position ? fromX : undefined,
+            y: position ? fromY : undefined,
+            ...routeEvidence,
+            reason: "expected_route_not_reached",
+          };
+        }
         return {
           ...base,
           ...setupScopeEvidence(scope),
@@ -15261,6 +15368,24 @@ async function executeSetupAction(action, ordinal, viewport) {
           coordinate_mode: mode,
           x: position ? fromX : undefined,
           y: position ? fromY : undefined,
+          ...routeEvidence,
+        };
+      }
+      const routeEvidence = await waitForSetupActionRoute(action, timeout);
+      if (routeEvidence && !routeEvidence.route_matched) {
+        return {
+          ...base,
+          ...setupScopeEvidence(scope),
+          count,
+          target_index: targetIndex,
+          text: matchedText,
+          force: action.force === true || undefined,
+          click_count: clickCount > 1 ? clickCount : undefined,
+          coordinate_mode: mode,
+          x: position ? fromX : undefined,
+          y: position ? fromY : undefined,
+          ...routeEvidence,
+          reason: "expected_route_not_reached",
         };
       }
       return {
@@ -15275,6 +15400,7 @@ async function executeSetupAction(action, ordinal, viewport) {
         coordinate_mode: mode,
         x: position ? fromX : undefined,
         y: position ? fromY : undefined,
+        ...routeEvidence,
       };
     }
     if (type === "fill" || type === "set_input_value") {
@@ -17157,6 +17283,7 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "format",
   "framework",
   "help",
+  "hostedRiddle",
   "image",
   "input",
   "inputDir",
@@ -17228,7 +17355,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 regression-pack run [--pack oc-flow-regression|--pack-file <file>] [--local-core true|false; default true] [--hosted-riddle true|false; default false] [--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]",
@@ -17539,6 +17666,244 @@ function runRegressionPackLocalCore(pack) {
     stdout_tail: ok ? void 0 : tailLines(child.stdout || "")
   };
 }
+function regressionPackHostedRiddleRequested(options) {
+  return optionBoolean(options, "hostedRiddle") ?? false;
+}
+function regressionPackHostedRiddleSuite(pack) {
+  return regressionPackRecord(pack.hosted_riddle_suite);
+}
+function regressionPackHostedRiddleCases(pack) {
+  const suite = regressionPackHostedRiddleSuite(pack);
+  return Array.isArray(suite.cases) ? suite.cases.map(regressionPackRecord) : [];
+}
+function regressionPackHostedRiddleExpectedStatus(testCase) {
+  const expect = regressionPackRecord(testCase.expect);
+  return cliString(expect.profile_status) || cliString(expect.status);
+}
+function regressionPackHostedRiddleExpectedMessage(testCase) {
+  const expect = regressionPackRecord(testCase.expect);
+  return cliString(expect.message_contains);
+}
+function regressionPackHostedRiddlePlan(pack) {
+  const suite = regressionPackHostedRiddleSuite(pack);
+  const cases = regressionPackHostedRiddleCases(pack);
+  return {
+    requested: false,
+    configured: cases.length > 0,
+    ok: true,
+    runner: cliString(suite.runner) || "riddle",
+    target: regressionPackRecord(suite.target),
+    case_count: cases.length,
+    case_ids: cases.map((item) => cliString(item.id)).filter(Boolean)
+  };
+}
+function regressionPackHostedRiddleCaseOutputDir(outputDir, caseId) {
+  return outputDir ? import_node_path6.default.join(outputDir, "hosted-riddle", safeProfileOutputSegment(caseId)) : void 0;
+}
+function compactHostedRiddleCaseResult(testCase, result, ok) {
+  const expectedMessage = regressionPackHostedRiddleExpectedMessage(testCase);
+  return {
+    id: cliString(testCase.id) || result.profile_name,
+    intent: cliString(testCase.intent) || null,
+    ok,
+    expected_status: regressionPackHostedRiddleExpectedStatus(testCase) || null,
+    expected_message_contains: expectedMessage || null,
+    expected_message_found: expectedMessage ? JSON.stringify(result).includes(expectedMessage) : void 0,
+    status: result.status,
+    profile_name: result.profile_name,
+    summary: result.summary,
+    route: result.route,
+    riddle: result.riddle,
+    artifacts: result.artifacts,
+    environment_blocker: result.environment_blocker,
+    error: result.error
+  };
+}
+function hostedRiddleBlockedCaseResult(testCase, error, environmentBlocker) {
+  const rawProfile = regressionPackRecord(testCase.profile);
+  return {
+    id: cliString(testCase.id) || cliString(rawProfile.name) || "hosted-riddle-case",
+    intent: cliString(testCase.intent) || null,
+    ok: false,
+    expected_status: regressionPackHostedRiddleExpectedStatus(testCase) || null,
+    expected_message_contains: regressionPackHostedRiddleExpectedMessage(testCase) || null,
+    status: "environment_blocked",
+    profile_name: cliString(rawProfile.name) || null,
+    summary: error,
+    environment_blocker: environmentBlocker,
+    error
+  };
+}
+async function hostedRiddleSuiteEnvironmentBlocker(cases, options) {
+  if (!runProfileBalancePreflightOption(options) || !cases.length) return void 0;
+  const client = createRiddleApiClient(riddleClientConfig(options));
+  const requiredSeconds = cases.length * RIDDLE_PROFILE_BALANCE_PREFLIGHT_MIN_SECONDS_PER_JOB;
+  let balance;
+  try {
+    balance = await client.getBalance();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      error: message,
+      environment_blocker: {
+        source: "riddle_api",
+        endpoint: "/v1/balance",
+        reason: "balance_preflight_failed",
+        balance_preflight: true,
+        job_count: cases.length,
+        seconds_per_job: RIDDLE_PROFILE_BALANCE_PREFLIGHT_MIN_SECONDS_PER_JOB,
+        required_seconds: requiredSeconds,
+        ...riddleApiErrorBlockerMetadata(error),
+        ...apiKeySourceBlockerMetadata(client)
+      }
+    };
+  }
+  const availableSeconds = riddleBalanceAvailableSeconds(balance);
+  if (availableSeconds === void 0 || availableSeconds >= requiredSeconds) return void 0;
+  const reservedSeconds = cliFiniteNumber(balance.reserved_seconds);
+  const totalSeconds = cliFiniteNumber(balance.total_seconds);
+  const holdsCount = cliFiniteNumber(balance.holds_count);
+  return {
+    error: `Riddle hosted regression balance preflight failed: ${availableSeconds}s available for ${cases.length} serial hosted job(s), minimum ${requiredSeconds}s required.`,
+    environment_blocker: {
+      source: "riddle_api",
+      endpoint: "/v1/balance",
+      reason: "insufficient_balance",
+      error: "Insufficient available balance",
+      balance_preflight: true,
+      job_count: cases.length,
+      seconds_per_job: RIDDLE_PROFILE_BALANCE_PREFLIGHT_MIN_SECONDS_PER_JOB,
+      required_seconds: requiredSeconds,
+      available_seconds: availableSeconds,
+      deficit_seconds: requiredSeconds - availableSeconds,
+      ...reservedSeconds === void 0 ? {} : { reserved_seconds: reservedSeconds },
+      ...totalSeconds === void 0 ? {} : { total_seconds: totalSeconds },
+      ...holdsCount === void 0 ? {} : { holds_count: holdsCount },
+      ...apiKeySourceBlockerMetadata(client)
+    }
+  };
+}
+async function runRegressionPackHostedRiddle(pack, options) {
+  const suite = regressionPackHostedRiddleSuite(pack);
+  const cases = regressionPackHostedRiddleCases(pack);
+  const runner = cliString(suite.runner) || "riddle";
+  const target = regressionPackRecord(suite.target);
+  const baseUrl = cliString(target.url) || cliString(target.base_url) || cliString(target.baseUrl) || optionString(options, "url") || optionString(options, "baseUrl");
+  const outputDir = profileOutputDirOption(options);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const results = [];
+  const suiteBlocker = await hostedRiddleSuiteEnvironmentBlocker(cases, options);
+  if (suiteBlocker) {
+    const blockedCases = cases.map((testCase) => hostedRiddleBlockedCaseResult(testCase, suiteBlocker.error, suiteBlocker.environment_blocker));
+    return {
+      requested: true,
+      configured: cases.length > 0,
+      ok: false,
+      runner,
+      target,
+      started_at: startedAt,
+      finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+      case_count: cases.length,
+      passed_case_count: 0,
+      failed_cases: blockedCases.map((item) => cliString(item.id)).filter((item) => Boolean(item)),
+      environment_blocked_cases: blockedCases.map((item) => cliString(item.id)).filter((item) => Boolean(item)),
+      environment_blocker: suiteBlocker.environment_blocker,
+      error: suiteBlocker.error,
+      cases: blockedCases
+    };
+  }
+  for (const testCase of cases) {
+    const caseId = cliString(testCase.id) || `case-${results.length + 1}`;
+    const rawProfile = regressionPackRecord(testCase.profile);
+    if (!Object.keys(rawProfile).length) {
+      results.push({
+        id: caseId,
+        intent: cliString(testCase.intent) || null,
+        ok: false,
+        expected_status: regressionPackHostedRiddleExpectedStatus(testCase) || null,
+        status: "configuration_error",
+        error: "hosted_riddle_suite case requires profile."
+      });
+      continue;
+    }
+    let result;
+    const caseOutputDir = regressionPackHostedRiddleCaseOutputDir(outputDir, caseId);
+    const caseOptions = {
+      ...options,
+      runner,
+      ...caseOutputDir ? { output: caseOutputDir, outputDir: caseOutputDir } : {}
+    };
+    try {
+      const profile = profileWithSelectedViewportNamesForCli(
+        normalizeRiddleProofProfile(rawProfile, { url: baseUrl }),
+        options
+      );
+      result = await runProfileForCli(profile, caseOptions);
+      writeProfileOutput(caseOutputDir, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({
+        id: caseId,
+        intent: cliString(testCase.intent) || null,
+        ok: false,
+        expected_status: regressionPackHostedRiddleExpectedStatus(testCase) || null,
+        status: "configuration_error",
+        error: message,
+        output_dir: caseOutputDir || null
+      });
+      continue;
+    }
+    const expectedStatus = regressionPackHostedRiddleExpectedStatus(testCase);
+    const expectedMessage = regressionPackHostedRiddleExpectedMessage(testCase);
+    const statusOk = expectedStatus ? result.status === expectedStatus : result.status === "passed";
+    const messageOk = expectedMessage ? JSON.stringify(result).includes(expectedMessage) : true;
+    const ok = statusOk && messageOk;
+    results.push({
+      ...compactHostedRiddleCaseResult(testCase, result, ok),
+      output_dir: caseOutputDir || null
+    });
+  }
+  const failedCases = results.filter((item) => item.ok !== true).map((item) => cliString(item.id)).filter((item) => Boolean(item));
+  const environmentBlockedCases = results.filter((item) => cliString(item.status) === "environment_blocked").map((item) => cliString(item.id)).filter((item) => Boolean(item));
+  return {
+    requested: true,
+    configured: cases.length > 0,
+    ok: cases.length > 0 && !failedCases.length,
+    runner,
+    target,
+    started_at: startedAt,
+    finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+    case_count: cases.length,
+    passed_case_count: results.length - failedCases.length,
+    failed_cases: failedCases,
+    environment_blocked_cases: environmentBlockedCases,
+    cases: results
+  };
+}
+function hostedRiddleHandoffPromptForRegressionPack(pack) {
+  const cases = regressionPackHostedRiddleCases(pack);
+  const suite = regressionPackHostedRiddleSuite(pack);
+  const target = regressionPackRecord(suite.target);
+  const lines = [
+    "Run the hosted Riddle generic regression suite before involving OpenClaw.",
+    "",
+    "Command:",
+    "riddle-proof-loop regression-pack run --pack oc-flow-regression --local-core true --hosted-riddle true --format markdown --output-dir artifacts/riddle-proof/hosted-regression",
+    "",
+    "Target:",
+    ...Object.entries(target).map(([key, value]) => `- ${key}: ${JSON.stringify(value)}`),
+    "",
+    "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)}`;
+    }),
+    "",
+    "Only pass the batch to OC after local_core.ok and hosted_riddle.ok are both true."
+  ].filter((line) => line !== "");
+  return lines.join("\n");
+}
 function openClawHandoffPromptForRegressionPack(pack, input) {
   const minimumVersions = regressionPackRecord(pack.minimum_versions);
   const runtimeGate = regressionPackRecord(pack.runtime_gate);
@@ -17560,6 +17925,7 @@ function openClawHandoffPromptForRegressionPack(pack, input) {
     "- 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.",
+    input.localCoreOk ? input.hostedRiddleOk ? "- Generic local core and hosted Riddle suites are green; OC should only validate wrapper/runtime adapter behavior." : input.hostedRiddleRequested ? "- Hosted Riddle generic suite did not pass; do not treat OC failures as wrapper-only until it is green." : "- Hosted Riddle generic suite was not run in this regression-pack invocation; run it before counting OC as the late adapter gate." : "- Local generic core suite is not green or was not run; keep OC as blocked-on-generic until local core is green.",
     `- Forbidden terminal markers: ${forbiddenMarkers.join(", ") || "none"}.`,
     fields.length ? `- Log fields for every counted run: ${fields.join(", ")}.` : "",
     "",
@@ -17572,12 +17938,13 @@ function openClawHandoffPromptForRegressionPack(pack, input) {
       ].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."
+    input.localCoreOk ? "Local generic core suite is green." : "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 hostedRiddle = regressionPackRecord(result.hosted_riddle);
   const openClaw = regressionPackRecord(result.openclaw_live_suite);
   return {
     version: result.version,
@@ -17592,12 +17959,22 @@ function compactRegressionPackRunResult(result) {
       failed_cases: localCore.failed_cases,
       forbidden_terminal_markers_seen: localCore.forbidden_terminal_markers_seen
     },
+    hosted_riddle: {
+      requested: hostedRiddle.requested,
+      configured: hostedRiddle.configured,
+      ok: hostedRiddle.ok,
+      runner: hostedRiddle.runner,
+      case_count: hostedRiddle.case_count,
+      failed_cases: hostedRiddle.failed_cases,
+      environment_blocked_cases: hostedRiddle.environment_blocked_cases
+    },
     openclaw_live_case_count: openClaw.case_count,
     output_dir: result.output_dir
   };
 }
 function regressionPackRunMarkdown(result) {
   const localCore = regressionPackRecord(result.local_core);
+  const hostedRiddle = regressionPackRecord(result.hosted_riddle);
   const runtimeGate = regressionPackRecord(result.runtime_gate);
   const minimumVersions = regressionPackRecord(result.minimum_versions);
   const openClaw = regressionPackRecord(result.openclaw_live_suite);
@@ -17617,6 +17994,16 @@ function regressionPackRunMarkdown(result) {
     `- failed cases: ${regressionPackStringArray(localCore.failed_cases).join(", ") || "none"}`,
     `- forbidden markers seen: ${regressionPackStringArray(localCore.forbidden_terminal_markers_seen).join(", ") || "none"}`,
     "",
+    "## Hosted Riddle",
+    "",
+    `- requested: ${hostedRiddle.requested === true}`,
+    `- configured: ${hostedRiddle.configured === true}`,
+    `- ok: ${hostedRiddle.ok === true}`,
+    `- runner: ${cliString(hostedRiddle.runner) || "n/a"}`,
+    `- cases: ${hostedRiddle.case_count ?? "n/a"}`,
+    `- failed cases: ${regressionPackStringArray(hostedRiddle.failed_cases).join(", ") || "none"}`,
+    `- environment blocked cases: ${regressionPackStringArray(hostedRiddle.environment_blocked_cases).join(", ") || "none"}`,
+    "",
     "## Runtime Gate",
     "",
     `- tool: ${cliString(runtimeGate.tool) || "n/a"}`,
@@ -17627,6 +18014,12 @@ function regressionPackRunMarkdown(result) {
     `- case count: ${openClaw.case_count ?? "n/a"}`,
     `- result log fields: ${regressionPackStringArray(openClaw.result_log_fields).join(", ") || "n/a"}`,
     "",
+    "## Hosted Riddle Handoff",
+    "",
+    "```text",
+    cliString(result.hosted_riddle_handoff_prompt) || "",
+    "```",
+    "",
     "## OC Handoff Prompt",
     "",
     "```text",
@@ -17643,22 +18036,29 @@ function writeRegressionPackOutput(outputDir, result) {
   (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, "hosted-riddle-handoff.md"), `${cliString(result.hosted_riddle_handoff_prompt) || ""}
+`);
   (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "oc-handoff.md"), `${cliString(result.openclaw_handoff_prompt) || ""}
 `);
 }
-function runRegressionPackForCli(options) {
+async function runRegressionPackForCli(options) {
   const { filePath, pack } = readRegressionPackForCli(options);
   const localCoreRequested = optionBoolean(options, "localCore") ?? true;
+  const hostedRiddleRequested = regressionPackHostedRiddleRequested(options);
   const localCore = localCoreRequested ? runRegressionPackLocalCore(pack) : { requested: false, ok: true, command: regressionPackCommandForLocalCore(pack) };
+  const hostedRiddle = hostedRiddleRequested ? await runRegressionPackHostedRiddle(pack, options) : regressionPackHostedRiddlePlan(pack);
   const liveSuite = regressionPackRecord(pack.openclaw_live_suite);
   const liveCases = Array.isArray(liveSuite.cases) ? liveSuite.cases : [];
   const localCoreRecord = regressionPackRecord(localCore);
+  const hostedRiddleRecord = regressionPackRecord(hostedRiddle);
   const localCoreValidated = localCoreRecord.requested === true && localCoreRecord.ok === true;
-  const ok = localCoreRequested ? localCoreValidated : true;
+  const hostedRiddleValidated = hostedRiddleRecord.requested === true && hostedRiddleRecord.ok === true;
+  const ok = (localCoreRequested ? localCoreValidated : true) && (hostedRiddleRequested ? hostedRiddleValidated : true);
   const result = {
     version: "riddle-proof.regression-pack-run-result.v1",
     ok,
     local_core_validated: localCoreValidated,
+    hosted_riddle_validated: hostedRiddleValidated,
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     pack_path: filePath,
     pack_id: cliString(pack.pack_id) || null,
@@ -17668,13 +18068,19 @@ function runRegressionPackForCli(options) {
     runtime_gate: regressionPackRecord(pack.runtime_gate),
     forbidden_terminal_markers: regressionPackStringArray(pack.forbidden_terminal_markers),
     local_core: localCore,
+    hosted_riddle: hostedRiddle,
     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 }),
+    hosted_riddle_handoff_prompt: hostedRiddleHandoffPromptForRegressionPack(pack),
+    openclaw_handoff_prompt: openClawHandoffPromptForRegressionPack(pack, {
+      localCoreOk: localCoreValidated,
+      hostedRiddleOk: hostedRiddleValidated,
+      hostedRiddleRequested
+    }),
     output_dir: profileOutputDirOption(options) || null
   };
   writeRegressionPackOutput(profileOutputDirOption(options), result);
@@ -21361,7 +21767,7 @@ async function main() {
   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);
+    const result = await runRegressionPackForCli(options);
     writeRegressionPackRunResult(result, options);
     process.exitCode = result.ok ? 0 : 1;
     return;

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import "./chunk-U73JPBZW.js";
-import "./chunk-PEWAIEER.js";
+import "./chunk-E25K5PDM.js";
+import "./chunk-Z2LCVROU.js";
 import "./chunk-TWTEUS7R.js";
 import "./chunk-ZREWMTFA.js";
 import "./chunk-ZQWVXQKJ.js";