@stsepelin/checktrail 0.1.0-alpha.1

package/dist/src/policy-pack.js

@@ -0,0 +1,41 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { environmentName } from "./environment.js";
+import { readProjectFile } from "./inventory.js";
+export const packReferenceSchema = z.strictObject({
+    path: z.string().min(1).max(4096),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+});
+export const policyPackSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    id: z
+        .string()
+        .regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/)
+        .max(256),
+    version: z
+        .string()
+        .regex(/^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/)
+        .max(128),
+    description: z.string().min(1).max(4096),
+    requiredChecks: z.array(z.string().min(1).max(256)).min(1).max(256),
+    requiredEnvironment: z.array(environmentName).max(64).optional(),
+});
+export function parsePolicyPack(contents) {
+    const pack = policyPackSchema.parse(JSON.parse(contents));
+    if (new Set(pack.requiredChecks).size !== pack.requiredChecks.length ||
+        new Set(pack.requiredEnvironment).size !==
+            (pack.requiredEnvironment?.length ?? 0))
+        throw new Error("Duplicate policy pack requirement");
+    return pack;
+}
+export async function loadPolicyPack(root, input) {
+    const reference = packReferenceSchema.parse(input);
+    const contents = await readProjectFile(root, reference.path);
+    if (Buffer.byteLength(contents) > 64 * 1024)
+        throw new Error("Policy pack exceeds 64 KiB limit");
+    const sha256 = createHash("sha256").update(contents).digest("hex");
+    if (sha256 !== reference.sha256)
+        throw new Error("Policy pack integrity mismatch");
+    const pack = parsePolicyPack(contents);
+    return { pack, sha256 };
+}

package/dist/src/pytest-evidence.d.ts

@@ -0,0 +1,2 @@
+import type { Check, CheckResult, ProcessResult } from "./types.js";
+export declare function pytestEvidence(check: Check, processes: ProcessResult[], root: string | undefined): Pick<CheckResult, "status" | "reason" | "tests">;

package/dist/src/pytest-evidence.js

@@ -0,0 +1,116 @@
+import path from "node:path";
+import { z } from "zod";
+const schema = z.object({
+    format: z.literal("checktrail-pytest-1"),
+    version: z.string().min(1),
+    exitCode: z.number().int().min(0).max(5),
+    finished: z.boolean(),
+    items: z.array(z.object({ id: z.string(), file: z.string() })),
+    reports: z.array(z.object({
+        id: z.string(),
+        phase: z.enum(["setup", "call", "teardown"]),
+        outcome: z.enum(["passed", "failed", "skipped"]),
+        xfail: z.boolean(),
+    })),
+    deselected: z.array(z.string()),
+    collectionErrors: z.array(z.string()),
+});
+export function pytestEvidence(check, processes, root) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "Pytest evidence is incomplete or does not account for every planned file and collected test.",
+    };
+    if (!root || processes.length !== 1 || !check.scope.length)
+        return incomplete;
+    const process = processes[0];
+    let value;
+    try {
+        value = JSON.parse(process.stdout);
+    }
+    catch {
+        return incomplete;
+    }
+    if (process.exitCode === 3 &&
+        z
+            .object({
+            format: z.literal("checktrail-pytest-1"),
+            unavailable: z.literal("pytest"),
+        })
+            .safeParse(value).success)
+        return {
+            status: "unavailable",
+            reason: "Pytest is not installed in the selected python3 runtime.",
+        };
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        return incomplete;
+    const report = parsed.data;
+    if (report.exitCode !== process.exitCode || !report.finished)
+        return incomplete;
+    if (report.collectionErrors.length)
+        return {
+            status: "failed",
+            reason: "Pytest reported collection or import failures.",
+        };
+    if (report.exitCode === 2)
+        return incomplete;
+    if (report.exitCode === 3 || report.exitCode === 4)
+        return {
+            status: "error",
+            reason: "Pytest reported an internal or configuration error.",
+        };
+    const expected = new Set(check.scope.map((file) => path.resolve(root, check.project, file)));
+    const files = new Set();
+    const items = new Map();
+    for (const item of report.items) {
+        if (!expected.has(item.file) || items.has(item.id))
+            return incomplete;
+        files.add(item.file);
+        items.set(item.id, []);
+    }
+    for (const event of report.reports) {
+        const events = items.get(event.id);
+        if (!events || events.some((prior) => prior.phase === event.phase))
+            return incomplete;
+        events.push(event);
+    }
+    const tests = {
+        total: items.size,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+    };
+    for (const events of items.values()) {
+        const setup = events[0];
+        const teardown = events.at(-1);
+        if (setup?.phase !== "setup" || teardown?.phase !== "teardown")
+            return incomplete;
+        const call = events.find((event) => event.phase === "call");
+        if ((setup.outcome === "passed" && !call) ||
+            (setup.outcome !== "passed" && call))
+            return incomplete;
+        if (events.some((event) => event.outcome === "failed" ||
+            (event.outcome === "passed" && event.xfail)))
+            tests.failed++;
+        else if (events.some((event) => event.outcome === "skipped"))
+            tests.skipped++;
+        else
+            tests.passed++;
+    }
+    if (tests.failed || report.exitCode === 1)
+        return {
+            status: "failed",
+            reason: "Pytest reported assertion, fixture, teardown or unexpected-pass failures.",
+            tests,
+        };
+    if (files.size !== expected.size ||
+        report.deselected.length ||
+        !tests.passed ||
+        report.exitCode !== 0)
+        return { ...incomplete, tests };
+    return {
+        status: "passed",
+        reason: "Pytest accounted for every planned file and collected test with complete lifecycle evidence.",
+        tests,
+    };
+}

