@actuarial-ts/agents 0.14.0 → 0.16.0

package/dist/review.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review.d.ts","sourceRoot":"","sources":["../src/review.ts"],"names":[],"mappings":"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"}

package/dist/review.js

@@ -0,0 +1,674 @@
+/**
+ * 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 { canonicalJson, fnv1a64, isDiagnosticToken, } from "@actuarial-ts/core";
+import { analysisReferenceSchema } from "@actuarial-ts/data";
+import { assertVerifiedReviewSnapshot, reviewEvidenceLinkSchema, } from "@actuarial-ts/compliance";
+import { z } from "zod";
+import { AgentsError } from "./errors.js";
+import { createJudgmentChain, } from "./judgment.js";
+import { defineActuarialTool, tenantOf, } from "./tools.js";
+// ---------------------------------------------------------------------------
+// Public limits and schemas
+export const REVIEW_AGENT_LIMITS = Object.freeze({
+    maximumPresets: 64,
+    maximumMethods: 64,
+    maximumAssumptions: 256,
+    maximumOptions: 128,
+    maximumJudgments: 128,
+    maximumCandidatesPerJudgment: 128,
+    maximumEligibilityItems: 640,
+    maximumReasonCodes: 64,
+    maximumAffectedCoordinates: 1_000,
+    maximumRemedies: 64,
+    maximumTextCharacters: 20_000,
+});
+const token = z
+    .string()
+    .max(REVIEW_AGENT_LIMITS.maximumTextCharacters)
+    .refine(isDiagnosticToken);
+const tag = z.string().regex(/^fnv1a64-jcs-v1:[0-9a-f]{16}$/);
+const text = z
+    .string()
+    .max(REVIEW_AGENT_LIMITS.maximumTextCharacters)
+    .refine((value) => value.trim().length > 0, "Expected nonblank text");
+const uniqueTokens = (maximum, minimum = 0) => z
+    .array(token)
+    .min(minimum)
+    .max(maximum)
+    .refine((values) => new Set(values).size === values.length, {
+    message: "Identifiers must be distinct",
+});
+export const reviewAgentDiscoveryInputSchema = z
+    .object({ runPresetId: token })
+    .strict();
+export const reviewAgentExecutionInputSchema = z
+    .object({
+    runPresetId: token,
+    planId: token,
+    inputId: token,
+    methodIds: uniqueTokens(REVIEW_AGENT_LIMITS.maximumMethods, 1),
+    assumptionIds: uniqueTokens(REVIEW_AGENT_LIMITS.maximumAssumptions),
+    optionIds: uniqueTokens(REVIEW_AGENT_LIMITS.maximumOptions),
+})
+    .strict();
+export const REVIEW_AGENT_ELIGIBILITY_STATUSES = [
+    "supported",
+    "supported-with-warnings",
+    "requires-input",
+    "unsupported",
+];
+export const REVIEW_AGENT_SUBJECT_KINDS = [
+    "plan",
+    "input",
+    "method",
+    "assumption",
+    "option",
+];
+export const reviewAgentEligibilitySchema = z
+    .object({
+    kind: z.enum(REVIEW_AGENT_SUBJECT_KINDS),
+    id: token,
+    status: z.enum(REVIEW_AGENT_ELIGIBILITY_STATUSES),
+    reasonCodes: uniqueTokens(REVIEW_AGENT_LIMITS.maximumReasonCodes),
+    affectedCoordinates: z
+        .array(text)
+        .max(REVIEW_AGENT_LIMITS.maximumAffectedCoordinates),
+    remedies: z.array(text).max(REVIEW_AGENT_LIMITS.maximumRemedies),
+})
+    .strict();
+export const REVIEW_AGENT_JUDGMENT_KINDS = [
+    "manual-prior",
+    "factor-override",
+    "manual-selection",
+    "requirement-waiver",
+    "adopted-range",
+];
+// ---------------------------------------------------------------------------
+// Result contracts
+const failureSchema = z
+    .object({
+    success: z.literal(false),
+    error: z.object({ code: z.string(), message: z.string() }).strict(),
+})
+    .strict();
+const catalogItemSchema = z.object({ id: token, label: text }).strict();
+const methodSchema = catalogItemSchema
+    .extend({ nodeId: token, operation: token })
+    .strict();
+const judgmentDescriptorSchema = z
+    .object({
+    id: token,
+    kind: z.enum(REVIEW_AGENT_JUDGMENT_KINDS),
+    targetId: token,
+    candidateIds: uniqueTokens(REVIEW_AGENT_LIMITS.maximumCandidatesPerJudgment),
+})
+    .strict();
+export const reviewAgentDiscoveryResultSchema = z.union([
+    z
+        .object({
+        success: z.literal(true),
+        data: z
+            .object({
+            runPresetId: token,
+            presetVersion: token,
+            label: text,
+            planId: token,
+            inputId: token,
+            profile: z.object({ id: token, version: token }).strict(),
+            methods: z.array(methodSchema).max(REVIEW_AGENT_LIMITS.maximumMethods),
+            assumptions: z
+                .array(catalogItemSchema)
+                .max(REVIEW_AGENT_LIMITS.maximumAssumptions),
+            options: z
+                .array(catalogItemSchema)
+                .max(REVIEW_AGENT_LIMITS.maximumOptions),
+            judgments: z
+                .array(judgmentDescriptorSchema)
+                .max(REVIEW_AGENT_LIMITS.maximumJudgments),
+            eligibility: z
+                .array(reviewAgentEligibilitySchema)
+                .max(REVIEW_AGENT_LIMITS.maximumEligibilityItems),
+        })
+            .strict(),
+    })
+        .strict(),
+    failureSchema,
+]);
+const readinessCheckSchema = z
+    .object({
+    id: text,
+    status: z.enum(["satisfied", "unresolved", "waived", "not-applicable"]),
+    message: text,
+    node: text.nullable(),
+    coordinates: z.array(text).max(1_000),
+    evidence: z.array(reviewEvidenceLinkSchema).max(1_024).optional(),
+    facet: z.enum(["validation", "selection", "review"]).optional(),
+})
+    .strict();
+const readinessFacetsSchema = z
+    .object({
+    calculation: z.enum(["satisfied", "unresolved"]),
+    validation: z.enum(["satisfied", "unresolved", "not-applicable"]),
+    selection: z.enum(["satisfied", "unresolved", "not-applicable"]),
+    review: z.enum(["satisfied", "unresolved", "not-applicable"]),
+    externalRelease: z.literal("not-reported"),
+})
+    .strict();
+const readinessSchema = z
+    .object({
+    status: z.enum(["requirements-satisfied", "unresolved"]),
+    checks: z.array(readinessCheckSchema),
+    assurance: z.enum([
+        "declared-minimum-requirements-only",
+        "caller-defined-versioned-profile",
+    ]),
+    stage: z
+        .enum(["exploratory", "calculated", "validated", "selected", "published"])
+        .optional(),
+    facets: readinessFacetsSchema.optional(),
+})
+    .strict();
+export const reviewAgentExecutionResultSchema = z.union([
+    z
+        .object({
+        success: z.literal(true),
+        data: z
+            .object({
+            runPresetId: token,
+            presetVersion: token,
+            requestIdentity: tag,
+            planId: token,
+            inputId: token,
+            methodIds: z.array(token).max(REVIEW_AGENT_LIMITS.maximumMethods),
+            assumptionIds: z
+                .array(token)
+                .max(REVIEW_AGENT_LIMITS.maximumAssumptions),
+            optionIds: z.array(token).max(REVIEW_AGENT_LIMITS.maximumOptions),
+            snapshot: z
+                .object({
+                id: text,
+                version: text,
+                reference: analysisReferenceSchema,
+                profile: z.object({ id: text, version: text }).strict(),
+                readiness: readinessSchema,
+                limitations: z.array(z
+                    .object({
+                    id: text,
+                    disposition: z.enum(["unresolved", "accepted"]),
+                })
+                    .strict()),
+                findingCodes: z.array(text),
+                assurance: z
+                    .object({
+                    frozen: z.literal(true),
+                    review: z.literal("not-attested"),
+                    publication: z.literal("not-reported"),
+                })
+                    .strict(),
+            })
+                .strict(),
+        })
+            .strict(),
+    })
+        .strict(),
+    failureSchema,
+]);
+const presetMetadataSchema = z
+    .object({
+    id: token,
+    version: token,
+    label: text,
+    plan: z.object({ id: token, reference: analysisReferenceSchema }).strict(),
+    input: z.object({ id: token, reference: analysisReferenceSchema }).strict(),
+    profile: z.object({ id: token, version: token }).strict(),
+    methods: z
+        .array(methodSchema)
+        .min(1)
+        .max(REVIEW_AGENT_LIMITS.maximumMethods),
+    assumptions: z
+        .array(catalogItemSchema.extend({ reference: analysisReferenceSchema }).strict())
+        .max(REVIEW_AGENT_LIMITS.maximumAssumptions),
+    options: z
+        .array(catalogItemSchema)
+        .max(REVIEW_AGENT_LIMITS.maximumOptions),
+    judgments: z
+        .array(judgmentDescriptorSchema)
+        .max(REVIEW_AGENT_LIMITS.maximumJudgments),
+})
+    .strict();
+function distinct(values, message) {
+    if (new Set(values).size !== values.length)
+        throw new AgentsError("BAD_REVIEW_CATALOG", message);
+}
+function ownPreset(value) {
+    if (typeof value?.inspect !== "function" || typeof value?.execute !== "function")
+        throw new AgentsError("BAD_REVIEW_CATALOG", "Every review preset requires host inspect and execute functions");
+    const parsed = presetMetadataSchema.safeParse({
+        id: value.id,
+        version: value.version,
+        label: value.label,
+        plan: value.plan,
+        input: value.input,
+        profile: value.profile,
+        methods: value.methods,
+        assumptions: value.assumptions,
+        options: value.options,
+        judgments: value.judgments,
+    });
+    if (!parsed.success)
+        throw new AgentsError("BAD_REVIEW_CATALOG", `Invalid review preset: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+    const metadata = parsed.data;
+    distinct(metadata.methods.map((item) => item.id), `Preset ${metadata.id} has duplicate method IDs`);
+    distinct(metadata.methods.map((item) => item.nodeId), `Preset ${metadata.id} maps two methods to one node`);
+    distinct(metadata.assumptions.map((item) => item.id), `Preset ${metadata.id} has duplicate assumption IDs`);
+    distinct(metadata.assumptions.map((item) => canonicalJson(item.reference)), `Preset ${metadata.id} maps more than one assumption ID to the same reference`);
+    distinct(metadata.options.map((item) => item.id), `Preset ${metadata.id} has duplicate option IDs`);
+    distinct(metadata.judgments.map((item) => item.id), `Preset ${metadata.id} has duplicate judgment IDs`);
+    for (const assumption of metadata.assumptions)
+        if (assumption.reference.kind !== "assumption")
+            throw new AgentsError("BAD_REVIEW_CATALOG", `Preset ${metadata.id} assumption ${assumption.id} must carry an assumption reference`);
+    if (metadata.plan.reference.kind !== "result")
+        throw new AgentsError("BAD_REVIEW_CATALOG", `Preset ${metadata.id} plan reference must be a result reference`);
+    return Object.freeze({
+        ...metadata,
+        methods: Object.freeze(metadata.methods.map((item) => Object.freeze(item))),
+        assumptions: Object.freeze(metadata.assumptions.map((item) => Object.freeze(item))),
+        options: Object.freeze(metadata.options.map((item) => Object.freeze(item))),
+        judgments: Object.freeze(metadata.judgments.map((item) => Object.freeze(item))),
+        inspect: value.inspect,
+        execute: value.execute,
+    });
+}
+function catalogOf(values) {
+    if (!Array.isArray(values) || values.length === 0 || values.length > REVIEW_AGENT_LIMITS.maximumPresets)
+        throw new AgentsError("BAD_REVIEW_CATALOG", "Review tools require a nonempty bounded preset catalog");
+    const result = new Map();
+    for (const raw of values) {
+        const preset = ownPreset(raw);
+        if (result.has(preset.id))
+            throw new AgentsError("BAD_REVIEW_CATALOG", `Duplicate review preset ${preset.id}`);
+        result.set(preset.id, preset);
+    }
+    return result;
+}
+function subjectKey(kind, id) {
+    return `${kind}\u0000${id}`;
+}
+function expectedSubjects(preset) {
+    return new Set([
+        subjectKey("plan", preset.plan.id),
+        subjectKey("input", preset.input.id),
+        ...preset.methods.map((item) => subjectKey("method", item.id)),
+        ...preset.assumptions.map((item) => subjectKey("assumption", item.id)),
+        ...preset.options.map((item) => subjectKey("option", item.id)),
+    ]);
+}
+async function inspectPreset(preset, tenantId) {
+    const parsed = z
+        .array(reviewAgentEligibilitySchema)
+        .max(REVIEW_AGENT_LIMITS.maximumEligibilityItems)
+        .safeParse(await preset.inspect({
+        tenantId,
+        runPresetId: preset.id,
+        presetVersion: preset.version,
+    }));
+    if (!parsed.success)
+        throw new AgentsError("REVIEW_ELIGIBILITY_MISMATCH", "Review preset returned malformed contextual eligibility");
+    const expected = expectedSubjects(preset);
+    const actual = parsed.data.map((item) => subjectKey(item.kind, item.id));
+    if (new Set(actual).size !== actual.length ||
+        actual.length !== expected.size ||
+        actual.some((key) => !expected.has(key)))
+        throw new AgentsError("REVIEW_ELIGIBILITY_MISMATCH", "Review preset must return exactly one eligibility outcome for every exposed item");
+    const kindOrder = new Map(REVIEW_AGENT_SUBJECT_KINDS.map((kind, index) => [kind, index]));
+    return [...parsed.data].sort((left, right) => kindOrder.get(left.kind) - kindOrder.get(right.kind) ||
+        left.id.localeCompare(right.id));
+}
+function sorted(values) {
+    return [...values].sort();
+}
+function exactMembers(left, right) {
+    return canonicalJson(sorted(left)) === canonicalJson(sorted(right));
+}
+function exactReference(left, right) {
+    return canonicalJson(left) === canonicalJson(right);
+}
+function requestIdentity(input) {
+    return `fnv1a64-jcs-v1:${fnv1a64(canonicalJson({
+        ...input,
+        methodIds: sorted(input.methodIds),
+        assumptionIds: sorted(input.assumptionIds),
+        optionIds: sorted(input.optionIds),
+    }))}`;
+}
+function selectedEligibility(eligibility, input) {
+    const selected = new Set([
+        subjectKey("plan", input.planId),
+        subjectKey("input", input.inputId),
+        ...input.methodIds.map((id) => subjectKey("method", id)),
+        ...input.assumptionIds.map((id) => subjectKey("assumption", id)),
+        ...input.optionIds.map((id) => subjectKey("option", id)),
+    ]);
+    return eligibility.filter((item) => selected.has(subjectKey(item.kind, item.id)));
+}
+function assertAllowedRequest(preset, input) {
+    if (input.planId !== preset.plan.id || input.inputId !== preset.input.id)
+        throw new AgentsError("REVIEW_REQUEST_MISMATCH", "The requested plan or input does not belong to the selected preset");
+    const allowedMethods = new Set(preset.methods.map((item) => item.id));
+    const allowedAssumptions = new Set(preset.assumptions.map((item) => item.id));
+    const allowedOptions = new Set(preset.options.map((item) => item.id));
+    if (input.methodIds.some((id) => !allowedMethods.has(id)))
+        throw new AgentsError("UNAPPROVED_REVIEW_METHOD", "One or more requested methods are not approved by the selected preset");
+    if (input.assumptionIds.some((id) => !allowedAssumptions.has(id)))
+        throw new AgentsError("UNAPPROVED_REVIEW_ASSUMPTION", "One or more requested assumptions are not approved by the selected preset");
+    if (input.optionIds.some((id) => !allowedOptions.has(id)))
+        throw new AgentsError("UNAPPROVED_REVIEW_OPTION", "One or more requested options are not approved by the selected preset");
+}
+function assertReceipt(preset, request, receipt) {
+    if (receipt === null || typeof receipt !== "object" || Array.isArray(receipt))
+        throw new AgentsError("REVIEW_EXECUTION_MISMATCH", "Review executor returned a malformed receipt");
+    const scopeField = Object.getOwnPropertyDescriptor(receipt, "scope");
+    const snapshotField = Object.getOwnPropertyDescriptor(receipt, "snapshot");
+    if (![Object.prototype, null].includes(Object.getPrototypeOf(receipt)) ||
+        Reflect.ownKeys(receipt).some((key) => typeof key !== "string" || !["scope", "snapshot"].includes(key)) ||
+        !scopeField?.enumerable ||
+        !("value" in scopeField) ||
+        !snapshotField?.enumerable ||
+        !("value" in snapshotField))
+        throw new AgentsError("REVIEW_EXECUTION_MISMATCH", "Review executor receipt must contain only scope and snapshot data fields");
+    const scope = z
+        .object({
+        tenantId: token,
+        runPresetId: token,
+        presetVersion: token,
+        requestIdentity: tag,
+        planId: token,
+        inputId: token,
+        methodIds: uniqueTokens(REVIEW_AGENT_LIMITS.maximumMethods, 1),
+        assumptionIds: uniqueTokens(REVIEW_AGENT_LIMITS.maximumAssumptions),
+        optionIds: uniqueTokens(REVIEW_AGENT_LIMITS.maximumOptions),
+    })
+        .strict()
+        .safeParse(scopeField.value);
+    if (!scope.success || canonicalJson(scope.data) !== canonicalJson(request))
+        throw new AgentsError("REVIEW_EXECUTION_MISMATCH", "Review executor result is bound to another tenant, request, definition or preset");
+    try {
+        assertVerifiedReviewSnapshot(snapshotField.value);
+    }
+    catch {
+        throw new AgentsError("REVIEW_EXECUTION_MISMATCH", "Review executor must return an authentic current-process verified snapshot");
+    }
+    const snapshot = snapshotField.value;
+    if (snapshot.profile.id !== preset.profile.id ||
+        snapshot.profile.version !== preset.profile.version ||
+        !exactReference(snapshot.run.document.analysisReview.run.plan.reference, preset.plan.reference))
+        throw new AgentsError("REVIEW_EXECUTION_MISMATCH", "Verified snapshot belongs to another review plan or profile");
+    const indexedReferences = snapshot.run.document.analysisReview.referenceIndex.definitions.map((entry) => entry.reference);
+    if (!indexedReferences.some((reference) => exactReference(reference, preset.input.reference)))
+        throw new AgentsError("REVIEW_EXECUTION_MISMATCH", "Verified snapshot does not contain the exact approved input reference");
+    const methods = request.methodIds.map((id) => preset.methods.find((item) => item.id === id));
+    const planNodes = snapshot.run.document.analysisReview.run.plan.plan.nodes;
+    if (methods.some((method) => !planNodes.some((node) => node.id === method.nodeId && node.operation === method.operation)))
+        throw new AgentsError("REVIEW_EXECUTION_MISMATCH", "Verified snapshot is missing an exact approved method node");
+    const requestedAssumptions = request.assumptionIds.map((id) => preset.assumptions.find((item) => item.id === id).reference);
+    if (!exactMembers(snapshot.profile.assumptions.map((reference) => canonicalJson(reference)), requestedAssumptions.map((reference) => canonicalJson(reference))))
+        throw new AgentsError("REVIEW_EXECUTION_MISMATCH", "Verified snapshot assumptions do not exactly match the approved request");
+    return snapshot;
+}
+/** Builds the paired read-only tools over one immutable host catalog. */
+export function createReviewAgentTools(input) {
+    if (input === null || typeof input !== "object" || Array.isArray(input))
+        throw new AgentsError("BAD_REVIEW_CATALOG", "Review tool options must be an object");
+    for (const [name, value] of [
+        ["discoveryId", input.discoveryId],
+        ["executionId", input.executionId],
+        ["tenantContextKey", input.tenantContextKey],
+    ])
+        if (value !== undefined && !isDiagnosticToken(value))
+            throw new AgentsError("BAD_REVIEW_CATALOG", `Review tool ${name} must be a nonempty identifier when supplied`);
+    if (input.discoveryId !== undefined &&
+        input.executionId !== undefined &&
+        input.discoveryId === input.executionId)
+        throw new AgentsError("BAD_REVIEW_CATALOG", "Review discovery and execution tool IDs must differ");
+    const catalog = catalogOf(input.runPresets);
+    const tenantKey = input.tenantContextKey ?? "projectId";
+    const discover = defineActuarialTool({
+        id: input.discoveryId ?? "discover-approved-review",
+        description: "Discover one host-approved analytical review and its contextual eligibility",
+        kind: "read",
+        tenant: "required",
+        tenantKey,
+        inputSchema: reviewAgentDiscoveryInputSchema,
+        outputSchema: reviewAgentDiscoveryResultSchema,
+        execute: async (request, tenantId) => {
+            const preset = catalog.get(request.runPresetId);
+            if (!preset)
+                throw new AgentsError("UNKNOWN_REVIEW_PRESET", `Unknown review preset ${request.runPresetId}`);
+            const eligibility = await inspectPreset(preset, tenantId);
+            return {
+                success: true,
+                data: {
+                    runPresetId: preset.id,
+                    presetVersion: preset.version,
+                    label: preset.label,
+                    planId: preset.plan.id,
+                    inputId: preset.input.id,
+                    profile: preset.profile,
+                    methods: preset.methods.map((item) => ({ ...item })),
+                    assumptions: preset.assumptions.map(({ id, label }) => ({ id, label })),
+                    options: preset.options.map((item) => ({ ...item })),
+                    judgments: preset.judgments.map((item) => ({
+                        ...item,
+                        candidateIds: [...item.candidateIds],
+                    })),
+                    eligibility: [...eligibility],
+                },
+            };
+        },
+    });
+    const execute = defineActuarialTool({
+        id: input.executionId ?? "run-approved-review",
+        description: "Run a host-approved analytical review and return verified readiness evidence",
+        kind: "read",
+        tenant: "required",
+        tenantKey,
+        inputSchema: reviewAgentExecutionInputSchema,
+        outputSchema: reviewAgentExecutionResultSchema,
+        execute: async (raw, tenantId) => {
+            const preset = catalog.get(raw.runPresetId);
+            if (!preset)
+                throw new AgentsError("UNKNOWN_REVIEW_PRESET", `Unknown review preset ${raw.runPresetId}`);
+            assertAllowedRequest(preset, raw);
+            const eligibility = await inspectPreset(preset, tenantId);
+            const unavailable = selectedEligibility(eligibility, raw).filter((item) => item.status === "requires-input" || item.status === "unsupported");
+            if (unavailable.length > 0)
+                throw new AgentsError("REVIEW_NOT_ELIGIBLE", `Approved review cannot run because these selected items are ineligible: ${unavailable
+                    .map((item) => `${item.kind}:${item.id}`)
+                    .join(", ")}`);
+            const normalized = {
+                ...raw,
+                methodIds: sorted(raw.methodIds),
+                assumptionIds: sorted(raw.assumptionIds),
+                optionIds: sorted(raw.optionIds),
+            };
+            const executionInput = {
+                tenantId,
+                runPresetId: preset.id,
+                presetVersion: preset.version,
+                requestIdentity: requestIdentity(normalized),
+                planId: normalized.planId,
+                inputId: normalized.inputId,
+                methodIds: normalized.methodIds,
+                assumptionIds: normalized.assumptionIds,
+                optionIds: normalized.optionIds,
+            };
+            const receipt = await preset.execute(executionInput);
+            const snapshot = assertReceipt(preset, executionInput, receipt);
+            return {
+                success: true,
+                data: {
+                    runPresetId: preset.id,
+                    presetVersion: preset.version,
+                    requestIdentity: executionInput.requestIdentity,
+                    planId: preset.plan.id,
+                    inputId: preset.input.id,
+                    methodIds: [...executionInput.methodIds],
+                    assumptionIds: [...executionInput.assumptionIds],
+                    optionIds: [...executionInput.optionIds],
+                    snapshot: {
+                        id: snapshot.id,
+                        version: snapshot.version,
+                        reference: snapshot.reference,
+                        profile: { id: snapshot.profile.id, version: snapshot.profile.version },
+                        readiness: snapshot.readiness,
+                        limitations: snapshot.limitations.map(({ id, disposition }) => ({
+                            id,
+                            disposition,
+                        })),
+                        findingCodes: [...new Set(snapshot.findings.map((item) => item.code))].sort(),
+                        assurance: snapshot.assurance,
+                    },
+                },
+            };
+        },
+    });
+    return Object.freeze({ discover, execute });
+}
+const judgmentDecisionSchema = z
+    .object({
+    decision: z.enum(["adopt", "decline"]),
+    candidateId: token.nullable(),
+    rationale: z.string(),
+    actor: z.enum(["actuary", "agent"]).optional(),
+})
+    .strict();
+function judgmentContext(gate, context, tenantKey) {
+    return {
+        tenantId: tenantOf({ requestContext: context.requestContext }, tenantKey),
+        presetId: gate.presetId,
+        presetVersion: gate.presetVersion,
+        gateId: gate.id,
+        kind: gate.kind,
+        targetId: gate.targetId,
+        decisions: context.decisions,
+        trail: context.trail,
+    };
+}
+/**
+ * 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 function createReviewAgentJudgmentChain(input) {
+    if (input === null || typeof input !== "object" || Array.isArray(input))
+        throw new AgentsError("BAD_REVIEW_JUDGMENT_CATALOG", "Review judgment options must be an object");
+    const tenantKey = input.tenantContextKey ?? "projectId";
+    if (!isDiagnosticToken(input.id) ||
+        !isDiagnosticToken(tenantKey) ||
+        typeof input.now !== "function")
+        throw new AgentsError("BAD_REVIEW_JUDGMENT_CATALOG", "Review judgment chain requires an ID and host clock");
+    if (!Array.isArray(input.gates) || input.gates.length === 0 || input.gates.length > REVIEW_AGENT_LIMITS.maximumJudgments)
+        throw new AgentsError("BAD_REVIEW_JUDGMENT_CATALOG", "Review judgment chain requires a nonempty bounded gate list");
+    if (new Set(input.gates.map((gate) => gate?.id)).size !== input.gates.length)
+        throw new AgentsError("BAD_REVIEW_JUDGMENT_CATALOG", "Review judgment gate IDs must be distinct");
+    const gates = input.gates.map((gate) => {
+        const parsed = z
+            .object({
+            id: token,
+            stage: text,
+            presetId: token,
+            presetVersion: token,
+            kind: z.enum(REVIEW_AGENT_JUDGMENT_KINDS),
+            targetId: token,
+            allowedCandidateIds: uniqueTokens(REVIEW_AGENT_LIMITS.maximumCandidatesPerJudgment),
+        })
+            .strict()
+            .safeParse({
+            id: gate.id,
+            stage: gate.stage,
+            presetId: gate.presetId,
+            presetVersion: gate.presetVersion,
+            kind: gate.kind,
+            targetId: gate.targetId,
+            allowedCandidateIds: gate.allowedCandidateIds,
+        });
+        if (!parsed.success ||
+            typeof gate.gatherEvidence !== "function" ||
+            typeof gate.applyDecision !== "function")
+            throw new AgentsError("BAD_REVIEW_JUDGMENT_CATALOG", "Review judgment gates require valid metadata and host callbacks");
+        const owned = parsed.data;
+        return {
+            id: owned.id,
+            stage: owned.stage,
+            resumeSchema: judgmentDecisionSchema,
+            gatherEvidence: async (context) => gate.gatherEvidence(judgmentContext(gate, context, tenantKey)),
+            applyDecision: async (context, decision) => {
+                const adopting = decision.decision === "adopt";
+                if ((adopting &&
+                    (decision.candidateId === null ||
+                        !owned.allowedCandidateIds.includes(decision.candidateId))) ||
+                    (!adopting && decision.candidateId !== null))
+                    throw new AgentsError("UNAPPROVED_REVIEW_JUDGMENT", "Review judgment must adopt one approved candidate or decline without a candidate");
+                const trusted = judgmentContext(gate, context, tenantKey);
+                const application = await gate.applyDecision(trusted, decision);
+                const auditValue = {
+                    presetId: owned.presetId,
+                    presetVersion: owned.presetVersion,
+                    kind: owned.kind,
+                    targetId: owned.targetId,
+                    decision: decision.decision,
+                    candidateId: decision.candidateId,
+                };
+                return {
+                    summary: application.summary ??
+                        (adopting
+                            ? `adopted ${decision.candidateId}`
+                            : `declined ${owned.targetId}`),
+                    ledgerEntries: [
+                        {
+                            field: `review.judgment.${owned.kind}.${owned.targetId}`,
+                            value: auditValue,
+                            source: `review-agent-gate:${owned.id}`,
+                        },
+                        ...(application.ledgerEntries ?? []),
+                    ],
+                };
+            },
+        };
+    });
+    return createJudgmentChain({
+        id: input.id,
+        gates,
+        now: input.now,
+        onComplete: input.onComplete,
+        requestContextSchema: z.object({ [tenantKey]: z.string().min(1) }),
+    });
+}
+/** Ready-to-run offline eval cases for the default review tool IDs. */
+export const REVIEW_AGENT_TOOL_SELECTION_CASES = Object.freeze([
+    {
+        id: "discover-approved-review",
+        prompt: "Show which approved review methods and assumptions are eligible before calculating anything.",
+        expectTools: ["discover-approved-review"],
+    },
+    {
+        id: "run-approved-review",
+        prompt: "Run the approved review I selected and return its verified readiness evidence.",
+        expectTools: ["run-approved-review"],
+    },
+]);
+//# sourceMappingURL=review.js.map