@riddledc/riddle-proof-packs 0.4.4 → 0.4.6

package/README.md

@@ -99,17 +99,28 @@ Profiles are stored under `packs/<slug>/profile.json` and mirrored into the runt
 - `neon-step-sequencer-full-mix-health-matrix`
 - `neon-step-sequencer-explore-songs-and-mixes`
 - `neon-step-sequencer-ratchet-loop-mix-level-search`
+- `neon-step-sequencer-ratchet-loop-approved-candidate`
 
 ## Audio and Neon ratchet packs
 
 The `audio-mix` directory contains reusable audio-proof authoring guidance, a profile template, a metrics schema, a ratchet method, and a human-review rubric.
 
-The `neon-step-sequencer` directory contains the first app-specific ratchet lab under the new architecture. Its profiles declare `current_target` or `interaction_snapshots` evidence-role patterns and explicitly state what they do not prove. The ratchet-loop profile now expects a compact `humanReviewPacket` for listening handoff: supported/rejected candidates, objective guardrails, state restoration, review-order ranking, and taste caveats. The case-study files record the claim, evidence, failure classification, smallest layer changed, and next sharper question for each run.
+The `neon-step-sequencer` directory contains the first app-specific ratchet lab under the new architecture. Its profiles declare `current_target` or `interaction_snapshots` evidence-role patterns and explicitly state what they do not prove. The ratchet-loop profiles now expect a compact `humanReviewPacket` for listening handoff: supported/rejected candidates, objective guardrails, state restoration, review-order ranking, taste caveats, and, when explicitly requested, an applied-candidate receipt. The case-study files record the claim, evidence, failure classification, smallest layer changed, and next sharper question for each run.
 
 ### Human-review packet handoff
 
 Human-review packets are proof artifacts for subjective follow-up. They are deliberately not taste scores. A packet should say what objective receipts passed, what was preserved, which candidate is ready for listening review, and which caveats remain.
 