package/dist/src/pytest-runner.d.ts

@@ -0,0 +1 @@
+export declare const pytestRunner: string;

package/dist/src/pytest-runner.js

@@ -0,0 +1,48 @@
+export const pytestRunner = String.raw `
+import contextlib
+import json
+import pathlib
+import sys
+
+try:
+    import pytest
+except ModuleNotFoundError as error:
+    if error.name != "pytest":
+        raise
+    print(json.dumps({"format": "checktrail-pytest-1", "unavailable": "pytest"}))
+    sys.exit(3)
+
+class Evidence:
+    def __init__(self):
+        self.items = []
+        self.reports = []
+        self.deselected = []
+        self.collection_errors = []
+        self.finished = False
+
+    def pytest_collection_finish(self, session):
+        self.items = [{"id": item.nodeid, "file": str(item.path.resolve())} for item in session.items]
+
+    def pytest_deselected(self, items):
+        self.deselected.extend(item.nodeid for item in items)
+
+    def pytest_collectreport(self, report):
+        if report.failed:
+            self.collection_errors.append(report.nodeid)
+            print(str(report.longrepr), file=sys.stderr)
+
+    def pytest_runtest_logreport(self, report):
+        self.reports.append({"id": report.nodeid, "phase": report.when, "outcome": report.outcome, "xfail": hasattr(report, "wasxfail")})
+        if report.failed:
+            print(str(report.longrepr), file=sys.stderr)
+
+    def pytest_sessionfinish(self, session, exitstatus):
+        self.finished = True
+
+plugin = Evidence()
+files = [str(pathlib.Path(file).resolve()) for file in sys.argv[1:]]
+with contextlib.redirect_stdout(sys.stderr):
+    code = pytest.main(["-o", "addopts=", "-o", "xfail_strict=true", "--maxfail=0", "-p", "no:cacheprovider", "-p", "no:terminal", "--", *files], plugins=[plugin])
+print(json.dumps({"format": "checktrail-pytest-1", "version": pytest.__version__, "exitCode": int(code), "finished": plugin.finished, "items": plugin.items, "reports": plugin.reports, "deselected": plugin.deselected, "collectionErrors": plugin.collection_errors}))
+sys.exit(int(code))
+`;

package/dist/src/pytest.d.ts

@@ -0,0 +1,2 @@
+import type { Check, Project } from "./types.js";
+export declare function pytestCheck(project: Project): Check;

package/dist/src/pytest.js

@@ -0,0 +1,25 @@
+import { pytestRunner } from "./pytest-runner.js";
+export function pytestCheck(project) {
+    const files = project.files.filter((file) => /(?:^|\/)(?:test_[^/]*|[^/]*_test)\.py$/.test(file));
+    const check = {
+        id: "python.pytest",
+        adapter: project.adapter,
+        project: project.path,
+        scope: files,
+        kind: "test",
+        parser: "pytest-json",
+        commands: [
+            {
+                executable: "python3",
+                args: ["-c", pytestRunner, ...files],
+                cwd: project.path,
+                env: { PYTHONDONTWRITEBYTECODE: "1" },
+            },
+        ],
+        reason: "Run pytest against every planned candidate and reconcile collected items with setup/call/teardown events.",
+    };
+    if (!files.length)
+        check.unavailableReason =
+            "No test_*.py or *_test.py files were inventoried.";
+    return check;
+}

