@crewhaus/tool-proof 0.0.0-stage → 0.8.1

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,150 @@
-# Temporary Holding Version
+# @crewhaus/tool-proof
 
-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.
+The tools a harness uses to prove its claims, and to check a draft answer before it sends it.
+They are the tool surface of the provability ladder (`provability:` in a spec: cited, grounded,
+checked, proven).
+
+```yaml
+tools:
+  - all-proof        # the tools below (also part of all-safety)
+```
+
+| Tool | What it does |
+|---|---|
+| `ProofCheckers` | Lists the proof checkers this harness can use, in preference order: whether each can run here (and why not), and the statement language each one checks |
+| `ProofCheck` | Runs a checker on `{ checker, claim, statement, proof }` and saves the verdict as a `prf_…` artifact. On ok the answer cites it as `[n]: proof:prf_…` |
+| `ProvabilityPreflight` | Grades `{ draft }` with the gate's own verifier and returns the verdict, a row per claim and what to fix. Gates nothing |
+
+Nothing here cites for the model, and nothing calls a model. A checker's verdict is the only
+thing `ProofCheck` trusts; the preflight is the same `verifyDocument` the gate runs, over the same
+evidence. A spec with a `provability:` block gets `ProvabilityPreflight` from the gate itself
+(`@crewhaus/evaluation-service`), and `ProofCheckers` and `ProofCheck` too at `proven` or when its
+`formal.checkers` is not the default. All three are bound to the gate's configuration, and any of them
+the spec also lists in `tools:` is replaced by the bound one. The builtin instances serve a spec
+without the block.
+
+## Checkers
+
+From [`@crewhaus/proof-checker`](../proof-checker), in the order `provability.formal.checkers`
+gives (default `builtin`, `smt`), with `builtin` always appended when the list leaves it out:
+
+- `builtin`: exact finite arithmetic and logic. No sandbox, always available.
+- `smt`: SMT-LIB 2 checked by Z3 in a container sandbox.
+- `lean4`: Lean 4 in a container sandbox.
+
+The sandbox checkers are listed whenever the config names them. They get a container sandbox
+when the run says one is wired or `CREWHAUS_SANDBOX` selects `docker` or `podman` (unset means
+docker); under `noop`, or a value that names no backend, they show as unavailable with the
+reason. With a sandbox, availability is the image's healthcheck, so a missing daemon or image
+reads as unavailable with why, and the first probe may wait on a cold pull. `ProofCheck` refuses
+an unknown or unavailable checker before anything is checked or saved.
+
+## Artifacts and events
+
+Every check that runs is saved, accepted or rejected, under
+`<cwd>/.crewhaus/proofs/<spec>/artifacts/<prf_id>.json` (mode 0600, never overwritten). A
+rejected proof is kept because it is signal: the bundle can then say why a citation of it
+failed. A check that never finishes is saved as a rejection once it runs past `formal.timeoutMs`
+plus `CHECK_GRACE_MS` (30 s); a cancelled call saves nothing.
+
+On the managed shape each turn runs inside its tenant, and the tools file artifacts under the
+tenant's own root (`<tenantRoot>/proofs/<spec>/`) and read its own sessions. A root outside the
+tenant is refused.
+
+Each check publishes a `proof_checked` trace event on the run's bus (`checker`, `ok`,
+`artifactId`, `durationMs`, `axioms`) and appends the same payload to the run's session event
+log.
+
+## API
+
+`createProofTools(opts?): ProofTools` builds the tools (`proofCheckers`, `proofCheck`,
+`provabilityPreflight`, and `all`) over one configuration:
+
+| Option | Meaning |
+|---|---|
+| `config` | The lowered `provability:` block. Default: the compiler's defaults at the `grounded` floor (`defaultProvabilityConfig()`). |
+| `specName` / `proofsRoot` | Where artifacts are filed: `<workspaceRoot>/.crewhaus/proofs/<specName>/`, or a root you name. |
+| `workspaceRoot` | Where path sources resolve (default: `process.cwd()` at call time). |
+| `checkers` | The checkers, in preference order. Default: `buildDefaultCheckers(config, …)`, built on first use. |
+| `sessionRootDir` | Where session logs live, when no `evidence` is injected. Default: the run's, the tenant's, `CREWHAUS_SESSION_DIR`, `.crewhaus/sessions`. |
+| `evidence` | `(ctx) => Promise<EvidenceIndex \| { index, turnNumbers?: Set<number> }>`: what the preflight grades against. A builder that rejects or returns anything else, or a `turnNumbers` that is not a `Set`, fails the call. Default: the run's session log, scoped by `config.scope`. |
+| `checkTimeoutMs` | The backstop before a check is saved as a rejection (default `formal.timeoutMs + CHECK_GRACE_MS`). |
+| `now` | Clock for `checkedAt` (tests). |
+
+The roots are resolved on every call, for the tenant the call runs under, so one instance built
+at boot serves every tenant of a managed daemon. Pass `specName` and `workspaceRoot` and let the
+tools resolve the root per call, or pass a function of the tenant, such as
+`(tenant) => defaultProofsRoot(cwd, spec, tenant)`. Do not pass a `proofsRoot` string resolved at
+boot to a managed daemon: no tenant exists then, and a root outside the call's tenant is
+refused, so every managed call would fail. `sessionRootDir` works the same way. The gate's
+composition root calls `createProofTools` with the spec's block, its proofs resolver and the
+evidence builder its verifier uses, so the gate and the tools always agree.
+
+The exported builtin instances (`proofCheckers`, `proofCheck`, `provabilityPreflight`,
+`PROOF_TOOLS`) are what a spec gets by listing the tools without a `provability:` block: the
+compiler's defaults at the `grounded` floor, artifacts under `.crewhaus/proofs/default/` (a run
+context carries no spec name), and the run's session log as evidence.
+
+The pieces are exported for the gate and the CLI: `buildDefaultCheckers`, `defaultCheckerIds`,
+`sandboxImages`, `listCheckers`, `probeChecker`; `runChecker`, `toArtifact`, `checkReport`;
+`preflightBundle`, `preflightConfig`, `preflightReport`; `sessionEvidence`, `currentTurn`,
+`startsTurn`; `proofRecheck` / `recheckProof` (the builtin checker re-running a stored builtin
+proof, the gate's `recheckProof`); `defaultProofsRoot`, `defaultSessionRoot`, `tenantRootOf`,
+`runtimeStateRoots` (the run's own state directories, which the gate and the preflight both
+refuse as sources) and `STATE_ENV_VARS`; and the bounds `PROOF_INPUT_LIMITS`, `REPORT_BYTES`,
+`DRAFT_CHARS`.
+
+## Flags
+
+| Tool | readOnly | concurrencySafe | destructive | requiresSandbox | scope |
+|---|---|---|---|---|---|
+| `ProofCheckers` | yes | yes | no | no | internal |
+| `ProofCheck` | no | yes | yes (writes one artifact) | no | internal |
+| `ProvabilityPreflight` | yes | yes | no | no | internal |
+
+`ProofCheck` is not `requiresSandbox`: the builtin checker needs none, and a tool-level flag would
+deny it on every sandbox-less harness. The sandbox checkers refuse themselves without a sandbox
+and on the `noop` backend, so the sandbox floor applies per checker rather than per tool.
+
+Its operative argument is `checker`, so a permission rule can scope it: `alwaysAllow
+ProofCheck(builtin)` allows the sandbox-free checker alone. permission-engine carries that rule
+as a builtin default, beside `alwaysAllow` for `ProofCheckers` and `ProvabilityPreflight`, so a
+`proven` harness reaches its floor through the builtin checker without approval on every
+surface. `smt` and `lean4` start a container and keep the mode's default (allow them with
+`alwaysAllow ProofCheck(smt)`, `ProofCheck(lean4)`).
+
+## Reports
+
+Each report is small enough for the model to read whole (`REPORT_BYTES`), since the runtime shows
+only the start of a large tool result. The verdict and what to do next come first, then the
+details. The preflight lists unmet claims first and counts any it had no room for; the full proof
+and output stay in the artifact.
+
+## What the preflight does not do
+
+It never leaves the run. Compared with the gate it skips three steps, with a note in the report
+wherever one would have mattered:
+
+- **HEAD requests** (`sources.resolve: head`): no URL is contacted; the draft is checked as if
+  `resolve` were `off`.
+- **Replay** (`checked`): cited tools are not re-run; bindings read `replayed: false`.
+- **The paraphrase judge**: never consulted. A paraphrase the gate's judge might accept shows as
+  `not_found_in_source` here, so the preflight is the stricter of the two.
+
+It does re-check a stored builtin proof and refuse the run's own state directories as sources,
+as the gate does.
+
+## Tests
+
+```sh
+bun test src
+```
+
+The suites pin the package-wide flags and bounds (`index`), run the tools through the executor
+(`integration`), cover `ProofCheck` with the builtin checker, a scripted sandbox and plugin
+checkers that misbehave (`check`), the listing with and without a sandbox (`checkers`), the
+tenant fencing (`tenancy`), and the preflight's parity with the gate (`preflight`). No test needs
+Docker; the sandbox checkers' real images are exercised by `@crewhaus/proof-checker`'s gated live
+test.
+
+Design: [design/0.8.0-provability-release.md](../../design/0.8.0-provability-release.md) §6.4, §7.