+From the CLI:
+
+```sh
+riddle-proof-review-packet \
+  --proof artifacts/riddle-proof/proof.json \
+  --output artifacts/riddle-proof
+```
+
+This writes `human-review-packet.json` and `human-review-packet.md` next to the proof run. Use `--stdout` when an agent should read the Markdown handoff immediately.
+
 ```ts
 import {
   createHumanReviewPacketArtifacts,

package/bin/riddle-proof-review-packet

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const cliPath = new URL("../dist/reviewPacketCli.js", import.meta.url);
+await import(cliPath.href);

package/dist/chunk-SAE6HFAG.js

@@ -0,0 +1,139 @@
+// src/humanReviewPacket.ts
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var asRecord = (value) => isRecord(value) ? value : null;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var getPath = (value, path) => {
+  let cursor = value;
+  for (const part of path.split(".")) {
+    if (!isRecord(cursor)) return void 0;
+    cursor = cursor[part];
+  }
+  return cursor;
+};
+var formatValue = (value) => {
+  if (value === null || value === void 0 || value === "") return "not captured";
+  if (typeof value === "number") return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(4)));
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return String(value);
+};
+var formatCodeValue = (value) => `\`${formatValue(value)}\``;
+var formatAction = (action) => {
+  const record = asRecord(action);
+  if (!record) return "not captured";
+  const type = record.type ?? "set_mixer_level";
+  const track = record.track ?? "track";
+  const from = formatValue(record.from);
+  const to = formatValue(record.to);
+  const delta = record.delta === null || record.delta === void 0 ? "" : ` (${formatValue(record.delta)})`;
+  return `${type} ${track}: ${from} -> ${to}${delta}`;
+};
+var addOptionalList = (lines, heading, values) => {
+  const entries = asArray(values).filter((entry) => entry !== null && entry !== void 0 && entry !== "");
+  if (!entries.length) return;
+  lines.push("", `## ${heading}`, "");
+  for (const entry of entries) lines.push(`- ${formatValue(entry)}`);
+};
+function findHumanReviewPacket(value) {
+  if (!value || typeof value !== "object") return null;
+  if (isRecord(value) && value.kind === "human_review_packet") return value;
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const packet = findHumanReviewPacket(entry);
+      if (packet) return packet;
+    }
+    return null;
+  }
+  for (const entry of Object.values(value)) {
+    const packet = findHumanReviewPacket(entry);
+    if (packet) return packet;
+  }
+  return null;
+}
+function requireHumanReviewPacket(value) {
+  const packet = findHumanReviewPacket(value);
+  if (!packet) throw new Error("No human_review_packet found");
+  return packet;
+}
+function formatHumanReviewPacketMarkdown(packet, options = {}) {
+  if (packet.kind !== "human_review_packet") {
+    throw new Error("Expected a human_review_packet");
+  }
+  const recommendation = asRecord(packet.recommendation) ?? {};
+  const candidate = asRecord(recommendation.candidate) ?? {};
+  const guardrails = asRecord(packet.guardrails) ?? {};
+  const ranking = asRecord(packet.ranking) ?? {};
+  const request = asRecord(packet.request) ?? {};
+  const approval = asRecord(request.approval) ?? {};
+  const supportedCandidates = asArray(packet.supportedCandidates);
+  const rejectedCandidates = asArray(packet.rejectedCandidates);
+  const selectedSong = getPath(packet, "target.selectedSong.selectedSong") ?? getPath(packet, "target.routeState.selectedSong");
+  const lines = [
+    `# ${options.title ?? "Human Review Packet"}`,
+    "",
+    `- status: ${formatCodeValue(packet.status)}`,
+    `- domain: ${formatCodeValue(packet.domain)}`,
+    `- evidence_role_pattern: ${formatCodeValue(packet.evidenceRolePattern)}`,
+    `- requested_intent: ${formatValue(packet.requestedIntent)}`,
+    `- selected_song: ${formatValue(selectedSong)}`,
+    "",
+    "## Recommendation",
+    "",
+    `- action: ${formatCodeValue(recommendation.action)}`,
+    `- candidate: ${formatCodeValue(candidate.label)}`,
+    `- candidate_action: ${formatCodeValue(formatAction(candidate.action))}`,
+    `- reason: ${formatValue(recommendation.reason)}`,
+    "",
+    "## Objective Receipts",
+    "",
+    `- supported_candidates: ${formatCodeValue(guardrails.supportedClaimCandidateCount ?? supportedCandidates.length)}`,
+    `- rejected_candidates: ${formatCodeValue(guardrails.rejectedCandidateCount ?? rejectedCandidates.length)}`,
+    `- state_restored_after_loop: ${formatCodeValue(guardrails.stateRestoredAfterLoop)}`,
+    `- candidate_actions_are_transient: ${formatCodeValue(request.candidateActionsAreTransient)}`,
+    `- no_permanent_edit_unless_apply_best: ${formatCodeValue(guardrails.noPermanentEditUnlessApplyBest)}`,
+    `- approved_candidate_applied: ${formatCodeValue(guardrails.approvedCandidateApplied)}`,
+    `- approval_mode: ${formatCodeValue(approval.mode)}`,
+    `- approval_basis: ${formatValue(approval.basis)}`,
+    "",
+    "## Ranking",
+    "",
+    `- metric: ${formatCodeValue(ranking.metric)}`,
+    `- role: ${formatCodeValue(ranking.role)}`,
+    `- lower_is_better: ${formatCodeValue(ranking.lowerIsBetter)}`,
+    `- baseline: ${formatCodeValue(ranking.baselineCandidateRankingMetric)}`,
+    `- best: ${formatCodeValue(ranking.bestCandidateRankingMetric)}`,
+    `- delta: ${formatCodeValue(ranking.rankingMetricDelta)}`,
+    "",
+    "## Boundary",
+    "",
+    formatValue(packet.proofBoundary)
+  ];
+  addOptionalList(lines, "Listening Prompts", packet.listenerPrompts);
+  addOptionalList(lines, "Caveats", packet.caveats);
+  if (rejectedCandidates.length) {
+    lines.push("", "## Rejected Candidates", "");
+    for (const entry of rejectedCandidates) {
+      const rejected = asRecord(entry) ?? {};
+      const failedReceipts = asArray(rejected.failedReceipts).map(formatValue).join(", ") || "not captured";
+      lines.push(`- ${formatCodeValue(rejected.label)}: ${failedReceipts}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function createHumanReviewPacketArtifacts(proofOrPacket, options = {}) {
+  const packet = requireHumanReviewPacket(proofOrPacket);
+  const markdown = formatHumanReviewPacketMarkdown(packet, options);
+  return {
+    packet,
+    json: `${JSON.stringify(packet, null, 2)}
+`,
+    markdown
+  };
+}
+
+export {
+  findHumanReviewPacket,
+  requireHumanReviewPacket,
+  formatHumanReviewPacketMarkdown,
+  createHumanReviewPacketArtifacts
+};

package/dist/humanReviewPacket-APSxuvat.d.cts

@@ -0,0 +1,17 @@
+type HumanReviewPacket = Record<string, unknown> & {
+    kind: "human_review_packet";
+};
+interface HumanReviewPacketMarkdownOptions {
+    title?: string;
+}
+interface HumanReviewPacketArtifacts {
+    packet: HumanReviewPacket;
+    json: string;
+    markdown: string;
+}
+declare function findHumanReviewPacket(value: unknown): HumanReviewPacket | null;
+declare function requireHumanReviewPacket(value: unknown): HumanReviewPacket;
+declare function formatHumanReviewPacketMarkdown(packet: HumanReviewPacket, options?: HumanReviewPacketMarkdownOptions): string;
+declare function createHumanReviewPacketArtifacts(proofOrPacket: unknown, options?: HumanReviewPacketMarkdownOptions): HumanReviewPacketArtifacts;
+
+export { type HumanReviewPacket as H, type HumanReviewPacketArtifacts as a, type HumanReviewPacketMarkdownOptions as b, createHumanReviewPacketArtifacts as c, formatHumanReviewPacketMarkdown as d, findHumanReviewPacket as f, requireHumanReviewPacket as r };

package/dist/humanReviewPacket-APSxuvat.d.ts

@@ -0,0 +1,17 @@
+type HumanReviewPacket = Record<string, unknown> & {
+    kind: "human_review_packet";
+};
+interface HumanReviewPacketMarkdownOptions {
+    title?: string;
+}
+interface HumanReviewPacketArtifacts {
+    packet: HumanReviewPacket;
+    json: string;
+    markdown: string;
+}
+declare function findHumanReviewPacket(value: unknown): HumanReviewPacket | null;
+declare function requireHumanReviewPacket(value: unknown): HumanReviewPacket;
+declare function formatHumanReviewPacketMarkdown(packet: HumanReviewPacket, options?: HumanReviewPacketMarkdownOptions): string;
+declare function createHumanReviewPacketArtifacts(proofOrPacket: unknown, options?: HumanReviewPacketMarkdownOptions): HumanReviewPacketArtifacts;
+
+export { type HumanReviewPacket as H, type HumanReviewPacketArtifacts as a, type HumanReviewPacketMarkdownOptions as b, createHumanReviewPacketArtifacts as c, formatHumanReviewPacketMarkdown as d, findHumanReviewPacket as f, requireHumanReviewPacket as r };

package/dist/index.cjs

@@ -1656,6 +1656,185 @@ var playback_sync_default = {
   }
 };
 
+// packs/neon-step-sequencer/profiles/ratchet-loop-approved-candidate.json
+var ratchet_loop_approved_candidate_default = {
+  version: "riddle-proof.profile.v1",
+  name: "neon-step-sequencer-ratchet-loop-approved-candidate",
+  target: {
+    route: "/games/drum-sequencer?song=monkberry-moon-delight-tab&mix=profile&view=trainer&instrument=bass",
+    viewports: [
+      {
+        name: "desktop",
+        width: 1440,
+        height: 1e3
+      }
+    ],
+    timeout_sec: 360,
+    wait_for_selector: ".drum-sequencer h1",
+    setup_actions: [
+      {
+        type: "window_eval",
+        label: "capture-neon-contract",
+        timeout_ms: 1e4,
+        store_return_to: "__neonMixProof.contract",
+        script: "const contract=window.__NEON_MIX_PROOF__; const diagnostic=contract?.captureDiagnostic?.(); window.__neonMixProof={...(window.__neonMixProof||{}),contract:{available:Boolean(contract),diagnostic}}; return window.__neonMixProof.contract;",
+        return_summary_fields: [
+          {
+            path: "available"
+          },
+          {
+            path: "diagnostic.selectedSong.selectedSong"
+          }
+        ]
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.contract.available",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "window_call",
+        label: "apply-approved-claim-candidate",
+        path: "__NEON_MIX_PROOF__.runRatchetLoop",
+        args: [
+          {
+            intent: "turn the chord part down a little",
+            strategy: "mix-level-search",
+            focusTracks: [
+              "bass",
+              "chord",
+              "guitar",
+              "rhythmSynth"
+            ],
+            maxIterations: 6,
+            monitorProfile: "smallSpeaker",
+            restore: true,
+            applyBest: true,
+            approval: {
+              mode: "mixing_canon_surrogate",
+              approvedBy: "codex",
+              basis: "subtle level reduction after objective receipts pass; this keeps development moving while preserving a listening-review caveat"
+            }
+          }
+        ],
+        store_return_to: "__neonMixProof.approvedCandidateLoop",
+        capture_return: true,
+        timeout_ms: 24e4,
+        return_summary_fields: [
+          {
+            path: "ok"
+          },
+          {
+            path: "status"
+          },
+          {
+            path: "best.claimVerdict.status"
+          },
+          {
+            path: "best.claimCandidate.action.track"
+          },
+          {
+            path: "appliedCandidateReceipt.ok"
+          },
+          {
+            path: "humanReviewPacket.status"
+          },
+          {
+            path: "humanReviewPacket.request.approval.mode"
+          },
+          {
+            path: "humanReviewPacket.ranking.role"
+          }
+        ]
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.ok",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.appliedCandidateReceipt.ok",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.humanReviewPacket.status",
+        expected_value: "candidate_applied_for_listening_review",
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.humanReviewPacket.request.candidateActionsAreTransient",
+        expected_value: false,
+        timeout_ms: 1e4
+      },
+      {
+        type: "assert_window_value",
+        path: "__neonMixProof.approvedCandidateLoop.humanReviewPacket.guardrails.approvedCandidateApplied",
+        expected_value: true,
+        timeout_ms: 1e4
+      },
+      {
+        type: "screenshot",
+        label: "neon-step-sequencer-ratchet-loop-approved-candidate",
+        mode: "viewport"
+      }
+    ]
+  },
+  checks: [
+    {
+      type: "route_loaded",
+      expected_path: "/games/drum-sequencer"
+    },
+    {
+      type: "selector_visible",
+      selector: ".drum-sequencer h1"
+    },
+    {
+      type: "no_horizontal_overflow"
+    },
+    {
+      type: "no_fatal_console_errors"
+    }
+  ],
+  artifacts: [
+    "screenshot",
+    "console",
+    "dom_summary",
+    "proof_json"
+  ],
+  baseline_policy: "invariant_only",
+  failure_policy: {
+    environment_blocked: "neutral",
+    proof_insufficient: "review",
+    needs_human_review: "review",
+    product_regression: "fail"
+  },
+  metadata: {
+    pack_id: "neon_step_sequencer",
+    pack_public_name: "Neon Step Sequencer Pack",
+    evidence_role_pattern: "interaction_snapshots",
+    purpose: "Run a bounded loop, use an explicit operator-approval surrogate, apply the supported claim candidate, and preserve a listening-review packet.",
+    required_receipts: [
+      "ratchet loop returns ok",
+      "a supported claim candidate is selected",
+      "approved candidate application receipt is captured",
+      "compact human-review packet is captured",
+      "ranking remains review-order only",
+      "listening-review caveat remains explicit"
+    ],
+    does_not_prove: [
+      "subjective mix quality",
+      "that the approval surrogate is a real listener preference",
+      "all possible mix edits"
+    ]
+  }
+};
+
 // packs/neon-step-sequencer/profiles/ratchet-loop-mix-level-search.json
 var ratchet_loop_mix_level_search_default = {
   version: "riddle-proof.profile.v1",
@@ -2258,7 +2437,8 @@ var rawProfiles = {
   "neon-step-sequencer-mobile-trainer-layout": mobile_trainer_layout_default,
   "neon-step-sequencer-full-mix-health-matrix": full_mix_health_matrix_default,
   "neon-step-sequencer-explore-songs-and-mixes": explore_songs_and_mixes_default,
-  "neon-step-sequencer-ratchet-loop-mix-level-search": ratchet_loop_mix_level_search_default
+  "neon-step-sequencer-ratchet-loop-mix-level-search": ratchet_loop_mix_level_search_default,
+  "neon-step-sequencer-ratchet-loop-approved-candidate": ratchet_loop_approved_candidate_default
 };
 var sourcePathOverrides = Object.freeze({
   "neon-step-sequencer-fast-mix-health": "packs/neon-step-sequencer/profiles/fast-mix-health.json",
@@ -2268,7 +2448,8 @@ var sourcePathOverrides = Object.freeze({
   "neon-step-sequencer-mobile-trainer-layout": "packs/neon-step-sequencer/profiles/mobile-trainer-layout.json",
   "neon-step-sequencer-full-mix-health-matrix": "packs/neon-step-sequencer/profiles/full-mix-health-matrix.json",
   "neon-step-sequencer-explore-songs-and-mixes": "packs/neon-step-sequencer/profiles/explore-songs-and-mixes.json",
-  "neon-step-sequencer-ratchet-loop-mix-level-search": "packs/neon-step-sequencer/profiles/ratchet-loop-mix-level-search.json"
+  "neon-step-sequencer-ratchet-loop-mix-level-search": "packs/neon-step-sequencer/profiles/ratchet-loop-mix-level-search.json",
+  "neon-step-sequencer-ratchet-loop-approved-candidate": "packs/neon-step-sequencer/profiles/ratchet-loop-approved-candidate.json"
 });
 var RIDDLE_PROOF_PACK_PROFILES = Object.freeze(
   Object.fromEntries(
@@ -2415,6 +2596,7 @@ function formatHumanReviewPacketMarkdown(packet, options = {}) {
   const guardrails = asRecord(packet.guardrails) ?? {};
   const ranking = asRecord(packet.ranking) ?? {};
   const request = asRecord(packet.request) ?? {};
+  const approval = asRecord(request.approval) ?? {};
   const supportedCandidates = asArray(packet.supportedCandidates);
   const rejectedCandidates = asArray(packet.rejectedCandidates);
   const selectedSong = getPath(packet, "target.selectedSong.selectedSong") ?? getPath(packet, "target.routeState.selectedSong");
@@ -2441,6 +2623,9 @@ function formatHumanReviewPacketMarkdown(packet, options = {}) {
     `- state_restored_after_loop: ${formatCodeValue(guardrails.stateRestoredAfterLoop)}`,
     `- candidate_actions_are_transient: ${formatCodeValue(request.candidateActionsAreTransient)}`,
     `- no_permanent_edit_unless_apply_best: ${formatCodeValue(guardrails.noPermanentEditUnlessApplyBest)}`,
+    `- approved_candidate_applied: ${formatCodeValue(guardrails.approvedCandidateApplied)}`,
+    `- approval_mode: ${formatCodeValue(approval.mode)}`,
+    `- approval_basis: ${formatValue(approval.basis)}`,
     "",
     "## Ranking",
     "",

package/dist/index.d.cts

@@ -1,5 +1,6 @@
 import * as _riddledc_riddle_proof from '@riddledc/riddle-proof';
 import { RiddleProofProfile } from '@riddledc/riddle-proof';
+export { H as HumanReviewPacket, a as HumanReviewPacketArtifacts, b as HumanReviewPacketMarkdownOptions, c as createHumanReviewPacketArtifacts, f as findHumanReviewPacket, d as formatHumanReviewPacketMarkdown, r as requireHumanReviewPacket } from './humanReviewPacket-APSxuvat.cjs';
 
 interface RiddleProofPackProfileManifest {
     /** Profile slug and canonical manifest key. */
@@ -59,20 +60,4 @@ interface RiddleProofPackProfileOverrides {
  */
 declare function instantiateRiddleProofProfile(profileName: string, options?: RiddleProofPackProfileOverrides): RiddleProofProfile;
 
-type HumanReviewPacket = Record<string, unknown> & {
-    kind: "human_review_packet";
-};
-interface HumanReviewPacketMarkdownOptions {
-    title?: string;
-}
-interface HumanReviewPacketArtifacts {
-    packet: HumanReviewPacket;
-    json: string;
-    markdown: string;
-}
-declare function findHumanReviewPacket(value: unknown): HumanReviewPacket | null;
-declare function requireHumanReviewPacket(value: unknown): HumanReviewPacket;
-declare function formatHumanReviewPacketMarkdown(packet: HumanReviewPacket, options?: HumanReviewPacketMarkdownOptions): string;
-declare function createHumanReviewPacketArtifacts(proofOrPacket: unknown, options?: HumanReviewPacketMarkdownOptions): HumanReviewPacketArtifacts;
-
-export { type HumanReviewPacket, type HumanReviewPacketArtifacts, type HumanReviewPacketMarkdownOptions, RIDDLE_PROOF_PACK_MANIFEST, RIDDLE_PROOF_PACK_PROFILES, type RiddleProofPackProfileManifest, createHumanReviewPacketArtifacts, findHumanReviewPacket, formatHumanReviewPacketMarkdown, getPackEnabledRiddleProofPackProfiles, getRiddleProofPackProfile, getRiddleProofPackProfileByPackId, getRiddleProofPackProfileManifest, getRiddleProofProfilesByPackId, instantiateRiddleProofProfile, listRiddleProofPackProfiles, listRiddleProofPacks, requireHumanReviewPacket };
+export { RIDDLE_PROOF_PACK_MANIFEST, RIDDLE_PROOF_PACK_PROFILES, type RiddleProofPackProfileManifest, getPackEnabledRiddleProofPackProfiles, getRiddleProofPackProfile, getRiddleProofPackProfileByPackId, getRiddleProofPackProfileManifest, getRiddleProofProfilesByPackId, instantiateRiddleProofProfile, listRiddleProofPackProfiles, listRiddleProofPacks };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import * as _riddledc_riddle_proof from '@riddledc/riddle-proof';
 import { RiddleProofProfile } from '@riddledc/riddle-proof';
+export { H as HumanReviewPacket, a as HumanReviewPacketArtifacts, b as HumanReviewPacketMarkdownOptions, c as createHumanReviewPacketArtifacts, f as findHumanReviewPacket, d as formatHumanReviewPacketMarkdown, r as requireHumanReviewPacket } from './humanReviewPacket-APSxuvat.js';
 
 interface RiddleProofPackProfileManifest {
     /** Profile slug and canonical manifest key. */
@@ -59,20 +60,4 @@ interface RiddleProofPackProfileOverrides {
  */
 declare function instantiateRiddleProofProfile(profileName: string, options?: RiddleProofPackProfileOverrides): RiddleProofProfile;
 
-type HumanReviewPacket = Record<string, unknown> & {
-    kind: "human_review_packet";
-};
-interface HumanReviewPacketMarkdownOptions {
-    title?: string;
-}
-interface HumanReviewPacketArtifacts {
-    packet: HumanReviewPacket;
-    json: string;
-    markdown: string;
-}
-declare function findHumanReviewPacket(value: unknown): HumanReviewPacket | null;
-declare function requireHumanReviewPacket(value: unknown): HumanReviewPacket;
-declare function formatHumanReviewPacketMarkdown(packet: HumanReviewPacket, options?: HumanReviewPacketMarkdownOptions): string;
-declare function createHumanReviewPacketArtifacts(proofOrPacket: unknown, options?: HumanReviewPacketMarkdownOptions): HumanReviewPacketArtifacts;
-
-export { type HumanReviewPacket, type HumanReviewPacketArtifacts, type HumanReviewPacketMarkdownOptions, RIDDLE_PROOF_PACK_MANIFEST, RIDDLE_PROOF_PACK_PROFILES, type RiddleProofPackProfileManifest, createHumanReviewPacketArtifacts, findHumanReviewPacket, formatHumanReviewPacketMarkdown, getPackEnabledRiddleProofPackProfiles, getRiddleProofPackProfile, getRiddleProofPackProfileByPackId, getRiddleProofPackProfileManifest, getRiddleProofProfilesByPackId, instantiateRiddleProofProfile, listRiddleProofPackProfiles, listRiddleProofPacks, requireHumanReviewPacket };
+export { RIDDLE_PROOF_PACK_MANIFEST, RIDDLE_PROOF_PACK_PROFILES, type RiddleProofPackProfileManifest, getPackEnabledRiddleProofPackProfiles, getRiddleProofPackProfile, getRiddleProofPackProfileByPackId, getRiddleProofPackProfileManifest, getRiddleProofProfilesByPackId, instantiateRiddleProofProfile, listRiddleProofPackProfiles, listRiddleProofPacks };