voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/domain/verify/model/types.d.ts

@@ -0,0 +1,408 @@
+import { z } from "zod";
+import { type VerificationStatus } from "../../../status/index.js";
+export { TERMINAL_VERIFICATION_STATUSES, verificationStatusSchema, } from "../../../status/index.js";
+export type { RubricRecommendation, RubricResultPayload, } from "../rubric-result.js";
+export type { VerificationStatus };
+declare const VERIFICATION_TARGET_KIND_VALUES: readonly ["spec", "run", "reduce", "message"];
+declare const VERIFICATION_METHOD_KIND_VALUES: readonly ["programmatic", "rubric"];
+declare const VERIFICATION_SCOPE_KIND_VALUES: readonly ["target", "run", "candidate"];
+export type VerificationTargetKind = (typeof VERIFICATION_TARGET_KIND_VALUES)[number];
+export type VerificationMethodKind = (typeof VERIFICATION_METHOD_KIND_VALUES)[number];
+export type VerificationScopeKind = (typeof VERIFICATION_SCOPE_KIND_VALUES)[number];
+export declare const verificationTargetKindSchema: z.ZodEnum<{
+    message: "message";
+    reduce: "reduce";
+    spec: "spec";
+    run: "run";
+}>;
+export declare const verificationMethodKindSchema: z.ZodEnum<{
+    programmatic: "programmatic";
+    rubric: "rubric";
+}>;
+export declare const verificationScopeKindSchema: z.ZodEnum<{
+    target: "target";
+    run: "run";
+    candidate: "candidate";
+}>;
+export declare const specVerificationTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"spec">;
+    sessionId: z.ZodString;
+    specPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const runVerificationTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"run">;
+    sessionId: z.ZodString;
+    candidateIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const reduceVerificationTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"reduce">;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export declare const messageVerificationTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"message">;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export declare const verificationTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"spec">;
+    sessionId: z.ZodString;
+    specPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"run">;
+    sessionId: z.ZodString;
+    candidateIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reduce">;
+    sessionId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"message">;
+    sessionId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type VerificationTarget = z.infer<typeof verificationTargetSchema>;
+export declare const verificationScopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"target">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"run">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"candidate">;
+    candidateId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type VerificationScope = z.infer<typeof verificationScopeSchema>;
+export declare const verificationMethodResultRefSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        programmatic: "programmatic";
+        rubric: "rubric";
+    }>;
+    slug: z.ZodOptional<z.ZodString>;
+    scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"target">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"candidate">;
+        candidateId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    artifactPath: z.ZodOptional<z.ZodString>;
+    verifierId: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cached: z.ZodOptional<z.ZodNumber>;
+        thoughts: z.ZodOptional<z.ZodNumber>;
+        tool: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type VerificationMethodResultRef = z.infer<typeof verificationMethodResultRefSchema>;
+export declare const rubricFindingSeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warning: "warning";
+}>;
+export declare const rubricFindingSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type RubricFinding = z.infer<typeof rubricFindingSchema>;
+export declare const programmaticResultArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    method: z.ZodLiteral<"programmatic">;
+    generatedAt: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    target: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        specPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"reduce">;
+        sessionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        sessionId: z.ZodString;
+    }, z.core.$strict>]>;
+    scope: z.ZodLiteral<"target">;
+    results: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+            errored: "errored";
+            skipped: "skipped";
+        }>;
+        command: z.ZodOptional<z.ZodString>;
+        exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        logPath: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    method: z.ZodLiteral<"programmatic">;
+    generatedAt: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    target: z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+        sessionId: z.ZodString;
+        candidateIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    scope: z.ZodLiteral<"run">;
+    candidates: z.ZodArray<z.ZodObject<{
+        candidateId: z.ZodString;
+        results: z.ZodArray<z.ZodObject<{
+            slug: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+                errored: "errored";
+                skipped: "skipped";
+            }>;
+            command: z.ZodOptional<z.ZodString>;
+            exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            logPath: z.ZodOptional<z.ZodString>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "scope">;
+export type ProgrammaticResultArtifact = z.infer<typeof programmaticResultArtifactSchema>;
+export declare const rubricResultArtifactSchema: z.ZodObject<{
+    method: z.ZodLiteral<"rubric">;
+    template: z.ZodString;
+    verifierId: z.ZodString;
+    generatedAt: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    result: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type RubricResultArtifact = z.infer<typeof rubricResultArtifactSchema>;
+export declare const verificationResultArtifactSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    method: z.ZodLiteral<"programmatic">;
+    generatedAt: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    target: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        specPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"reduce">;
+        sessionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        sessionId: z.ZodString;
+    }, z.core.$strict>]>;
+    scope: z.ZodLiteral<"target">;
+    results: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+            errored: "errored";
+            skipped: "skipped";
+        }>;
+        command: z.ZodOptional<z.ZodString>;
+        exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        logPath: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    method: z.ZodLiteral<"programmatic">;
+    generatedAt: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    target: z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+        sessionId: z.ZodString;
+        candidateIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    scope: z.ZodLiteral<"run">;
+    candidates: z.ZodArray<z.ZodObject<{
+        candidateId: z.ZodString;
+        results: z.ZodArray<z.ZodObject<{
+            slug: z.ZodString;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+                errored: "errored";
+                skipped: "skipped";
+            }>;
+            command: z.ZodOptional<z.ZodString>;
+            exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            logPath: z.ZodOptional<z.ZodString>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "scope">, z.ZodObject<{
+    method: z.ZodLiteral<"rubric">;
+    template: z.ZodString;
+    verifierId: z.ZodString;
+    generatedAt: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    result: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>]>;
+export type VerificationResultArtifact = z.infer<typeof verificationResultArtifactSchema>;
+export declare const verificationRecordSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    createdAt: z.ZodString;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        specPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+        sessionId: z.ZodString;
+        candidateIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"reduce">;
+        sessionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        sessionId: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    extraContextMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        stagedPath: z.ZodString;
+        sourcePath: z.ZodString;
+    }, z.core.$strip>>>;
+    blinded: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodLiteral<true>;
+        aliasMap: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>;
+    methods: z.ZodArray<z.ZodObject<{
+        method: z.ZodEnum<{
+            programmatic: "programmatic";
+            rubric: "rubric";
+        }>;
+        slug: z.ZodOptional<z.ZodString>;
+        scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"target">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"run">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"candidate">;
+            candidateId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            aborted: "aborted";
+        }>;
+        artifactPath: z.ZodOptional<z.ZodString>;
+        verifierId: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+            total_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            cached: z.ZodOptional<z.ZodNumber>;
+            thoughts: z.ZodOptional<z.ZodNumber>;
+            tool: z.ZodOptional<z.ZodNumber>;
+            total: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type VerificationRecord = z.infer<typeof verificationRecordSchema>;
+export declare const verificationIndexEntrySchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    createdAt: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    targetKind: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        spec: "spec";
+        run: "run";
+    }>;
+    targetSessionId: z.ZodString;
+}, z.core.$strict>;
+export type VerificationIndexEntry = z.infer<typeof verificationIndexEntrySchema>;