package/dist/src/report-validation.d.ts

@@ -0,0 +1,129 @@
+export declare function validatedReport(input: unknown): {
+    startedAt: string;
+    sourceFingerprint: string;
+    finalSourceFingerprint: string | null;
+    policyFingerprint: string;
+    excluded: string[];
+    checks: {
+        id: string;
+        adapter: string;
+        project: string;
+        scope: string[];
+        status: "error" | "passed" | "failed" | "skipped" | "unavailable" | "inconclusive";
+        reason: string;
+        processes: {
+            command: {
+                executable: string;
+                args: string[];
+                cwd: string;
+                temporaryDirectory?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+            };
+            exitCode: number | null;
+            signal: string | null;
+            stdout: string;
+            stderr: string;
+            durationMs: number;
+            timedOut: boolean;
+            cancelled: boolean;
+            truncated: boolean;
+            errorCode?: string | undefined;
+        }[];
+        external?: {
+            id: string;
+            version: string;
+            sha256: string;
+            tools?: {
+                name: string;
+                version: string;
+                source: "adapter-reported";
+            }[] | undefined;
+        } | undefined;
+        tests?: {
+            total: number;
+            passed: number;
+            failed: number;
+            skipped: number;
+        } | undefined;
+        findingsComplete?: boolean | undefined;
+        runtime?: {
+            schemaVersion: 1;
+            format: "runtime-inventory";
+            producer: {
+                name: string;
+                version: string;
+            };
+            assembly: {
+                name: string;
+                environment: string;
+            };
+            sourceFingerprint: string;
+            capturedAt: string;
+            collections: {
+                kind: "routes" | "listeners" | "middleware" | "schedules" | "bindings";
+                complete: boolean;
+                ordered: boolean;
+                entries: {
+                    key: string;
+                    attributes: Record<string, string | number | boolean | string[] | null>;
+                }[];
+            }[];
+        } | undefined;
+        findings?: {
+            ruleId: string;
+            level: "error" | "warning" | "note";
+            message: string;
+            file?: string | undefined;
+            line?: number | undefined;
+        }[] | undefined;
+        environment?: {
+            names: string[];
+            fingerprint: string;
+        } | undefined;
+        tools?: {
+            name: string;
+            source: "engine-runtime" | "package-metadata" | "version-command";
+            version: string | null;
+            status: "unavailable" | "inconclusive" | "identified";
+            process?: {
+                command: {
+                    executable: string;
+                    args: string[];
+                    cwd: string;
+                    temporaryDirectory?: boolean | undefined;
+                    env?: Record<string, string> | undefined;
+                };
+                exitCode: number | null;
+                signal: string | null;
+                stdout: string;
+                stderr: string;
+                durationMs: number;
+                timedOut: boolean;
+                cancelled: boolean;
+                truncated: boolean;
+                errorCode?: string | undefined;
+            } | undefined;
+            path?: string | undefined;
+        }[] | undefined;
+    }[];
+    runId: string;
+    outcome: "passed" | "failed" | "incomplete";
+    durationMs: number;
+    sourceChanged: boolean;
+    sourceError: boolean;
+    schemaVersion: 1;
+    engineVersion: string;
+    selection?: {
+        mode: "full" | "affected";
+        reason: string;
+        changedFiles: string[];
+        selectedProjects: string[];
+        git?: {
+            baseCommit: string;
+            headCommit: string;
+            version: string;
+            worktreeId: string;
+            indexFingerprint: string;
+        } | undefined;
+    } | undefined;
+};

package/dist/src/report-validation.js

@@ -0,0 +1,27 @@
+import { reportSchema } from "./schemas.js";
+export function validatedReport(input) {
+    const report = reportSchema.parse(input);
+    const expected = report.checks.some((check) => check.status === "failed")
+        ? "failed"
+        : report.sourceChanged ||
+            report.sourceError ||
+            !report.checks.length ||
+            report.checks.some((check) => check.status !== "passed")
+            ? "incomplete"
+            : "passed";
+    if (report.outcome !== expected)
+        throw new Error("Report outcome contradicts its check evidence");
+    if ((!report.finalSourceFingerprint && !report.sourceError) ||
+        (report.finalSourceFingerprint !== null &&
+            report.finalSourceFingerprint !== report.sourceFingerprint &&
+            !report.sourceChanged))
+        throw new Error("Report source flags contradict its fingerprints");
+    const checks = new Set();
+    for (const check of report.checks) {
+        const id = JSON.stringify([check.project, check.id]);
+        if (checks.has(id))
+            throw new Error("Duplicate check identity in report");
+        checks.add(id);
+    }
+    return report;
+}

