@crewhaus/grader-provability 0.0.0-stage → 0.8.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,9 @@
+CrewHaus Factory
+Copyright 2026 Max Meier
+
+This product includes software developed by Max Meier
+(operating as StudioMax — https://studiomax.io) and contributors.
+
+The CrewHaus name and logo are trademarks of Max Meier. See
+https://github.com/crewhaus/factory/blob/main/TRADEMARK.md for the
+use-of-marks policy.

package/README.md

@@ -1,3 +1,99 @@
-# Temporary Holding Version
+# @crewhaus/grader-provability
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Deterministic eval graders over the proof bundle the provability gate produced for each eval
+sample (`RunResult.artifacts.proof`, the gate's standing verdict). They make no model call and
+never re-run the verifier: the bundle is the gate's own record of the answer, so a graded sample
+and the footer the answer carried can never disagree.
+
+| Grader | Measures | Passes |
+|---|---|---|
+| `provability.claimCoverage` | claims that meet the floor ÷ claims that count (assumptions excluded) | ≥ 0.95, and every `expected_sources` origin grounds the answer |
+| `provability.rungAchieved` | the highest floor the answer passed, as rank ÷ 4 | at or above the floor |
+| `provability.citationValidity` | defined markers ÷ markers | ≥ 0.99 |
+| `provability.assumptionRate` | declared assumptions (refused ones and proof hypotheses included) ÷ claims; lower is better | ≤ 0.1 |
+| `provability.replayIntegrity` | replayed tool results that matched ÷ replayed | = 1.0 (none replayed passes) |
+| `provability.costPerProvenClaim` | gate-caused spend per met claim | reported, never gates |
+
+The floor is the sample's `metadata.provability.level` when set, else the run's (the spec's
+`provability.level`, or `crewhaus eval --provability <level>`). `crewhaus eval` runs each such
+sample's gate at its own level, so its grade is exact. A sample can also name the sources that
+must ground its answer, as URLs, `doi:` references or workspace paths:
+
+```jsonl
+{"id": "refund", "input": "What is the refund window?", "metadata": {"provability": {"level": "grounded", "expected_sources": ["https://acme.example/policy"]}}}
+```
+
+`metadata.provability: grounded` is the shorthand for `{ level: grounded }`. A malformed value
+fails the sample with a rationale naming the field, never silently grades it at the wrong bar.
+
+## Unmeasured is never a pass
+
+A run with no proof bundle fails every grader with "no proof bundle (is provability:
+declared?)", and a bundle the gate could not verify fails them with "the gate could not verify
+this answer". Proof was expected, so a missing verdict is never a pass. A bundle made below the
+sample's level cannot grade it either: rungs above a gate's floor are recorded without the checks
+only those floors run, so the floor-dependent graders fail it as unmeasured (`citationValidity`
+and `assumptionRate` do not depend on the floor and still measure). `isUnmeasured(result)` tells
+these failures apart from measured ones by their pinned prefixes (`UNMEASURED_PREFIXES`), and the
+roll-up keeps them out of a lower-is-better mean.
+
+`costPerProvenClaim` prices the gate's retries from the run's cost events, or through a
+`pricing` function when nothing metered the run, and adds the waiver judge's reported spend;
+checker time (`proof_checked` durations) is reported beside it, never added. Tokens it cannot
+price are reported as unpriced (the score is then a lower bound), never as free, and spend with
+no met claim is reported as an infinite ratio.
+
+## API
+
+```ts
+import { GraderRegistry } from "@crewhaus/grader-registry";
+import { registerProvabilityGraders, summarizeProvabilityMetrics } from "@crewhaus/grader-provability";
+
+const registry = new GraderRegistry();
+registerProvabilityGraders(registry); // the graders above, under their canonical names
+```
+
+- `registerProvabilityGraders(registry)` registers every grader, skipping a name already
+  present (a plugin registered first keeps it), and returns the canonical names.
+- `PROVABILITY_GRADERS` (name, grader pairs in table order), `PROVABILITY_GRADER_NAMES`, and
+  `createProvabilityGraders({ pricing? })`, the same set with `costPerProvenClaim` pricing
+  through `pricing`. The graders are exported one by one too (`claimCoverage`, …).
+- `provabilityGraderRole(name)`: `"requirement"` for the graders with a bar, `"report"` for
+  `costPerProvenClaim` (`PROVABILITY_REPORTED_GRADERS`), `undefined` for any other name.
+- `summarizeProvabilityMetrics(byMetric): ProvabilitySummary` folds per-sample results into the
+  roll-up (mean, pass fraction, p50/p95, breaches, unmeasured counts);
+  `renderProvabilitySummaryLines(summary)` prints it; `summarizeCostPerProvenClaim` is the cost
+  metric's own fold.
+- `PROVABILITY_METRIC_THRESHOLDS`, `PROVABILITY_METRIC_SPECS`, `sampleProvabilityOf(sample)`,
+  `expectedSourceKey(source, workspaceRoot?)`, `gateSpendOf(events, bundle?, { pricing? })`, and
+  the pinned prefixes.
+
+## How it is wired
+
+`crewhaus eval` registers the graders in its default registry, so a graders file can name them
+with `type: registry`, and `crewhaus eval --provability <level>` adds all of them to the run.
+Either way they sit beside your graders' `combine:` policy rather than inside it: a sample passes
+only when your graders pass and every provability bar holds, and the cost is reported only. A
+`weight` on one of them is not used, and under `combine: any` or `weighted` the run says so at
+start.
+
+## Limits
+
+- A bundle made outside `crewhaus eval` (a hand-wired invoker) graded at a floor below its own is
+  re-read from the rungs the gate recorded: `grounded.independent` and the guarded HEAD apply only
+  at the run's own floor, so that grade is close, not exact.
+- An `expected_sources` origin counts only when it grounded the answer in text the run did not
+  write there itself (`writtenBy`); a source the run wrote is named in the rationale instead.
+- `citationValidity` counts the markers the answer wrote: a claim read from a definition line's
+  text is skipped, since its binding is defined by construction.
+
+## Tests
+
+```sh
+bun test src
+```
+
+Fixture bundles (`src/__test__/fixtures.ts`) pin each grader's score and rationale, the
+unmeasured cases, the spend windows and pricing, the sample metadata reader and the roll-up.
+
+Design: [design/0.8.0-provability-release.md](../../design/0.8.0-provability-release.md) §9.1.

package/dist/cost.d.ts

@@ -0,0 +1,66 @@
+/**
+ * What the provability gate cost a sample (design/0.8.0-provability-release.md
+ * §9.1 `provability.costPerProvenClaim`, the `continuity.costPerProvenOutcome`
+ * precedent): the spend the gate CAUSED, read from the run's own trace events,
+ * never estimated.
+ *
+ *   - re-runs — every model call inside a turn AFTER a failing
+ *     `provability_graded` pass and BEFORE that turn's next pass: the retry
+ *     (or escalation) the failing verdict triggered. Calls with
+ *     `role: "judge"` are left out of the window: the waiver judge is counted
+ *     from the gate's own report below (counting both would double it), and
+ *     an `evaluation:` judge re-grading the re-run is that gate's spend;
+ *   - the waiver judge — `judgeCostUsdMicros` on every `provability_graded`
+ *     pass (the bundle's `spentUsdMicros` when the run carried no pass
+ *     events, e.g. a hand-wired invoker that supplied only the bundle);
+ *   - checker time — `durationMs` of every `proof_checked` event. Time, not
+ *     money: reported beside the spend, never added to it.
+ *
+ * How a re-run call is priced depends on whether the run was METERED:
+ *
+ *   - a run whose cost-tracker was attached (`CREWHAUS_COST_TRACKING=1`, or a
+ *     session-scoped budget) publishes one `cost_accrual` per call, so the
+ *     window's accruals ARE the price; an accrual the tracker could not price
+ *     (`unpriced: true`) adds its tokens to the unpriced count;
+ *   - an unmetered run (a plain `crewhaus eval` attaches no tracker) prices
+ *     the window's `model_response` usage through the caller's `pricing`
+ *     seam (the eval runner's `RunEvalOptions.pricing` — the same lookup the
+ *     run's budget cap uses); a call it cannot price, or every call when no
+ *     seam was given, is unpriced.
+ *
+ * Unpriced tokens are reported as UNPRICED, never as free: the grader marks
+ * the ratio a lower bound and the roll-up counts it apart.
+ */
+import type { ProofBundle } from "@crewhaus/provability";
+import type { TraceEvent } from "@crewhaus/trace-event-bus";
+/**
+ * Prices one model call in USD micro-dollars, or `undefined` when the model
+ * has no pricing row. Structurally the eval runner's `EvalPricingFn`.
+ */
+export type GatePricing = (model: string, tokens: {
+    readonly input: number;
+    readonly output: number;
+}) => number | undefined;
+export type GateSpend = {
+    /** Gate-triggered re-runs: agent/escalation calls inside a retry window, as priced. */
+    readonly rerunUsdMicros: number;
+    /** The opt-in paraphrase-waiver judge, as the gate reported it. */
+    readonly judgeUsdMicros: number;
+    /** `rerunUsdMicros + judgeUsdMicros` — a LOWER BOUND when {@link unpriced}. */
+    readonly totalUsdMicros: number;
+    /** Verification passes after the first, across every turn. */
+    readonly reruns: number;
+    /** Input + output tokens of the re-run calls (priced or not). */
+    readonly rerunTokens: number;
+    /** Re-run tokens nothing priced (an unpriced accrual, or a call the seam could not price). */
+    readonly unpricedTokens: number;
+    /** `unpricedTokens > 0`: the spend above is a lower bound. */
+    readonly unpriced: boolean;
+    /** `ProofCheck` checker runs and their summed wall-clock time. */
+    readonly checks: number;
+    readonly checkerMs: number;
+};
+/** The spend the gate caused across `events` (see the module doc). */
+export declare function gateSpendOf(events: ReadonlyArray<TraceEvent>, bundle?: Pick<ProofBundle, "spentUsdMicros">, opts?: {
+    readonly pricing?: GatePricing;
+}): GateSpend;

package/dist/cost.js

@@ -0,0 +1,91 @@
+const finite = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+/** A per-call accrual (not the role-less optimizer roll-up, which re-sums per-call ones). */
+const isCallAccrual = (event) => event.kind === "cost_accrual" && event.summary !== true;
+/** The spend the gate caused across `events` (see the module doc). */
+export function gateSpendOf(events, bundle, opts = {}) {
+    // Passes per turn, in publish order: a window opens after a FAILING pass
+    // and closes at the turn's next pass.
+    const passesByTurn = new Map();
+    let judgeUsdMicros = 0;
+    let sawPass = false;
+    let checks = 0;
+    let checkerMs = 0;
+    events.forEach((event, index) => {
+        if (event.kind === "provability_graded") {
+            sawPass = true;
+            judgeUsdMicros += finite(event.judgeCostUsdMicros);
+            const passes = passesByTurn.get(event.turnNumber) ?? [];
+            passes.push({ index, failing: event.verdict === "fail" });
+            passesByTurn.set(event.turnNumber, passes);
+        }
+        else if (event.kind === "proof_checked") {
+            checks += 1;
+            checkerMs += finite(event.durationMs);
+        }
+    });
+    if (!sawPass)
+        judgeUsdMicros = finite(bundle?.spentUsdMicros);
+    /** Whether event `index` of turn `turn` sits inside a retry window. */
+    const inWindow = (turn, index) => {
+        const passes = passesByTurn.get(turn);
+        if (passes === undefined)
+            return false;
+        for (let i = 0; i + 1 < passes.length; i++) {
+            const open = passes[i];
+            const close = passes[i + 1];
+            if (open.failing && index > open.index && index < close.index)
+                return true;
+        }
+        return false;
+    };
+    // A tracker publishes an accrual for EVERY call, so one per-call accrual
+    // anywhere means the accruals are the price; without one, the seam prices.
+    const metered = events.some(isCallAccrual);
+    let rerunUsdMicros = 0;
+    let rerunTokens = 0;
+    let unpricedTokens = 0;
+    events.forEach((event, index) => {
+        if (event.kind === "cost_accrual") {
+            if (event.role === "judge" || !inWindow(event.turnNumber, index))
+                return;
+            // The role-less optimizer total re-sums per-call accruals; a ROLED
+            // summary is a nested run (a Task child) whose calls this bus never saw.
+            if (event.summary === true && event.role === undefined)
+                return;
+            if (event.unpriced === true) {
+                unpricedTokens += finite(event.inputTokens) + finite(event.outputTokens);
+            }
+            else {
+                rerunUsdMicros += finite(event.costUsdMicros);
+            }
+        }
+        else if (event.kind === "model_response") {
+            if (event.role === "judge" || !inWindow(event.turnNumber, index))
+                return;
+            const input = finite(event.usage.input);
+            const output = finite(event.usage.output);
+            rerunTokens += input + output;
+            if (metered)
+                return;
+            const priced = opts.pricing?.(event.specModel ?? event.model, { input, output });
+            if (typeof priced === "number" && Number.isFinite(priced))
+                rerunUsdMicros += priced;
+            else
+                unpricedTokens += input + output;
+        }
+    });
+    let reruns = 0;
+    for (const passes of passesByTurn.values())
+        reruns += Math.max(0, passes.length - 1);
+    return {
+        rerunUsdMicros,
+        judgeUsdMicros,
+        totalUsdMicros: rerunUsdMicros + judgeUsdMicros,
+        reruns,
+        rerunTokens,
+        unpricedTokens,
+        unpriced: unpricedTokens > 0,
+        checks,
+        checkerMs,
+    };
+}

package/dist/graders.d.ts

@@ -0,0 +1,149 @@
+/**
+ * The six provability graders (design/0.8.0-provability-release.md §9.1) —
+ * deterministic reads of the proof bundle the eval runner captured for a
+ * sample (`RunResult.artifacts.proof`, the gate's STANDING verdict). No
+ * grader re-verifies anything: the bundle is the gate's own record, and these
+ * only measure it, so a sample graded here and the footer its answer carried
+ * can never disagree.
+ *
+ * The floor a sample is graded at is `metadata.provability.level` when the
+ * sample sets one, else the bundle's own (the spec's `provability.level`, or
+ * the `crewhaus eval --provability` override). The eval runner wires each
+ * gated sample's gate AT that floor, so in a runner-made bundle the two
+ * agree and every grade is the gate's own. A bundle made elsewhere (a
+ * hand-wired invoker) can disagree:
+ *   - a floor BELOW the bundle's re-reads the rungs the gate RECORDED: a
+ *     claim meets it when it has no dangling marker and some non-assumption
+ *     binding reached that rung. `grounded.independent` and the guarded HEAD
+ *     are applied only at the run's own floor, so that grade is close, not
+ *     exact;
+ *   - a floor ABOVE the bundle's is not graded at all by the floor-dependent
+ *     graders (claimCoverage, rungAchieved, replayIntegrity,
+ *     costPerProvenClaim): the verifier computes rungs above its floor
+ *     WITHOUT the checks only those floors run (replay at checked), so a
+ *     recorded `checked` there is a claim nobody checked. Those graders fail
+ *     the sample as unmeasured ({@link FLOOR_ABOVE_BUNDLE}); citationValidity
+ *     and assumptionRate do not depend on the floor and still measure.
+ *
+ * Every failure that replaces a measurement starts with a pinned prefix
+ * ({@link UNMEASURED_PREFIXES}, read by {@link isUnmeasured} and the roll-up),
+ * never a guess:
+ *   - NO BUNDLE — the run was not gated (no `provability:` block and no
+ *     `--provability`), or the sample ended (an invoker error, a timeout)
+ *     before the gate graded an answer. A provability grader is configured
+ *     because proof is expected; a missing verdict must not read as a pass
+ *     (the research report's NO_CITATIONS_NOTICE posture: an ungated answer
+ *     never passes for a gated one).
+ *   - UNVERIFIED — the gate's verifier threw and the answer stood unchecked
+ *     (design §5.1 fail-open). Nothing was measured, so nothing passes.
+ *   - INVALID METADATA — a malformed `metadata.provability`, naming the field.
+ *   - FLOOR ABOVE THE BUNDLE — see above.
+ */
+import type { GradeResult, Grader } from "@crewhaus/eval-grader";
+import { type GatePricing } from "./cost";
+/** The release thresholds (design §9.1's table). */
+export declare const PROVABILITY_METRIC_THRESHOLDS: Readonly<{
+    /** met / (claims − assumptions) at the floor. */
+    claimCoverage: 0.95;
+    /** defined markers / markers. */
+    citationValidity: 0.99;
+    /** declared assumptions / claims — an UPPER bound. */
+    assumptionRate: 0.1;
+    /** matched replays / replays — every replay must match. */
+    replayIntegrity: 1;
+}>;
+/** The reason a provability grader returns when the run carried no bundle. */
+export declare const NO_PROOF_BUNDLE = "no proof bundle (is provability: declared?)";
+/** The pinned prefix of the result for a bundle whose verifier threw (§5.1 fail-open). */
+export declare const UNVERIFIED_BUNDLE = "the gate could not verify this answer";
+/** The pinned prefix of the result for a malformed `metadata.provability`. */
+export declare const INVALID_SAMPLE_METADATA = "invalid metadata.provability";
+/** The pinned prefix of a floor-dependent result whose floor is above the bundle's. */
+export declare const FLOOR_ABOVE_BUNDLE = "not gradable at this floor";
+/**
+ * Every prefix a result carries when it REPLACES a measurement (no score was
+ * measured; `score` is a placeholder 0). A roll-up keeps these out of a
+ * lower-is-better mean, where a placeholder 0 would read as the best value.
+ */
+export declare const UNMEASURED_PREFIXES: ReadonlyArray<string>;
+/** Whether a provability grade replaced its measurement with a failure (see {@link UNMEASURED_PREFIXES}). */
+export declare function isUnmeasured(result: Pick<GradeResult, "rationale">): boolean;
+/** The pinned prefix of an infinite `costPerProvenClaim` rationale (see the grader). */
+export declare const INFINITE_COST_PREFIX = "\u221E per proven claim";
+/** The pinned prefix of a `costPerProvenClaim` whose spend is a lower bound (see the grader). */
+export declare const UNPRICED_COST_PREFIX = "\u2265 (partly unpriced) per proven claim";
+/**
+ * met / (claims − assumptions) at the floor, the gate's own score when the
+ * floor is the run's. Passes at ≥ 0.95 AND when every
+ * `metadata.provability.expected_sources` origin grounded the answer — an ok
+ * source binding, or at `checked` / `proven` (where a source is never `ok`)
+ * one that reached `grounded` (see `sourceGrounds`). A missing one fails the
+ * sample; the score stays the coverage, the rationale names the source.
+ */
+export declare const claimCoverage: Grader;
+/**
+ * The highest floor the answer would have passed (`bundle.achieved`, the
+ * gate ran every rung for it), normalized 0..1 as rank/4 — a per-sample
+ * ladder score that shows HOW FAR an answer falls short. Passes when the
+ * achieved rung is at or above the floor.
+ */
+export declare const rungAchieved: Grader;
+/**
+ * defined markers / markers — the `cited` sub-check alone: every `[n]` in a
+ * claim needs its `[n]: …` definition. One binding is one marker occurrence;
+ * a marker with no definition is a binding whose reason is `no_definition`.
+ * No markers at all is a vacuous pass (claimCoverage is what fails an
+ * uncited answer). Passes at ≥ 0.99.
+ *
+ * Design §9.1 counts the markers the ANSWER wrote. A claim carrying
+ * `definition` is text a definition line shows after what it names, read
+ * as citing that definition: its one binding is the verifier's synthetic
+ * self-binding, defined by construction and never typed as a marker. So it
+ * is skipped — counted, a gloss sentence (or a long bibliography) would add
+ * a defined marker to both sides and lift a dangling-marker answer over the
+ * bar.
+ */
+export declare const citationValidity: Grader;
+/**
+ * declared assumptions / claims — the assumption dodge made visible. LOWER is
+ * better (the continuity.reAskRate precedent): passes at ≤ 0.1. Declared
+ * counts the accepted assumptions, the ones the config refused
+ * (`assumptions: forbid`, past `max_assumptions`) — a refused assumption is
+ * still the answer leaning on one — and the hypotheses accepted proofs rest
+ * on (`hypotheses`, design §6.4): a proof that assumes its own conclusion is
+ * not "0 assumptions". Zero claims is a vacuous 0.
+ */
+export declare const assumptionRate: Grader;
+/**
+ * replayed executions whose output digest matched / replayed executions.
+ * An execution is one `tool:<toolUseId>` (bindings citing the same call share
+ * its one replay). Must be exactly 1: a mismatch means a cited result is not
+ * what the tool returns for that input. None replayed is a vacuous pass —
+ * replay runs only at a `checked` floor, for pure tools, with
+ * `execution.replay` on.
+ */
+export declare const replayIntegrity: Grader;
+/**
+ * Gate-caused spend per met claim (see `./cost` for exactly what counts and
+ * how it is priced) — the `continuity.costPerProvenOutcome` precedent, but
+ * REPORTED, with no threshold: it never fails a measured sample (only a
+ * missing or unverified bundle does, like every grader here). Score is USD
+ * per claim met at the floor. Three outcomes are told apart by a pinned
+ * rationale prefix, which the roll-up reads:
+ *   - {@link INFINITE_COST_PREFIX} — spend (priced, or tokens nothing could
+ *     price) with zero met claims: the infinite ratio, kept JSON-safe as
+ *     score 0;
+ *   - {@link UNPRICED_COST_PREFIX} — some re-run tokens had no price, so the
+ *     score is the PRICED part per met claim, a lower bound, never a $0 that
+ *     reads as free;
+ *   - otherwise the exact ratio.
+ *
+ * `pricing` prices re-run calls on a run no cost-tracker metered (the eval
+ * runner passes its own `RunEvalOptions.pricing`); without it those calls
+ * are unpriced.
+ */
+export declare function createCostPerProvenClaim(opts?: {
+    readonly pricing?: GatePricing;
+}): Grader;
+/** {@link createCostPerProvenClaim} with no pricing seam (the registry's instance). */
+export declare const costPerProvenClaim: Grader;