@crewhaus/tool-proof 0.0.0-stage → 0.8.1

package/dist/index.js

@@ -0,0 +1,365 @@
+/**
+ * @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 { createCheckerRegistry, } from "@crewhaus/proof-checker";
+import { createFileArtifactStore, newProofId, proofsRoot as proofsRootFor, } from "@crewhaus/provability";
+import { createSandbox, sandboxAvailableFromEnv } from "@crewhaus/sandbox";
+import { currentTenantContext } from "@crewhaus/tenancy";
+import { buildTool } from "@crewhaus/tool-builder";
+import { z } from "zod";
+import { CHECK_GRACE_MS, PROOF_INPUT_LIMITS, checkReport, clip, proofCheckedFields, runChecker, toArtifact, } from "./lib/check";
+import { buildDefaultCheckers, listCheckers, probeChecker } from "./lib/checkers";
+import { DEFAULT_SPEC_NAME, assertConfig, defaultProvabilityConfig } from "./lib/config";
+import { bridgeSandboxAvailable, eventBusOf, eventLogOf, sessionIdOf, sessionRootOf, specNameOf, warn, } from "./lib/context";
+import { sessionEvidence } from "./lib/evidence";
+import { DRAFT_CHARS, preflightBundle, preflightReport } from "./lib/preflight";
+import { proofRecheck } from "./lib/recheck";
+import { defaultProofsRoot, defaultSessionRoot, fenced, runtimeStateRoots } from "./lib/roots";
+export { AVAILABILITY_TIMEOUT_MS, BUILTIN_ID, buildDefaultCheckers, defaultCheckerIds, listCheckers, probeChecker, sandboxImages, } from "./lib/checkers";
+export { CHECK_GRACE_MS, OUTPUT_CHARS, PROOF_INPUT_LIMITS, REPORT_BYTES, checkReport, runChecker, toArtifact, } from "./lib/check";
+export { DEFAULT_EXECUTION_SELECTORS, DEFAULT_FLOOR, DEFAULT_SPEC_NAME, defaultProvabilityConfig, } from "./lib/config";
+export { currentTurn, sessionEvidence, startsTurn } from "./lib/evidence";
+export { DRAFT_CHARS, NOTES_BYTES, ROW_BINDINGS, TABLE_ROWS, preflightBundle, preflightConfig, preflightReport, } from "./lib/preflight";
+export { proofRecheck, recheckProof } from "./lib/recheck";
+export { STATE_ENV_VARS, defaultProofsRoot, defaultSessionRoot, runtimeStateRoots, tenantRootOf, } from "./lib/roots";
+/** Compact JSON — the reader is a model, not a person. */
+const json = (value) => JSON.stringify(value);
+/** A call the tools refuse: an unknown or unavailable checker, an artifact that could not be saved. */
+export class ProofToolError extends CrewhausError {
+    name = "ProofToolError";
+    constructor(message, cause) {
+        super("tool", message, cause);
+    }
+}
+const checkersSchema = z.object({});
+const checkSchema = z.object({
+    checker: z
+        .string()
+        .min(1)
+        .max(PROOF_INPUT_LIMITS.checkerChars)
+        .describe("The checker to use: an id ProofCheckers lists as available (builtin, smt, lean4)."),
+    claim: z
+        .string()
+        .min(1)
+        .max(PROOF_INPUT_LIMITS.claimChars)
+        .describe("The sentence your answer will carry, as you will write it. The gate checks that the cited sentence states it."),
+    statement: z
+        .string()
+        .min(1)
+        .max(PROOF_INPUT_LIMITS.statementChars)
+        .describe("The claim as a formal statement, in the checker's language."),
+    proof: z
+        .string()
+        .min(1)
+        .max(PROOF_INPUT_LIMITS.proofChars)
+        .describe("The proof, certificate or problem, in the checker's language."),
+});
+const isEvidenceIndex = (value) => typeof value === "object" &&
+    value !== null &&
+    typeof value.all === "function" &&
+    typeof value.bySource === "function" &&
+    typeof value.byToolUseId === "function";
+const preflightSchema = z.object({
+    draft: z
+        .string()
+        .min(1)
+        .max(DRAFT_CHARS)
+        .describe("Your draft answer, exactly as you would send it, with its citation lines."),
+});
+/**
+ * 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 function createProofTools(opts = {}) {
+    const now = opts.now ?? (() => new Date());
+    if (opts.config !== undefined)
+        assertConfig(opts.config);
+    // A bad name is the caller's mistake: refuse it here, not on every call.
+    if (opts.specName !== undefined)
+        proofsRootFor(".", opts.specName);
+    // Duplicate ids are refused by the registry, also at construction.
+    const injected = opts.checkers !== undefined ? createCheckerRegistry(opts.checkers) : undefined;
+    let config = opts.config;
+    const configOf = () => {
+        config ??= defaultProvabilityConfig();
+        return config;
+    };
+    // The default checkers are built once, on first use, and kept: the
+    // sandbox checkers remember their image probe across calls.
+    let defaults;
+    const registryFor = (ctx) => {
+        if (injected !== undefined)
+            return injected;
+        defaults ??= createCheckerRegistry(buildDefaultCheckers(configOf(), {
+            sandboxAvailable: bridgeSandboxAvailable(ctx) || sandboxAvailableFromEnv(),
+            createSandbox: (sandboxOpts) => createSandbox({ allowedImages: sandboxOpts.allowedImages }),
+        }));
+        return defaults;
+    };
+    const workspaceRoot = () => opts.workspaceRoot ?? process.cwd();
+    // The tenant is read per call: it is the request's (AsyncLocalStorage),
+    // and one tools instance serves every tenant of a managed daemon.
+    const tenantNow = () => currentTenantContext()?.tenant;
+    const rootFor = (option, tenant, what) => {
+        if (typeof option !== "function")
+            return option;
+        const dir = option(tenant);
+        if (typeof dir !== "string" || dir === "") {
+            throw new ProofToolError(`the ${what} resolver returned no directory; nothing was done`);
+        }
+        return dir;
+    };
+    /** Where proofs are filed and read for this call, fenced to the active tenant. */
+    const proofsDirFor = (ctx) => {
+        const tenant = tenantNow();
+        const rootDir = rootFor(opts.proofsRoot, tenant, "proofsRoot") ??
+            defaultProofsRoot(workspaceRoot(), opts.specName ?? specNameOf(ctx) ?? DEFAULT_SPEC_NAME, tenant);
+        return fenced(rootDir, tenant);
+    };
+    const artifactsFor = (ctx) => createFileArtifactStore({ rootDir: proofsDirFor(ctx) });
+    /** The session-log root a preflight reads, when one was chosen (else event-log's default). */
+    const sessionRootFor = (ctx) => {
+        const tenant = tenantNow();
+        const chosen = rootFor(opts.sessionRootDir, tenant, "sessionRootDir") ??
+            sessionRootOf(ctx) ??
+            defaultSessionRoot(tenant);
+        // Event-log's default (`.crewhaus/sessions`, cwd-relative) when none was
+        // chosen; under a tenant one always is, and it must be the tenant's.
+        return chosen !== undefined ? fenced(chosen, tenant) : undefined;
+    };
+    const evidenceFor = async (ctx, scope) => {
+        if (opts.evidence !== undefined) {
+            let built;
+            try {
+                built = await opts.evidence(ctx);
+            }
+            catch (err) {
+                throw new ProofToolError(`ProvabilityPreflight could not read this run's evidence: ${err instanceof Error ? err.message : String(err)}`, err);
+            }
+            if (isEvidenceIndex(built))
+                return { index: built, notes: [] };
+            const scoped = built;
+            if (typeof scoped === "object" && scoped !== null && isEvidenceIndex(scoped.index)) {
+                if (scoped.turnNumbers !== undefined && !(scoped.turnNumbers instanceof Set)) {
+                    throw new ProofToolError("ProvabilityPreflight could not read this run's evidence: turnNumbers must be a Set of turn numbers");
+                }
+                return {
+                    index: scoped.index,
+                    ...(scoped.turnNumbers !== undefined
+                        ? { turnNumbers: scoped.turnNumbers }
+                        : {}),
+                    notes: [],
+                };
+            }
+            // Grading against nothing would fail every claim as not fetched: refuse.
+            throw new ProofToolError("ProvabilityPreflight could not read this run's evidence: the evidence builder returned no evidence index");
+        }
+        const tenant = tenantNow();
+        const sessionId = sessionIdOf(ctx);
+        const rootDir = sessionRootFor(ctx);
+        return sessionEvidence({
+            scope,
+            ...(sessionId !== undefined ? { sessionId } : {}),
+            ...(rootDir !== undefined ? { rootDir } : {}),
+            ...(opts.workspaceRoot !== undefined ? { workspaceRoot: opts.workspaceRoot } : {}),
+            // Inside a tenant scope the runtime spills to the tenant's root.
+            ...(tenant !== undefined ? { toolResultsRoot: tenant.toolResultRoot } : {}),
+            onUnreadable: (info) => warn(ctx, "tool-proof: a session log could not be read to its end", { ...info }),
+        });
+    };
+    /** "available: builtin; listed but not available here: smt (why)". */
+    const describeCheckers = async (registry) => {
+        const listing = await listCheckers(registry.list());
+        const up = listing.filter((c) => c.available).map((c) => c.id);
+        const down = listing.filter((c) => !c.available).map((c) => c.id);
+        return [
+            `available: ${up.length > 0 ? up.join(", ") : "none"}`,
+            ...(down.length > 0 ? [`listed but not available here: ${down.join(", ")}`] : []),
+        ].join("; ");
+    };
+    const proofCheckers = buildTool({
+        name: "ProofCheckers",
+        description: "List the proof checkers this harness can prove claims with, in preference order: whether each can run here (and why not), and the statement language each one checks. Use it before ProofCheck, so you write the statement and the proof in a language an available checker accepts.",
+        inputSchema: checkersSchema,
+        readOnly: true,
+        concurrencySafe: true,
+        execute: async (_input, ctx) => {
+            const listing = await listCheckers(registryFor(ctx).list());
+            return json({
+                floor: configOf().level,
+                checkers: listing,
+                usage: "Run ProofCheck with { checker, claim, statement, proof }, using the first available checker whose language can state the claim. On ok, cite the returned id as [n]: proof:<id> on the sentence that states the claim. A proof meets any floor.",
+            });
+        },
+    });
+    const proofCheck = buildTool({
+        name: "ProofCheck",
+        description: "Check a formal proof of one claim with a proof checker and save the verdict as a proof artifact. Give the checker id (see ProofCheckers), the claim sentence as your answer will state it, the formal statement, and the proof in that checker's language. Use it to back a claim with a machine-checked proof: on ok, cite the returned id as [n]: proof:<id>. A rejected proof is saved too, with the checker's reason and any counterexample, so fix the proof or drop the claim.",
+        inputSchema: checkSchema,
+        // Writes one new, immutable artifact file per call.
+        readOnly: false,
+        destructive: true,
+        // The one choice a call makes about where it acts is which checker
+        // runs: the builtin (a worker thread, no sandbox), or a container (smt,
+        // lean4). The artifact's place is fixed by the configuration, never by
+        // the call. Declaring it lets an operator allow the sandbox-free checker
+        // alone — `alwaysAllow ProofCheck(builtin)` — and ask before the rest.
+        operativeArgs: [{ field: "checker", kind: "id" }],
+        // Each call writes its own uniquely named artifact and shares no state with
+        // another, so two checks may run side by side.
+        concurrencySafe: true,
+        // NOT requiresSandbox: the builtin checker is a parser, not an executor,
+        // and needs none. The sandbox checkers (smt, lean4) refuse themselves when
+        // no container sandbox is wired, and on the noop backend (proof-checker's
+        // sandbox-common), so the floor is per checker, not per tool — a
+        // tool-level flag would deny the builtin on every sandbox-less harness.
+        execute: async (input, ctx) => {
+            const registry = registryFor(ctx);
+            const checker = registry.get(input.checker);
+            if (checker === undefined) {
+                throw new ProofToolError(`unknown proof checker "${clip(input.checker, 64)}" — ${await describeCheckers(registry)}. Run ProofCheckers to see what each one proves.`);
+            }
+            const availability = await probeChecker(checker);
+            if (!availability.ok) {
+                throw new ProofToolError(`the ${checker.id} checker cannot run here: ${availability.reason ?? "unavailable"} — ${await describeCheckers(registry)}. Nothing was checked or saved.`);
+            }
+            // Resolved (and tenant-fenced) before the check runs: a root the call
+            // may not write is refused before any work, not after it.
+            const artifacts = artifactsFor(ctx);
+            const result = await runChecker(checker, input, {
+                ...(ctx?.signal !== undefined ? { signal: ctx.signal } : {}),
+                timeoutMs: opts.checkTimeoutMs ?? configOf().formal.timeoutMs + CHECK_GRACE_MS,
+            });
+            if (ctx?.signal?.aborted === true) {
+                // A cancelled check is not a verdict on the proof.
+                throw new ProofToolError("ProofCheck was cancelled; nothing was saved");
+            }
+            const artifact = toArtifact({
+                id: newProofId(),
+                checker,
+                input,
+                result,
+                checkedAt: now(),
+            });
+            try {
+                await artifacts.put(artifact);
+            }
+            catch (err) {
+                throw new ProofToolError(`the ${checker.id} checker ${artifact.ok ? "accepted" : "rejected"} the proof, but the artifact could not be saved, so it cannot be cited: ${err instanceof Error ? err.message : String(err)}`, err);
+            }
+            const fields = proofCheckedFields(artifact);
+            // The trace event: fire-and-forget, like every bus publish.
+            const bus = eventBusOf(ctx);
+            if (bus !== undefined) {
+                try {
+                    bus.publish({ ...bus.envelope(), kind: "proof_checked", ...fields });
+                }
+                catch (err) {
+                    warn(ctx, "tool-proof: proof_checked could not be published", {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            // The durable twin: the run's session event log, which the bridge hands
+            // to tools (`RuntimeBridge.eventLog`). The artifact file is the record a
+            // citation resolves against; the log line mirrors it, so a failed append
+            // is logged rather than turning a finished check into an error.
+            const log = eventLogOf(ctx);
+            if (log !== undefined) {
+                try {
+                    await log.append({ kind: "proof_checked", payload: fields });
+                }
+                catch (err) {
+                    warn(ctx, "tool-proof: proof_checked could not be appended to the event log", {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            return json(checkReport(artifact));
+        },
+    });
+    const provabilityPreflight = buildTool({
+        name: "ProvabilityPreflight",
+        description: "Check a draft answer against the provability gate before you send it. Runs the verifier the gate runs, over the evidence this session has gathered, and returns the verdict, each claim with its evidence and status, and what to fix. Sends nothing and gates nothing. Use it on your final draft whenever your answers must carry cited, grounded, checked or proven claims.",
+        inputSchema: preflightSchema,
+        readOnly: true,
+        concurrencySafe: true,
+        execute: async (input, ctx) => {
+            const config = configOf();
+            const artifacts = artifactsFor(ctx);
+            const evidence = await evidenceFor(ctx, config.scope);
+            const tenant = tenantNow();
+            const sessionRootDir = sessionRootFor(ctx);
+            const { bundle, notes } = await preflightBundle(input.draft, {
+                config,
+                evidence: evidence.index,
+                artifacts,
+                workspaceRoot: workspaceRoot(),
+                // The directories the gate refuses path sources under, as the gate
+                // names them (`runtimeStateRoots`), so the two agree (design §6).
+                stateRoots: runtimeStateRoots({
+                    workspaceRoot: workspaceRoot(),
+                    proofsRoot: proofsDirFor(ctx),
+                    ...(sessionRootDir !== undefined ? { sessionRootDir } : {}),
+                    ...(tenant !== undefined ? { tenant } : {}),
+                }),
+                ...(evidence.turnNumbers !== undefined ? { turnNumbers: evidence.turnNumbers } : {}),
+                // The gate's re-check of a stored builtin proof, so a draft resting
+                // on a rewritten artifact is told what the gate will say.
+                recheckProof: proofRecheck({
+                    timeoutMs: config.formal.timeoutMs,
+                    ...(ctx?.signal !== undefined ? { signal: ctx.signal } : {}),
+                }),
+                now,
+            });
+            return json(preflightReport(bundle, [...evidence.notes, ...notes]));
+        },
+    });
+    return {
+        proofCheckers,
+        proofCheck,
+        provabilityPreflight,
+        all: [proofCheckers, proofCheck, provabilityPreflight],
+    };
+}
+/**
+ * The builtin instances (see the module doc). Building them creates
+ * nothing: the default config, checkers and sandbox are resolved on the
+ * first call.
+ */
+const BUILTIN_PROOF_TOOLS = createProofTools();
+export const proofCheckers = BUILTIN_PROOF_TOOLS.proofCheckers;
+export const proofCheck = BUILTIN_PROOF_TOOLS.proofCheck;
+export const provabilityPreflight = BUILTIN_PROOF_TOOLS.provabilityPreflight;
+/** Every builtin proof tool, registration-ready. */
+export const PROOF_TOOLS = BUILTIN_PROOF_TOOLS.all;

package/dist/lib/check.d.ts

@@ -0,0 +1,122 @@
+/**
+ * One `ProofCheck`: run a checker, turn its verdict into the artifact the
+ * `proven` rung reads, and say what the model should do next (design §6.4,
+ * §7).
+ *
+ * The checker's verdict is the only thing trusted, and only `ok === true`
+ * is a proof. Everything a checker returns is normalised here, because a
+ * plugin checker implements the same interface and may get it wrong: a
+ * thrown error, a non-array of assumptions or an oversized output is a
+ * rejection or a clip, never a crash and never an accepted proof.
+ */
+import type { CheckResult, ProofChecker } from "@crewhaus/proof-checker";
+import { type ProofArtifact } from "@crewhaus/provability";
+/**
+ * Input bounds. The statement and proof bounds are the largest any shipped
+ * checker accepts (`BUILTIN_LIMITS.maxStatementChars`, `.maxProofChars`), so
+ * the schema never refuses what a checker would take; each checker applies
+ * its own tighter limit and says so. A claim is one sentence of an answer.
+ */
+export declare const PROOF_INPUT_LIMITS: {
+    readonly checkerChars: 64;
+    readonly claimChars: 2000;
+    readonly statementChars: 20000;
+    readonly proofChars: 1000000;
+};
+/** Checker output kept in an artifact (proof-checker's "a few KB"). */
+export declare const OUTPUT_CHARS = 4000;
+/**
+ * The most UTF-8 bytes a proof tool's report may be. The runtime spills any
+ * tool result over 10 KB (`@crewhaus/tool-result-store`'s
+ * `DEFAULT_THRESHOLD_BYTES`, 10 240) to a file and shows the model only its
+ * first 10 KB, so a report past that loses its tail — and the tail is where
+ * a JSON report's instructions would sit. Every report is cut to fit under
+ * it, with the instructions placed first, so the model always reads the
+ * whole of it.
+ */
+export declare const REPORT_BYTES = 9000;
+/**
+ * How much longer than `formal.timeoutMs` one check may take before it is
+ * recorded as a rejection: a container start and the checker's own
+ * reporting. The sandbox checkers stop themselves at `formal.timeoutMs`;
+ * this is the backstop for a plugin checker that never settles.
+ */
+export declare const CHECK_GRACE_MS = 30000;
+/** Keep the head and the tail of long text, marking the cut. */
+export declare function clipMiddle(text: string, cap: number): string;
+/** Text clipped to `cap` characters, an ellipsis marking the cut. */
+export declare function clip(text: string, cap: number): string;
+/** The UTF-8 bytes `value` takes in a compact JSON report. */
+export declare function jsonBytes(value: unknown): number;
+/**
+ * `text` cut (by `cut`, `clipMiddle` by default) until it takes at most
+ * `maxBytes` as a JSON string. Measured, not estimated: escaping turns a
+ * newline into two bytes and a control character into six, and a character
+ * can take three bytes of UTF-8. Empty when not even the cut marker fits.
+ */
+export declare function fitText(text: string, maxBytes: number, cut?: (text: string, cap: number) => string): string;
+export type RunCheckerOptions = {
+    /** The call's signal: an abort ends the wait at once (the caller then saves nothing). */
+    readonly signal?: AbortSignal;
+    /**
+     * The longest the check may take before it is recorded as a rejection
+     * (`formal.timeoutMs` + {@link CHECK_GRACE_MS} from the tool). Absent: no
+     * backstop.
+     */
+    readonly timeoutMs?: number;
+};
+/**
+ * Run `checker` and return a well-formed `CheckResult`, whatever it does.
+ * A checker that throws has not proved anything: the result is a rejection
+ * whose reason names the failure, and it is persisted like any rejection.
+ * So is one that does not settle within `timeoutMs`. An abort of `signal`
+ * stops the wait too, with a rejection the caller recognises by the aborted
+ * signal and does not save. Neither stops a checker that ignores its signal
+ * — nothing can — but the call returns, so one hung plugin cannot hang the
+ * turn.
+ */
+export declare function runChecker(checker: ProofChecker, input: {
+    readonly claim: string;
+    readonly statement: string;
+    readonly proof: string;
+}, opts?: RunCheckerOptions): Promise<CheckResult>;
+/**
+ * The artifact for one check — accepted or rejected alike: a rejected proof
+ * is persisted too, because proof pressure is signal (the `action_proof`
+ * rule from tool-plan), and `proof_rejected` in a bundle can then name the
+ * checker's reason. The `checker` is the id the model asked for, which is
+ * the registry's identity for the checker that ran.
+ */
+export declare function toArtifact(args: {
+    readonly id: string;
+    readonly checker: ProofChecker;
+    readonly input: {
+        readonly claim: string;
+        readonly statement: string;
+        readonly proof: string;
+    };
+    readonly result: CheckResult;
+    readonly checkedAt: Date;
+}): ProofArtifact;
+/** The `proof_checked` payload: the trace event's fields, and the event-log line's whole payload. */
+export declare function proofCheckedFields(artifact: ProofArtifact): {
+    readonly checker: string;
+    readonly ok: boolean;
+    readonly artifactId: string;
+    readonly durationMs: number;
+    readonly axioms: readonly string[];
+};
+/**
+ * As many of `items` as fit in `maxBytes`, each clipped to `itemChars`, in
+ * order, then `more(n)` counting the n left out — which the caller says
+ * where to find (the artifact keeps a ProofCheck's whole).
+ */
+export declare function listed(items: ReadonlyArray<string>, maxBytes: number, more?: (rest: number) => string, itemChars?: number): string[];
+/**
+ * What the model reads back: the verdict, the artifact id and one
+ * instruction — how to cite it, or what to do instead — first, then why
+ * (reason, counterexample), what the proof rests on and the checker's
+ * output. The whole report fits in {@link REPORT_BYTES}, the output taking
+ * what the rest leaves; the artifact keeps everything whole.
+ */
+export declare function checkReport(artifact: ProofArtifact): Record<string, unknown>;