package/dist/domain/verify/model/types.js

@@ -0,0 +1,289 @@
+import { z } from "zod";
+import { agentIdSchema } from "../../../configs/agents/types.js";
+import { programmaticCheckResultSchema, programmaticSlugSchema, rubricTemplateSchema, } from "../../../configs/verification/methods.js";
+import { extraContextMetadataEntrySchema, persistedExtraContextPathSchema, } from "../../../persistence/extra-context.js";
+import { repoRelativeRecordPathSchema } from "../../../persistence/record-path-schema.js";
+import { TERMINAL_VERIFICATION_STATUSES, verificationStatusSchema, } from "../../../status/index.js";
+import { extractedTokenUsageSchema } from "../../run/model/types.js";
+import { validateRecordLifecycleTimestamps } from "../../shared/lifecycle.js";
+import { BLINDED_ALIAS_PATTERN } from "../blinding/aliases.js";
+import { rubricResultPayloadSchema, safeParseRubricRecommendationFromResult, } from "../rubric-result.js";
+export { TERMINAL_VERIFICATION_STATUSES, verificationStatusSchema, } from "../../../status/index.js";
+const VERIFICATION_TARGET_KIND_VALUES = [
+    "spec",
+    "run",
+    "reduce",
+    "message",
+];
+const VERIFICATION_METHOD_KIND_VALUES = ["programmatic", "rubric"];
+const VERIFICATION_SCOPE_KIND_VALUES = ["target", "run", "candidate"];
+const RUBRIC_FINDING_SEVERITY_VALUES = ["info", "warning", "error"];
+export const verificationTargetKindSchema = z.enum(VERIFICATION_TARGET_KIND_VALUES);
+export const verificationMethodKindSchema = z.enum(VERIFICATION_METHOD_KIND_VALUES);
+export const verificationScopeKindSchema = z.enum(VERIFICATION_SCOPE_KIND_VALUES);
+const verificationResultArtifactPathSchema = repoRelativeRecordPathSchema.refine((value) => value.endsWith("/result.json") || value.endsWith(".result.json"), {
+    message: "verification result artifact paths must end with `/result.json` or `.result.json`",
+});
+export const specVerificationTargetSchema = z
+    .object({
+    kind: z.literal("spec"),
+    sessionId: z.string().min(1),
+    specPath: repoRelativeRecordPathSchema.optional(),
+})
+    .strict();
+export const runVerificationTargetSchema = z
+    .object({
+    kind: z.literal("run"),
+    sessionId: z.string().min(1),
+    candidateIds: z.array(agentIdSchema).min(1),
+})
+    .strict();
+export const reduceVerificationTargetSchema = z
+    .object({
+    kind: z.literal("reduce"),
+    sessionId: z.string().min(1),
+})
+    .strict();
+export const messageVerificationTargetSchema = z
+    .object({
+    kind: z.literal("message"),
+    sessionId: z.string().min(1),
+})
+    .strict();
+export const verificationTargetSchema = z.discriminatedUnion("kind", [
+    specVerificationTargetSchema,
+    runVerificationTargetSchema,
+    reduceVerificationTargetSchema,
+    messageVerificationTargetSchema,
+]);
+export const verificationScopeSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("target") }).strict(),
+    z.object({ kind: z.literal("run") }).strict(),
+    z
+        .object({
+        kind: z.literal("candidate"),
+        candidateId: agentIdSchema,
+    })
+        .strict(),
+]);
+const blindedAliasSchema = z.string().regex(BLINDED_ALIAS_PATTERN, {
+    message: "Blinded alias must match /^v_[a-z0-9]{10,16}$/",
+});
+const blindedAliasMapSchema = z.record(blindedAliasSchema, agentIdSchema);
+export const verificationMethodResultRefSchema = z
+    .object({
+    method: verificationMethodKindSchema,
+    slug: programmaticSlugSchema.optional(),
+    scope: verificationScopeSchema,
+    status: verificationStatusSchema,
+    artifactPath: verificationResultArtifactPathSchema.optional(),
+    verifierId: agentIdSchema.optional(),
+    template: rubricTemplateSchema.optional(),
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    tokenUsage: extractedTokenUsageSchema.optional(),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((entry, ctx) => {
+    const isTerminal = TERMINAL_VERIFICATION_STATUSES.includes(entry.status);
+    if (entry.method === "programmatic") {
+        if (entry.slug !== "programmatic") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["slug"],
+                message: "programmatic method refs must use slug `programmatic`",
+            });
+        }
+        if (entry.verifierId !== undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["verifierId"],
+                message: "programmatic method refs must not set `verifierId`",
+            });
+        }
+        if (entry.template !== undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["template"],
+                message: "programmatic method refs must not set `template`",
+            });
+        }
+    }
+    if (entry.method === "rubric") {
+        if (entry.slug !== undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["slug"],
+                message: "rubric method refs must not set `slug`",
+            });
+        }
+        if (!entry.verifierId) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["verifierId"],
+                message: "rubric method refs must set `verifierId`",
+            });
+        }
+        if (!entry.template) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["template"],
+                message: "rubric method refs must set `template`",
+            });
+        }
+    }
+    if (isTerminal && !entry.artifactPath) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["artifactPath"],
+            message: "terminal verification method refs must persist a verification result artifact path",
+        });
+    }
+});
+export const rubricFindingSeveritySchema = z.enum(RUBRIC_FINDING_SEVERITY_VALUES);
+export const rubricFindingSchema = z
+    .object({
+    severity: rubricFindingSeveritySchema,
+    message: z.string().min(1),
+})
+    .strict();
+const programmaticCandidateResultSchema = z
+    .object({
+    candidateId: agentIdSchema,
+    results: z.array(programmaticCheckResultSchema),
+})
+    .strict();
+export const programmaticResultArtifactSchema = z.discriminatedUnion("scope", [
+    z
+        .object({
+        method: z.literal("programmatic"),
+        generatedAt: z.string(),
+        status: verificationStatusSchema.optional(),
+        error: z.string().nullable().optional(),
+        target: z.union([
+            specVerificationTargetSchema,
+            reduceVerificationTargetSchema,
+            messageVerificationTargetSchema,
+        ]),
+        scope: z.literal("target"),
+        results: z.array(programmaticCheckResultSchema),
+    })
+        .strict(),
+    z
+        .object({
+        method: z.literal("programmatic"),
+        generatedAt: z.string(),
+        status: verificationStatusSchema.optional(),
+        error: z.string().nullable().optional(),
+        target: runVerificationTargetSchema,
+        scope: z.literal("run"),
+        candidates: z.array(programmaticCandidateResultSchema),
+    })
+        .strict(),
+]);
+export const rubricResultArtifactSchema = z
+    .object({
+    method: z.literal("rubric"),
+    template: rubricTemplateSchema,
+    verifierId: agentIdSchema,
+    generatedAt: z.string(),
+    status: verificationStatusSchema,
+    result: rubricResultPayloadSchema,
+    error: z.string().nullable().optional(),
+})
+    .strict()
+    .superRefine((artifact, ctx) => {
+    const validation = safeParseRubricRecommendationFromResult(artifact.result);
+    if (validation.success) {
+        return;
+    }
+    for (const issue of validation.error.issues) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["result", ...issue.path],
+            message: issue.message,
+        });
+    }
+});
+export const verificationResultArtifactSchema = z.union([
+    programmaticResultArtifactSchema,
+    rubricResultArtifactSchema,
+]);
+export const verificationRecordSchema = z
+    .object({
+    sessionId: z.string().min(1),
+    createdAt: z.string(),
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    status: verificationStatusSchema,
+    target: verificationTargetSchema,
+    extraContext: z.array(persistedExtraContextPathSchema).optional(),
+    extraContextMetadata: z.array(extraContextMetadataEntrySchema).optional(),
+    blinded: z
+        .object({
+        enabled: z.literal(true),
+        aliasMap: blindedAliasMapSchema,
+    })
+        .optional(),
+    methods: z.array(verificationMethodResultRefSchema),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((record, ctx) => {
+    validateRecordLifecycleTimestamps({
+        status: record.status,
+        createdAt: record.createdAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    }, ctx, {
+        queued: ["queued"],
+        running: ["running"],
+        terminal: TERMINAL_VERIFICATION_STATUSES,
+    });
+    const methodKeySet = new Set();
+    for (const method of record.methods) {
+        const key = method.method === "programmatic"
+            ? `${method.method}:${method.scope.kind}`
+            : `${method.method}:${method.template}:${method.verifierId}:${method.scope.kind}:${method.scope.kind === "candidate" ? method.scope.candidateId : "_"}`;
+        if (methodKeySet.has(key)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["methods"],
+                message: `duplicate verification method ref: ${key}`,
+            });
+        }
+        methodKeySet.add(key);
+        if (record.target.kind === "run") {
+            if (method.method === "rubric" && method.scope.kind === "target") {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["methods"],
+                    message: "run-target rubric refs must use explicit `run` or `candidate` scope",
+                });
+            }
+            if (method.scope.kind === "candidate" &&
+                !record.target.candidateIds.includes(method.scope.candidateId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["methods"],
+                    message: `candidate scope references unknown run candidate \`${method.scope.candidateId}\``,
+                });
+            }
+        }
+        else if (method.scope.kind !== "target") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["methods"],
+                message: "spec, reduce, and message verification refs must use `target` scope only",
+            });
+        }
+    }
+});
+export const verificationIndexEntrySchema = z
+    .object({
+    sessionId: z.string().min(1),
+    createdAt: z.string(),
+    status: verificationStatusSchema,
+    targetKind: verificationTargetKindSchema,
+    targetSessionId: z.string().min(1),
+})
+    .strict();