package/dist/index.d.ts

@@ -0,0 +1,148 @@
+/**
+ * @crewhaus/tool-proof — the tools a harness proves claims with and checks
+ * a draft with before it answers (design/0.8.0-provability-release.md §7).
+ *
+ *   ProofCheckers         which proof checkers this harness can use, whether
+ *                         each can run here, and the language each checks
+ *   ProofCheck            run a checker on a proof and save the verdict as a
+ *                         `prf_…` artifact the `proven` rung can cite
+ *   ProvabilityPreflight  grade a draft with the gate's own verifier,
+ *                         without gating
+ *
+ * Nothing here cites for the model and nothing calls a model. A checker's
+ * exit status is the only thing `ProofCheck` trusts, and the preflight is
+ * `verifyDocument` — the function the gate calls — over the same evidence.
+ *
+ * `createProofTools` binds the three tools to one configuration: the
+ * composition root (`@crewhaus/evaluation-service`) calls it with the spec's
+ * lowered `provability:` block, so the gate and the tools agree on the
+ * floor, the checkers, the artifacts root and the evidence. The roots are
+ * resolved per call, for the tenant the call runs under: an instance built
+ * once at boot serves every tenant of a managed daemon (see
+ * {@link CreateProofToolsOptions.proofsRoot}). The exported
+ * builtin instances are what a spec gets by listing `proofCheck` (or
+ * `all-proof`) in `tools:` with no `provability:` block: the compiler's
+ * defaults at the `grounded` floor, checkers in `builtin, smt` order,
+ * artifacts under `<cwd>/.crewhaus/proofs/default/` (under the tenant's root
+ * inside a managed turn, see `./lib/roots`), and the run's own session log
+ * as evidence.
+ *
+ * Each tool is a thin wrapper over `./lib`, where the behaviour lives.
+ */
+import { CrewhausError } from "@crewhaus/errors";
+import { type ProofChecker } from "@crewhaus/proof-checker";
+import { type EvidenceIndex, type ProvabilityConfig } from "@crewhaus/provability";
+import { type Tenant } from "@crewhaus/tenancy";
+import type { RegisteredTool, ToolExecuteContext } from "@crewhaus/tool-catalog";
+export { AVAILABILITY_TIMEOUT_MS, BUILTIN_ID, type CheckerListing, type DefaultCheckerDeps, buildDefaultCheckers, defaultCheckerIds, listCheckers, probeChecker, sandboxImages, } from "./lib/checkers";
+export { CHECK_GRACE_MS, OUTPUT_CHARS, PROOF_INPUT_LIMITS, REPORT_BYTES, type RunCheckerOptions, checkReport, runChecker, toArtifact, } from "./lib/check";
+export { DEFAULT_EXECUTION_SELECTORS, DEFAULT_FLOOR, DEFAULT_SPEC_NAME, defaultProvabilityConfig, } from "./lib/config";
+export { type SessionEvidence, currentTurn, sessionEvidence, startsTurn } from "./lib/evidence";
+export { DRAFT_CHARS, NOTES_BYTES, ROW_BINDINGS, TABLE_ROWS, preflightBundle, preflightConfig, preflightReport, } from "./lib/preflight";
+export { type RecheckProofOptions, proofRecheck, recheckProof } from "./lib/recheck";
+export { STATE_ENV_VARS, defaultProofsRoot, defaultSessionRoot, runtimeStateRoots, tenantRootOf, } from "./lib/roots";
+/** A call the tools refuse: an unknown or unavailable checker, an artifact that could not be saved. */
+export declare class ProofToolError extends CrewhausError {
+    readonly name = "ProofToolError";
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * What an injected evidence builder returns: the index alone when it is
+ * already restricted to `config.scope`, or the index with the turns
+ * `scope: turn` keeps (`VerifyOptions.turnNumbers`), which the preflight
+ * forwards to the verifier exactly as the gate does.
+ */
+export type ProofToolEvidence = EvidenceIndex | {
+    readonly index: EvidenceIndex;
+    readonly turnNumbers?: ReadonlySet<number>;
+};
+/**
+ * A directory fixed for the instance's life, or resolved on every call from
+ * the tenant the call runs under (`undefined` outside any tenant scope).
+ */
+export type ProofToolsRoot = string | ((tenant: Tenant | undefined) => string);
+export type CreateProofToolsOptions = {
+    /**
+     * The lowered `provability:` block (`IrProvability`) the gate runs under.
+     * Absent: the compiler's defaults at the `grounded` floor.
+     */
+    readonly config?: ProvabilityConfig;
+    /**
+     * Whose proofs these are: artifacts go under
+     * `<workspaceRoot>/.crewhaus/proofs/<specName>/artifacts/` (inside a
+     * tenant scope, `<tenantRoot>/proofs/<specName>/artifacts/`). Absent: the
+     * spec name the run carries, else `default`. Ignored when `proofsRoot` is set.
+     */
+    readonly specName?: string;
+    /**
+     * The proofs root itself, for a caller that resolves it rather than naming
+     * `specName`. Inside a tenant scope the root a call resolves must lie
+     * under that tenant's root, or the call is refused (`TenancyError`).
+     *
+     * So a fixed string suits a CLI run or a single-tenant daemon only. A
+     * composition root that builds the tools once at boot and serves every
+     * tenant — a managed daemon — must NOT pass the boot-time
+     * `proofsRoot(cwd, specName)`: no tenant exists at boot, and that root
+     * fails every managed call. It either omits this (passing `specName` and
+     * `workspaceRoot`; the tools then resolve `<tenantRoot>/proofs/<spec>`
+     * per call, `<workspaceRoot>/.crewhaus/proofs/<spec>` outside a tenant),
+     * or passes a function of the call's tenant, e.g.
+     * `(tenant) => defaultProofsRoot(cwd, specName, tenant)`. The gate's own
+     * artifact and bundle stores resolve the same way, per turn —
+     * `defaultProofsRoot(cwd, specName, currentTenantContext()?.tenant)` —
+     * so a citation the tools filed resolves at the gate.
+     */
+    readonly proofsRoot?: ProofToolsRoot;
+    /** Where path sources resolve and `.crewhaus/` lives (default: `process.cwd()` at call time). */
+    readonly workspaceRoot?: string;
+    /**
+     * The checkers, in preference order. Absent: `createDefaultCheckers` over
+     * `config.formal` with the builtin always present, the sandbox checkers
+     * given a container sandbox when one is available.
+     */
+    readonly checkers?: ReadonlyArray<ProofChecker>;
+    /**
+     * Where session `.jsonl` logs live. Default: the run's, else the active
+     * tenant's `sessionRoot`, else `CREWHAUS_SESSION_DIR`, else
+     * `.crewhaus/sessions` — the runtime's own order. Inside a tenant scope
+     * the root a call resolves must lie under the tenant's root: as with
+     * `proofsRoot`, a shared instance omits it or passes a function of the
+     * call's tenant. Unused when `evidence` is injected.
+     */
+    readonly sessionRootDir?: ProofToolsRoot;
+    /**
+     * The evidence a preflight grades against. Absent: the run's session log
+     * (`ctx.runContext.sessionId`), scoped by `config.scope`. The gate's
+     * composition root passes the builder its verifier uses. Under
+     * `scope: turn` the builder returns either an index already restricted to
+     * the turn, or `{ index, turnNumbers }` for the preflight to restrict the
+     * way the gate does — never a session-wide index alone, which would let
+     * an earlier turn's reading ground this turn's draft.
+     */
+    readonly evidence?: (ctx: ToolExecuteContext | undefined) => Promise<ProofToolEvidence>;
+    /**
+     * The longest one check may take before it is saved as a rejection.
+     * Default: `config.formal.timeoutMs` + {@link CHECK_GRACE_MS}.
+     */
+    readonly checkTimeoutMs?: number;
+    /** Clock for `checkedAt` and bundle timestamps (tests). */
+    readonly now?: () => Date;
+};
+export type ProofTools = {
+    readonly proofCheckers: RegisteredTool;
+    readonly proofCheck: RegisteredTool;
+    readonly provabilityPreflight: RegisteredTool;
+    /** The three tools, registration-ready. */
+    readonly all: readonly RegisteredTool[];
+};
+/**
+ * Build the three proof tools over one configuration (see the module doc).
+ * Nothing is created here — no sandbox, no directory, no log read: each
+ * tool resolves what it needs on its first call.
+ */
+export declare function createProofTools(opts?: CreateProofToolsOptions): ProofTools;
+export declare const proofCheckers: RegisteredTool;
+export declare const proofCheck: RegisteredTool;
+export declare const provabilityPreflight: RegisteredTool;
+/** Every builtin proof tool, registration-ready. */
+export declare const PROOF_TOOLS: readonly RegisteredTool[];