package/dist/src/review.d.ts

@@ -0,0 +1,270 @@
+import { z } from "zod";
+export declare const reviewSelectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    files: z.ZodArray<z.ZodString>;
+    topics: z.ZodArray<z.ZodEnum<{
+        "test-lifecycle": "test-lifecycle";
+        "analysis-scope": "analysis-scope";
+        "package-consumers": "package-consumers";
+        "python-imports": "python-imports";
+        "framework-assembly": "framework-assembly";
+        "execution-depth": "execution-depth";
+    }>>;
+}, z.core.$strict>;
+export declare const reviewContextSchema: z.ZodObject<{
+    contextDigest: z.ZodString;
+    schemaVersion: z.ZodLiteral<1>;
+    format: z.ZodLiteral<"review-context">;
+    channel: z.ZodLiteral<"advisory">;
+    automatedCoverage: z.ZodLiteral<false>;
+    sourceFingerprint: z.ZodString;
+    sourceTrust: z.ZodLiteral<"untrusted-source-text">;
+    selection: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        files: z.ZodArray<z.ZodString>;
+        topics: z.ZodArray<z.ZodEnum<{
+            "test-lifecycle": "test-lifecycle";
+            "analysis-scope": "analysis-scope";
+            "package-consumers": "package-consumers";
+            "python-imports": "python-imports";
+            "framework-assembly": "framework-assembly";
+            "execution-depth": "execution-depth";
+        }>>;
+    }, z.core.$strict>;
+    instructions: z.ZodString;
+    guidance: z.ZodObject<{
+        context: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            checks: z.ZodArray<z.ZodString>;
+            topics: z.ZodArray<z.ZodEnum<{
+                "test-lifecycle": "test-lifecycle";
+                "analysis-scope": "analysis-scope";
+                "package-consumers": "package-consumers";
+                "python-imports": "python-imports";
+                "framework-assembly": "framework-assembly";
+                "execution-depth": "execution-depth";
+            }>>;
+        }, z.core.$strict>;
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodLiteral<"1.0.0">;
+            title: z.ZodString;
+            triggers: z.ZodObject<{
+                checks: z.ZodArray<z.ZodString>;
+                topics: z.ZodArray<z.ZodEnum<{
+                    "test-lifecycle": "test-lifecycle";
+                    "analysis-scope": "analysis-scope";
+                    "package-consumers": "package-consumers";
+                    "python-imports": "python-imports";
+                    "framework-assembly": "framework-assembly";
+                    "execution-depth": "execution-depth";
+                }>>;
+            }, z.core.$strict>;
+            questions: z.ZodArray<z.ZodString>;
+            references: z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                url: z.ZodURL;
+            }, z.core.$strict>>;
+            matched: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                checks: z.ZodArray<z.ZodString>;
+                topics: z.ZodArray<z.ZodEnum<{
+                    "test-lifecycle": "test-lifecycle";
+                    "analysis-scope": "analysis-scope";
+                    "package-consumers": "package-consumers";
+                    "python-imports": "python-imports";
+                    "framework-assembly": "framework-assembly";
+                    "execution-depth": "execution-depth";
+                }>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        schemaVersion: z.ZodLiteral<1>;
+        engineVersion: z.ZodString;
+        channel: z.ZodLiteral<"advisory">;
+        provenance: z.ZodLiteral<"builtin-guidance-selection">;
+        catalogueDigest: z.ZodString;
+        automatedCoverage: z.ZodLiteral<false>;
+        selectionBasis: z.ZodLiteral<"exact-check-or-topic">;
+    }, z.core.$strict>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReviewContext = z.infer<typeof reviewContextSchema>;
+export declare const reviewContextSummarySchema: z.ZodObject<{
+    format: z.ZodLiteral<"review-context-summary">;
+    contextDigest: z.ZodString;
+    selectedFiles: z.ZodNumber;
+    sourceBytes: z.ZodNumber;
+    sourceIncluded: z.ZodLiteral<false>;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+    channel: z.ZodLiteral<"advisory">;
+    automatedCoverage: z.ZodLiteral<false>;
+    claimsVerified: z.ZodLiteral<false>;
+    deterministicOutcomeChanged: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export declare const reviewAssessmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    contextDigest: z.ZodString;
+    reviewer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"human">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"model">;
+        provider: z.ZodString;
+        model: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    createdAt: z.ZodISODateTime;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        elapsedMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        disposition: z.ZodEnum<{
+            reviewed: "reviewed";
+            "not-reviewed": "not-reviewed";
+        }>;
+        note: z.ZodString;
+    }, z.core.$strict>>;
+    observations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            suggestion: "suggestion";
+            concern: "concern";
+        }>;
+        claim: z.ZodString;
+        citations: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            quote: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReviewAssessment = z.infer<typeof reviewAssessmentSchema>;
+export declare const reviewReceiptSchema: z.ZodObject<{
+    assessment: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        contextDigest: z.ZodString;
+        reviewer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"model">;
+            provider: z.ZodString;
+            model: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        createdAt: z.ZodISODateTime;
+        usage: z.ZodObject<{
+            inputTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            elapsedMs: z.ZodNullable<z.ZodNumber>;
+            costUSD: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            disposition: z.ZodEnum<{
+                reviewed: "reviewed";
+                "not-reviewed": "not-reviewed";
+            }>;
+            note: z.ZodString;
+        }, z.core.$strict>>;
+        observations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            severity: z.ZodEnum<{
+                suggestion: "suggestion";
+                concern: "concern";
+            }>;
+            claim: z.ZodString;
+            citations: z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                startLine: z.ZodNumber;
+                endLine: z.ZodNumber;
+                quote: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    citationChecks: z.ZodArray<z.ZodObject<{
+        observationId: z.ZodString;
+        citation: z.ZodNumber;
+        matchesContext: z.ZodBoolean;
+    }, z.core.$strict>>;
+    provenance: z.ZodLiteral<"imported-review-assessment">;
+    contextDigest: z.ZodString;
+    freshness: z.ZodEnum<{
+        current: "current";
+        stale: "stale";
+    }>;
+    usageProvenance: z.ZodLiteral<"reviewer-declared">;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        elapsedMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    coverage: z.ZodObject<{
+        selected: z.ZodNumber;
+        declaredReviewed: z.ZodNumber;
+        declaredNotReviewed: z.ZodNumber;
+        unaccounted: z.ZodNumber;
+    }, z.core.$strict>;
+    citations: z.ZodObject<{
+        matched: z.ZodNumber;
+        unmatched: z.ZodNumber;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+    channel: z.ZodLiteral<"advisory">;
+    automatedCoverage: z.ZodLiteral<false>;
+    claimsVerified: z.ZodLiteral<false>;
+    deterministicOutcomeChanged: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export declare const reviewReceiptSummarySchema: z.ZodObject<{
+    reviewerKind: z.ZodEnum<{
+        human: "human";
+        model: "model";
+    }>;
+    observations: z.ZodNumber;
+    provenance: z.ZodLiteral<"imported-review-assessment">;
+    contextDigest: z.ZodString;
+    freshness: z.ZodEnum<{
+        current: "current";
+        stale: "stale";
+    }>;
+    usageProvenance: z.ZodLiteral<"reviewer-declared">;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        elapsedMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    coverage: z.ZodObject<{
+        selected: z.ZodNumber;
+        declaredReviewed: z.ZodNumber;
+        declaredNotReviewed: z.ZodNumber;
+        unaccounted: z.ZodNumber;
+    }, z.core.$strict>;
+    citations: z.ZodObject<{
+        matched: z.ZodNumber;
+        unmatched: z.ZodNumber;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+    channel: z.ZodLiteral<"advisory">;
+    automatedCoverage: z.ZodLiteral<false>;
+    claimsVerified: z.ZodLiteral<false>;
+    deterministicOutcomeChanged: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export type ReviewReceipt = z.infer<typeof reviewReceiptSchema>;
+export declare function createReviewContext(root: string, input: unknown): Promise<ReviewContext>;
+export declare function projectReviewContext(context: ReviewContext, sourceEnabled: boolean): Record<string, unknown>;
+export declare function receiveReview(root: string, contextInput: unknown, assessmentInput: unknown): Promise<ReviewReceipt>;
+export declare function projectReviewReceipt(report: ReviewReceipt, detailed: boolean): Record<string, unknown>;