@actuarial-ts/agents 0.15.0 → 0.16.0

package/dist/review.d.ts

@@ -0,0 +1,729 @@
+/**
+ * Trusted agent boundary for a complete analytical review.
+ *
+ * The model can select only opaque identifiers from a host-owned catalog. It
+ * cannot author a plan, formula, source location, financial definition, input
+ * payload or tenant id. The host resolves those identifiers, performs the
+ * calculation, and returns a current-process VerifiedReviewSnapshot together
+ * with an exact scope receipt. This module validates that receipt before
+ * projecting review evidence back to the model.
+ *
+ * Manual priors, factor overrides, selections, waivers and adopted ranges are
+ * separate judgment gates. They reuse createJudgmentChain so every adopted
+ * decision suspends, requires a rationale, reads actor identity from trusted
+ * request context and enters the compliance ledger.
+ */
+import { type AnalysisReference } from "@actuarial-ts/core";
+import { type ReviewSnapshotReadiness, type VerifiedReviewSnapshot } from "@actuarial-ts/compliance";
+import { z } from "zod";
+import { type CreateJudgmentChainOptions, type JudgmentApplication, type JudgmentChainWorkflow, type JudgmentGateContext } from "./judgment.js";
+import { type DefinedActuarialTool, type ToolEnvelopeFailure } from "./tools.js";
+export declare const REVIEW_AGENT_LIMITS: Readonly<{
+    maximumPresets: 64;
+    maximumMethods: 64;
+    maximumAssumptions: 256;
+    maximumOptions: 128;
+    maximumJudgments: 128;
+    maximumCandidatesPerJudgment: 128;
+    maximumEligibilityItems: 640;
+    maximumReasonCodes: 64;
+    maximumAffectedCoordinates: 1000;
+    maximumRemedies: 64;
+    maximumTextCharacters: 20000;
+}>;
+export declare const reviewAgentDiscoveryInputSchema: z.ZodObject<{
+    runPresetId: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    runPresetId: string;
+}, {
+    runPresetId: string;
+}>;
+export declare const reviewAgentExecutionInputSchema: z.ZodObject<{
+    runPresetId: z.ZodEffects<z.ZodString, string, string>;
+    planId: z.ZodEffects<z.ZodString, string, string>;
+    inputId: z.ZodEffects<z.ZodString, string, string>;
+    methodIds: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+    assumptionIds: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+    optionIds: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+}, "strict", z.ZodTypeAny, {
+    runPresetId: string;
+    planId: string;
+    inputId: string;
+    methodIds: string[];
+    assumptionIds: string[];
+    optionIds: string[];
+}, {
+    runPresetId: string;
+    planId: string;
+    inputId: string;
+    methodIds: string[];
+    assumptionIds: string[];
+    optionIds: string[];
+}>;
+export type ReviewAgentDiscoveryInput = z.output<typeof reviewAgentDiscoveryInputSchema>;
+export type ReviewAgentExecutionInput = z.output<typeof reviewAgentExecutionInputSchema>;
+export declare const REVIEW_AGENT_ELIGIBILITY_STATUSES: readonly ["supported", "supported-with-warnings", "requires-input", "unsupported"];
+export type ReviewAgentEligibilityStatus = (typeof REVIEW_AGENT_ELIGIBILITY_STATUSES)[number];
+export declare const REVIEW_AGENT_SUBJECT_KINDS: readonly ["plan", "input", "method", "assumption", "option"];
+export type ReviewAgentSubjectKind = (typeof REVIEW_AGENT_SUBJECT_KINDS)[number];
+export interface ReviewAgentEligibility {
+    readonly kind: ReviewAgentSubjectKind;
+    readonly id: string;
+    readonly status: ReviewAgentEligibilityStatus;
+    readonly reasonCodes: readonly string[];
+    readonly affectedCoordinates: readonly string[];
+    readonly remedies: readonly string[];
+}
+export declare const reviewAgentEligibilitySchema: z.ZodType<ReviewAgentEligibility>;
+export declare const REVIEW_AGENT_JUDGMENT_KINDS: readonly ["manual-prior", "factor-override", "manual-selection", "requirement-waiver", "adopted-range"];
+export type ReviewAgentJudgmentKind = (typeof REVIEW_AGENT_JUDGMENT_KINDS)[number];
+export interface ReviewAgentCatalogItem {
+    readonly id: string;
+    readonly label: string;
+}
+export interface ReviewAgentMethod extends ReviewAgentCatalogItem {
+    /** Exact node and operation which must occur in the returned review plan. */
+    readonly nodeId: string;
+    readonly operation: string;
+}
+export interface ReviewAgentAssumption extends ReviewAgentCatalogItem {
+    readonly reference: AnalysisReference;
+}
+export interface ReviewAgentJudgmentDescriptor {
+    readonly id: string;
+    readonly kind: ReviewAgentJudgmentKind;
+    readonly targetId: string;
+    readonly candidateIds: readonly string[];
+}
+export interface ReviewAgentPresetInspectionInput {
+    readonly tenantId: string;
+    readonly runPresetId: string;
+    readonly presetVersion: string;
+}
+export interface ReviewAgentPresetExecutionInput extends ReviewAgentPresetInspectionInput {
+    readonly requestIdentity: string;
+    readonly planId: string;
+    readonly inputId: string;
+    readonly methodIds: readonly string[];
+    readonly assumptionIds: readonly string[];
+    readonly optionIds: readonly string[];
+}
+export interface ReviewAgentExecutionScope extends ReviewAgentPresetExecutionInput {
+}
+export interface ReviewAgentExecutionReceipt {
+    readonly scope: ReviewAgentExecutionScope;
+    /** Must retain its current-process authenticity brand. Copies are refused. */
+    readonly snapshot: VerifiedReviewSnapshot;
+}
+export interface ReviewAgentRunPreset {
+    readonly id: string;
+    readonly version: string;
+    readonly label: string;
+    readonly plan: {
+        readonly id: string;
+        readonly reference: AnalysisReference;
+    };
+    readonly input: {
+        readonly id: string;
+        /** Exact input/scope reference which must occur in the verified run. */
+        readonly reference: AnalysisReference;
+    };
+    readonly profile: {
+        readonly id: string;
+        readonly version: string;
+    };
+    readonly methods: readonly ReviewAgentMethod[];
+    readonly assumptions: readonly ReviewAgentAssumption[];
+    readonly options: readonly ReviewAgentCatalogItem[];
+    readonly judgments: readonly ReviewAgentJudgmentDescriptor[];
+    /** Returns one contextual eligibility item for every exposed catalog item. */
+    readonly inspect: (input: ReviewAgentPresetInspectionInput) => Promise<readonly ReviewAgentEligibility[]>;
+    readonly execute: (input: ReviewAgentPresetExecutionInput) => Promise<ReviewAgentExecutionReceipt>;
+}
+export declare const reviewAgentDiscoveryResultSchema: z.ZodUnion<[z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        runPresetId: z.ZodEffects<z.ZodString, string, string>;
+        presetVersion: z.ZodEffects<z.ZodString, string, string>;
+        label: z.ZodEffects<z.ZodString, string, string>;
+        planId: z.ZodEffects<z.ZodString, string, string>;
+        inputId: z.ZodEffects<z.ZodString, string, string>;
+        profile: z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            version: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            version: string;
+        }, {
+            id: string;
+            version: string;
+        }>;
+        methods: z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            label: z.ZodEffects<z.ZodString, string, string>;
+        } & {
+            nodeId: z.ZodEffects<z.ZodString, string, string>;
+            operation: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            label: string;
+            operation: string;
+            nodeId: string;
+        }, {
+            id: string;
+            label: string;
+            operation: string;
+            nodeId: string;
+        }>, "many">;
+        assumptions: z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            label: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            label: string;
+        }, {
+            id: string;
+            label: string;
+        }>, "many">;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            label: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            label: string;
+        }, {
+            id: string;
+            label: string;
+        }>, "many">;
+        judgments: z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            kind: z.ZodEnum<["manual-prior", "factor-override", "manual-selection", "requirement-waiver", "adopted-range"]>;
+            targetId: z.ZodEffects<z.ZodString, string, string>;
+            candidateIds: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            kind: "manual-prior" | "factor-override" | "manual-selection" | "requirement-waiver" | "adopted-range";
+            targetId: string;
+            candidateIds: string[];
+        }, {
+            id: string;
+            kind: "manual-prior" | "factor-override" | "manual-selection" | "requirement-waiver" | "adopted-range";
+            targetId: string;
+            candidateIds: string[];
+        }>, "many">;
+        eligibility: z.ZodArray<z.ZodType<ReviewAgentEligibility, z.ZodTypeDef, ReviewAgentEligibility>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        options: {
+            id: string;
+            label: string;
+        }[];
+        runPresetId: string;
+        label: string;
+        planId: string;
+        inputId: string;
+        presetVersion: string;
+        profile: {
+            id: string;
+            version: string;
+        };
+        methods: {
+            id: string;
+            label: string;
+            operation: string;
+            nodeId: string;
+        }[];
+        assumptions: {
+            id: string;
+            label: string;
+        }[];
+        judgments: {
+            id: string;
+            kind: "manual-prior" | "factor-override" | "manual-selection" | "requirement-waiver" | "adopted-range";
+            targetId: string;
+            candidateIds: string[];
+        }[];
+        eligibility: ReviewAgentEligibility[];
+    }, {
+        options: {
+            id: string;
+            label: string;
+        }[];
+        runPresetId: string;
+        label: string;
+        planId: string;
+        inputId: string;
+        presetVersion: string;
+        profile: {
+            id: string;
+            version: string;
+        };
+        methods: {
+            id: string;
+            label: string;
+            operation: string;
+            nodeId: string;
+        }[];
+        assumptions: {
+            id: string;
+            label: string;
+        }[];
+        judgments: {
+            id: string;
+            kind: "manual-prior" | "factor-override" | "manual-selection" | "requirement-waiver" | "adopted-range";
+            targetId: string;
+            candidateIds: string[];
+        }[];
+        eligibility: ReviewAgentEligibility[];
+    }>;
+}, "strict", z.ZodTypeAny, {
+    data: {
+        options: {
+            id: string;
+            label: string;
+        }[];
+        runPresetId: string;
+        label: string;
+        planId: string;
+        inputId: string;
+        presetVersion: string;
+        profile: {
+            id: string;
+            version: string;
+        };
+        methods: {
+            id: string;
+            label: string;
+            operation: string;
+            nodeId: string;
+        }[];
+        assumptions: {
+            id: string;
+            label: string;
+        }[];
+        judgments: {
+            id: string;
+            kind: "manual-prior" | "factor-override" | "manual-selection" | "requirement-waiver" | "adopted-range";
+            targetId: string;
+            candidateIds: string[];
+        }[];
+        eligibility: ReviewAgentEligibility[];
+    };
+    success: true;
+}, {
+    data: {
+        options: {
+            id: string;
+            label: string;
+        }[];
+        runPresetId: string;
+        label: string;
+        planId: string;
+        inputId: string;
+        presetVersion: string;
+        profile: {
+            id: string;
+            version: string;
+        };
+        methods: {
+            id: string;
+            label: string;
+            operation: string;
+            nodeId: string;
+        }[];
+        assumptions: {
+            id: string;
+            label: string;
+        }[];
+        judgments: {
+            id: string;
+            kind: "manual-prior" | "factor-override" | "manual-selection" | "requirement-waiver" | "adopted-range";
+            targetId: string;
+            candidateIds: string[];
+        }[];
+        eligibility: ReviewAgentEligibility[];
+    };
+    success: true;
+}>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    error: {
+        code: string;
+        message: string;
+    };
+    success: false;
+}, {
+    error: {
+        code: string;
+        message: string;
+    };
+    success: false;
+}>]>;
+export declare const reviewAgentExecutionResultSchema: z.ZodUnion<[z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        runPresetId: z.ZodEffects<z.ZodString, string, string>;
+        presetVersion: z.ZodEffects<z.ZodString, string, string>;
+        requestIdentity: z.ZodString;
+        planId: z.ZodEffects<z.ZodString, string, string>;
+        inputId: z.ZodEffects<z.ZodString, string, string>;
+        methodIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        assumptionIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        optionIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        snapshot: z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            version: z.ZodEffects<z.ZodString, string, string>;
+            reference: z.ZodObject<{
+                kind: z.ZodEnum<["source", "scope", "amount-basis", "exposure-basis", "period", "assumption", "result", "adjustment", "context"]>;
+                id: z.ZodEffects<z.ZodString, string, string>;
+                version: z.ZodEffects<z.ZodString, string, string>;
+                contentIdentity: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                id: string;
+                kind: "source" | "scope" | "period" | "amount-basis" | "exposure-basis" | "assumption" | "result" | "adjustment" | "context";
+                version: string;
+                contentIdentity: string;
+            }, {
+                id: string;
+                kind: "source" | "scope" | "period" | "amount-basis" | "exposure-basis" | "assumption" | "result" | "adjustment" | "context";
+                version: string;
+                contentIdentity: string;
+            }>;
+            profile: z.ZodObject<{
+                id: z.ZodEffects<z.ZodString, string, string>;
+                version: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                id: string;
+                version: string;
+            }, {
+                id: string;
+                version: string;
+            }>;
+            readiness: z.ZodType<ReviewSnapshotReadiness, z.ZodTypeDef, ReviewSnapshotReadiness>;
+            limitations: z.ZodArray<z.ZodObject<{
+                id: z.ZodEffects<z.ZodString, string, string>;
+                disposition: z.ZodEnum<["unresolved", "accepted"]>;
+            }, "strict", z.ZodTypeAny, {
+                id: string;
+                disposition: "unresolved" | "accepted";
+            }, {
+                id: string;
+                disposition: "unresolved" | "accepted";
+            }>, "many">;
+            findingCodes: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+            assurance: z.ZodObject<{
+                frozen: z.ZodLiteral<true>;
+                review: z.ZodLiteral<"not-attested">;
+                publication: z.ZodLiteral<"not-reported">;
+            }, "strict", z.ZodTypeAny, {
+                review: "not-attested";
+                publication: "not-reported";
+                frozen: true;
+            }, {
+                review: "not-attested";
+                publication: "not-reported";
+                frozen: true;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            version: string;
+            reference: {
+                id: string;
+                kind: "source" | "scope" | "period" | "amount-basis" | "exposure-basis" | "assumption" | "result" | "adjustment" | "context";
+                version: string;
+                contentIdentity: string;
+            };
+            assurance: {
+                review: "not-attested";
+                publication: "not-reported";
+                frozen: true;
+            };
+            profile: {
+                id: string;
+                version: string;
+            };
+            readiness: ReviewSnapshotReadiness;
+            limitations: {
+                id: string;
+                disposition: "unresolved" | "accepted";
+            }[];
+            findingCodes: string[];
+        }, {
+            id: string;
+            version: string;
+            reference: {
+                id: string;
+                kind: "source" | "scope" | "period" | "amount-basis" | "exposure-basis" | "assumption" | "result" | "adjustment" | "context";
+                version: string;
+                contentIdentity: string;
+            };
+            assurance: {
+                review: "not-attested";
+                publication: "not-reported";
+                frozen: true;
+            };
+            profile: {
+                id: string;
+                version: string;
+            };
+            readiness: ReviewSnapshotReadiness;
+            limitations: {
+                id: string;
+                disposition: "unresolved" | "accepted";
+            }[];
+            findingCodes: string[];
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        runPresetId: string;
+        planId: string;
+        inputId: string;
+        methodIds: string[];
+        assumptionIds: string[];
+        optionIds: string[];
+        presetVersion: string;
+        requestIdentity: string;
+        snapshot: {
+            id: string;
+            version: string;
+            reference: {
+                id: string;
+                kind: "source" | "scope" | "period" | "amount-basis" | "exposure-basis" | "assumption" | "result" | "adjustment" | "context";
+                version: string;
+                contentIdentity: string;
+            };
+            assurance: {
+                review: "not-attested";
+                publication: "not-reported";
+                frozen: true;
+            };
+            profile: {
+                id: string;
+                version: string;
+            };
+            readiness: ReviewSnapshotReadiness;
+            limitations: {
+                id: string;
+                disposition: "unresolved" | "accepted";
+            }[];
+            findingCodes: string[];
+        };
+    }, {
+        runPresetId: string;
+        planId: string;
+        inputId: string;
+        methodIds: string[];
+        assumptionIds: string[];
+        optionIds: string[];
+        presetVersion: string;
+        requestIdentity: string;
+        snapshot: {
+            id: string;
+            version: string;
+            reference: {
+                id: string;
+                kind: "source" | "scope" | "period" | "amount-basis" | "exposure-basis" | "assumption" | "result" | "adjustment" | "context";
+                version: string;
+                contentIdentity: string;
+            };
+            assurance: {
+                review: "not-attested";
+                publication: "not-reported";
+                frozen: true;
+            };
+            profile: {
+                id: string;
+                version: string;
+            };
+            readiness: ReviewSnapshotReadiness;
+            limitations: {
+                id: string;
+                disposition: "unresolved" | "accepted";
+            }[];
+            findingCodes: string[];
+        };
+    }>;
+}, "strict", z.ZodTypeAny, {
+    data: {
+        runPresetId: string;
+        planId: string;
+        inputId: string;
+        methodIds: string[];
+        assumptionIds: string[];
+        optionIds: string[];
+        presetVersion: string;
+        requestIdentity: string;
+        snapshot: {
+            id: string;
+            version: string;
+            reference: {
+                id: string;
+                kind: "source" | "scope" | "period" | "amount-basis" | "exposure-basis" | "assumption" | "result" | "adjustment" | "context";
+                version: string;
+                contentIdentity: string;
+            };
+            assurance: {
+                review: "not-attested";
+                publication: "not-reported";
+                frozen: true;
+            };
+            profile: {
+                id: string;
+                version: string;
+            };
+            readiness: ReviewSnapshotReadiness;
+            limitations: {
+                id: string;
+                disposition: "unresolved" | "accepted";
+            }[];
+            findingCodes: string[];
+        };
+    };
+    success: true;
+}, {
+    data: {
+        runPresetId: string;
+        planId: string;
+        inputId: string;
+        methodIds: string[];
+        assumptionIds: string[];
+        optionIds: string[];
+        presetVersion: string;
+        requestIdentity: string;
+        snapshot: {
+            id: string;
+            version: string;
+            reference: {
+                id: string;
+                kind: "source" | "scope" | "period" | "amount-basis" | "exposure-basis" | "assumption" | "result" | "adjustment" | "context";
+                version: string;
+                contentIdentity: string;
+            };
+            assurance: {
+                review: "not-attested";
+                publication: "not-reported";
+                frozen: true;
+            };
+            profile: {
+                id: string;
+                version: string;
+            };
+            readiness: ReviewSnapshotReadiness;
+            limitations: {
+                id: string;
+                disposition: "unresolved" | "accepted";
+            }[];
+            findingCodes: string[];
+        };
+    };
+    success: true;
+}>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    error: {
+        code: string;
+        message: string;
+    };
+    success: false;
+}, {
+    error: {
+        code: string;
+        message: string;
+    };
+    success: false;
+}>]>;
+export type ReviewAgentDiscoverySuccess = Extract<z.output<typeof reviewAgentDiscoveryResultSchema>, {
+    success: true;
+}>;
+export type ReviewAgentExecutionSuccess = Extract<z.output<typeof reviewAgentExecutionResultSchema>, {
+    success: true;
+}>;
+export interface CreateReviewAgentToolsInput {
+    readonly runPresets: readonly ReviewAgentRunPreset[];
+    readonly discoveryId?: string;
+    readonly executionId?: string;
+    readonly tenantContextKey?: string;
+}
+export interface ReviewAgentTools {
+    readonly discover: DefinedActuarialTool<z.input<typeof reviewAgentDiscoveryInputSchema>, z.output<typeof reviewAgentDiscoveryResultSchema>>;
+    readonly execute: DefinedActuarialTool<z.input<typeof reviewAgentExecutionInputSchema>, z.output<typeof reviewAgentExecutionResultSchema>>;
+}
+/** Builds the paired read-only tools over one immutable host catalog. */
+export declare function createReviewAgentTools(input: CreateReviewAgentToolsInput): ReviewAgentTools;
+export interface ReviewAgentJudgmentDecision {
+    readonly decision: "adopt" | "decline";
+    readonly candidateId: string | null;
+    readonly rationale: string;
+    readonly actor?: "actuary" | "agent";
+}
+export interface ReviewAgentJudgmentContext {
+    readonly tenantId: string;
+    readonly presetId: string;
+    readonly presetVersion: string;
+    readonly gateId: string;
+    readonly kind: ReviewAgentJudgmentKind;
+    readonly targetId: string;
+    readonly decisions: JudgmentGateContext["decisions"];
+    readonly trail: JudgmentGateContext["trail"];
+}
+export interface ReviewAgentJudgmentGateSpec {
+    readonly id: string;
+    readonly stage: string;
+    readonly presetId: string;
+    readonly presetVersion: string;
+    readonly kind: ReviewAgentJudgmentKind;
+    readonly targetId: string;
+    readonly allowedCandidateIds: readonly string[];
+    readonly gatherEvidence: (context: ReviewAgentJudgmentContext) => Promise<{
+        readonly recommendation: string;
+        readonly evidence: unknown;
+    }> | {
+        readonly recommendation: string;
+        readonly evidence: unknown;
+    };
+    readonly applyDecision: (context: ReviewAgentJudgmentContext, decision: ReviewAgentJudgmentDecision) => Promise<JudgmentApplication>;
+}
+export interface CreateReviewAgentJudgmentChainInput {
+    readonly id: string;
+    readonly gates: readonly ReviewAgentJudgmentGateSpec[];
+    readonly now: () => string;
+    readonly tenantContextKey?: string;
+    readonly onComplete?: CreateJudgmentChainOptions["onComplete"];
+}
+/**
+ * Creates a resumable review-judgment workflow. The fixed schema admits only
+ * an allowlisted candidate ID and a documented adopt/decline decision. The
+ * wrapper always records the review judgment in the ledger, even when the
+ * host application has no additional assumption entries to append.
+ */
+export declare function createReviewAgentJudgmentChain(input: CreateReviewAgentJudgmentChainInput): JudgmentChainWorkflow;
+/** Ready-to-run offline eval cases for the default review tool IDs. */
+export declare const REVIEW_AGENT_TOOL_SELECTION_CASES: readonly [{
+    readonly id: "discover-approved-review";
+    readonly prompt: "Show which approved review methods and assumptions are eligible before calculating anything.";
+    readonly expectTools: readonly ["discover-approved-review"];
+}, {
+    readonly id: "run-approved-review";
+    readonly prompt: "Run the approved review I selected and return its verified readiness evidence.";
+    readonly expectTools: readonly ["run-approved-review"];
+}];
+export type ReviewAgentToolResult = ReviewAgentDiscoverySuccess | ReviewAgentExecutionSuccess | ToolEnvelopeFailure;
+//# sourceMappingURL=review.d.ts.map