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

package/dist/commands/verify/lifecycle.js

@@ -0,0 +1,229 @@
+import { runTeardown } from "../../competition/shared/teardown.js";
+import { buildOperationLifecycleCompleteFields, buildRecordLifecycleCompleteFields, } from "../../domain/shared/lifecycle.js";
+import { writeVerificationArtifact } from "../../domain/verify/competition/artifacts.js";
+import { flushVerificationRecordBuffer, readVerificationRecords, rewriteVerificationRecord, } from "../../domain/verify/persistence/adapter.js";
+import { toErrorMessage } from "../../utils/errors.js";
+import { getVerificationProgrammaticResultPath, getVerificationRubricResultPath, } from "../../workspace/structure.js";
+export const VERIFY_ABORT_DETAIL = "Verification aborted before completion.";
+let activeVerification;
+let terminationInFlight = false;
+export function registerActiveVerification(context) {
+    activeVerification = context;
+}
+export function clearActiveVerification(verificationId) {
+    if (activeVerification?.verificationId !== verificationId) {
+        return;
+    }
+    if (!terminationInFlight) {
+        activeVerification = undefined;
+    }
+}
+export async function terminateActiveVerification(status) {
+    if (!activeVerification || terminationInFlight) {
+        return;
+    }
+    terminationInFlight = true;
+    const context = activeVerification;
+    let persistenceError;
+    try {
+        const existingRecord = await readVerificationRecords({
+            root: context.root,
+            verificationsFilePath: context.verificationsFilePath,
+            limit: 1,
+            predicate: (record) => record.sessionId === context.verificationId,
+        }).then((records) => records[0]);
+        if (!existingRecord) {
+            return;
+        }
+        const completedAt = new Date().toISOString();
+        const detail = status === "aborted" ? VERIFY_ABORT_DETAIL : "Verification failed.";
+        await materializeTerminalVerificationArtifacts({
+            root: context.root,
+            verificationId: context.verificationId,
+            record: existingRecord,
+            status,
+            completedAt,
+            detail,
+        });
+        await rewriteVerificationRecord({
+            root: context.root,
+            verificationsFilePath: context.verificationsFilePath,
+            sessionId: context.verificationId,
+            mutate: (existing) => {
+                const methods = existing.methods.map((method) => finalizeVerificationMethodRef({
+                    verificationId: context.verificationId,
+                    method,
+                    target: existing.target,
+                    status,
+                    completedAt,
+                    detail,
+                }));
+                const inProgress = existing.status === "queued" || existing.status === "running";
+                if (!inProgress) {
+                    if (methods.every((method, index) => method === existing.methods[index])) {
+                        return existing;
+                    }
+                    return {
+                        ...existing,
+                        methods,
+                    };
+                }
+                return {
+                    ...existing,
+                    status,
+                    methods,
+                    ...buildRecordLifecycleCompleteFields({
+                        existing,
+                        startedAt: existing.startedAt ?? completedAt,
+                        completedAt,
+                    }),
+                    error: existing.error ?? detail,
+                };
+            },
+            forceFlush: true,
+        });
+        await flushVerificationRecordBuffer({
+            verificationsFilePath: context.verificationsFilePath,
+            sessionId: context.verificationId,
+        });
+    }
+    catch (error) {
+        persistenceError =
+            error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to finalize verification ${context.verificationId}: ${toErrorMessage(error)}`);
+    }
+    finally {
+        try {
+            await finalizeRegisteredVerificationTeardown(context);
+        }
+        finally {
+            terminationInFlight = false;
+            activeVerification = undefined;
+        }
+    }
+    if (persistenceError) {
+        throw persistenceError;
+    }
+}
+export async function finalizeActiveVerification(verificationId) {
+    if (!activeVerification ||
+        activeVerification.verificationId !== verificationId) {
+        clearActiveVerification(verificationId);
+        return;
+    }
+    const context = activeVerification;
+    try {
+        await finalizeRegisteredVerificationTeardown(context);
+    }
+    finally {
+        clearActiveVerification(verificationId);
+    }
+}
+function finalizeVerificationMethodRef(options) {
+    const { verificationId, method, target, status, completedAt, detail } = options;
+    if (method.status !== "queued" && method.status !== "running") {
+        return method;
+    }
+    const artifactPath = method.artifactPath ??
+        buildVerificationMethodArtifactPath({
+            verificationId,
+            method,
+        });
+    return {
+        ...method,
+        status,
+        artifactPath,
+        ...buildOperationLifecycleCompleteFields({
+            existing: method,
+            startedAt: method.startedAt ?? completedAt,
+            completedAt,
+        }),
+        error: method.error ?? detail,
+        ...(method.method === "programmatic" &&
+            target.kind !== "run" &&
+            method.scope.kind === "run"
+            ? { scope: { kind: "target" } }
+            : {}),
+    };
+}
+async function materializeTerminalVerificationArtifacts(options) {
+    const { root, verificationId, record, status, completedAt, detail } = options;
+    for (const method of record.methods) {
+        if (method.status !== "queued" && method.status !== "running") {
+            continue;
+        }
+        const artifactPath = buildVerificationMethodArtifactPath({
+            verificationId,
+            method,
+        });
+        if (!artifactPath) {
+            continue;
+        }
+        if (method.method === "rubric") {
+            const { template, verifierId } = method;
+            if (!template || !verifierId) {
+                continue;
+            }
+            await writeVerificationArtifact({
+                root,
+                artifactPath,
+                artifact: {
+                    method: "rubric",
+                    template,
+                    verifierId,
+                    generatedAt: completedAt,
+                    status,
+                    result: {},
+                    error: detail,
+                },
+            });
+            continue;
+        }
+        if (record.target.kind === "run") {
+            await writeVerificationArtifact({
+                root,
+                artifactPath,
+                artifact: {
+                    method: "programmatic",
+                    generatedAt: completedAt,
+                    status,
+                    error: detail,
+                    target: record.target,
+                    scope: "run",
+                    candidates: [],
+                },
+            });
+            continue;
+        }
+        await writeVerificationArtifact({
+            root,
+            artifactPath,
+            artifact: {
+                method: "programmatic",
+                generatedAt: completedAt,
+                status,
+                error: detail,
+                target: record.target,
+                scope: "target",
+                results: [],
+            },
+        });
+    }
+}
+async function finalizeRegisteredVerificationTeardown(context) {
+    await runTeardown(context.teardown);
+}
+function buildVerificationMethodArtifactPath(options) {
+    const { verificationId, method } = options;
+    if (method.method === "programmatic") {
+        return getVerificationProgrammaticResultPath(verificationId);
+    }
+    if (!method.verifierId || !method.template) {
+        return undefined;
+    }
+    return getVerificationRubricResultPath({
+        sessionId: verificationId,
+        verifierId: method.verifierId,
+        template: method.template,
+    });
+}

package/dist/commands/verify/max-parallel.d.ts

@@ -0,0 +1,7 @@
+import type { VerificationConfig } from "../../configs/verification/types.js";
+export declare function resolveVerifyRubricMaxParallel(options: {
+    targetKind: "spec" | "run" | "reduce" | "message";
+    verificationConfig: VerificationConfig;
+    verifierAgentCount: number;
+    requestedMaxParallel?: number;
+}): number;

package/dist/commands/verify/max-parallel.js

@@ -0,0 +1,15 @@
+import { resolveEffectiveMaxParallel } from "../shared/max-parallel.js";
+export function resolveVerifyRubricMaxParallel(options) {
+    const { targetKind, verificationConfig, verifierAgentCount, requestedMaxParallel, } = options;
+    const rubricTemplateCount = targetKind === "spec"
+        ? verificationConfig.spec.rubric.length
+        : targetKind === "run"
+            ? verificationConfig.run.rubric.length
+            : targetKind === "reduce"
+                ? verificationConfig.reduce.rubric.length
+                : verificationConfig.message.rubric.length;
+    return resolveEffectiveMaxParallel({
+        competitorCount: verifierAgentCount * rubricTemplateCount,
+        requestedMaxParallel,
+    });
+}

package/dist/commands/verify/targets.d.ts

@@ -0,0 +1,18 @@
+import type { ResolvedVerificationTarget, VerificationCompetitiveCandidate } from "../../domain/verify/competition/target.js";
+export type VerifyTargetKind = "spec" | "run" | "reduce" | "message";
+export interface VerifyTargetSelection {
+    kind: VerifyTargetKind;
+    sessionId: string;
+}
+export interface ResolveVerifyTargetInput {
+    root: string;
+    specsFilePath: string;
+    runsFilePath: string;
+    reductionsFilePath: string;
+    messagesFilePath: string;
+    verificationsFilePath: string;
+    target: VerifyTargetSelection;
+}
+export type VerifyCompetitiveCandidate = VerificationCompetitiveCandidate;
+export type ResolvedVerifyTarget = ResolvedVerificationTarget;
+export declare function resolveVerifyTarget(input: ResolveVerifyTargetInput): Promise<ResolvedVerifyTarget>;

package/dist/commands/verify/targets.js

@@ -0,0 +1,420 @@
+import { basename } from "node:path";
+import { CliError, RunNotFoundCliError } from "../../cli/errors.js";
+import { TERMINAL_MESSAGE_STATUSES } from "../../domain/message/model/types.js";
+import { readMessageRecords } from "../../domain/message/persistence/adapter.js";
+import { TERMINAL_REDUCTION_STATUSES } from "../../domain/reduce/model/types.js";
+import { readReductionRecords } from "../../domain/reduce/persistence/adapter.js";
+import { RunRecordNotFoundError } from "../../domain/run/model/errors.js";
+import { fetchRunsSafely } from "../../domain/run/persistence/adapter.js";
+import { TERMINAL_SPEC_STATUSES } from "../../domain/spec/model/types.js";
+import { readSpecRecords } from "../../domain/spec/persistence/adapter.js";
+import { readVerificationRecords } from "../../domain/verify/persistence/adapter.js";
+import { TERMINAL_RUN_STATUSES } from "../../status/index.js";
+import { MESSAGE_RESPONSE_FILENAME } from "../../workspace/structure.js";
+export async function resolveVerifyTarget(input) {
+    const { target } = input;
+    switch (target.kind) {
+        case "spec":
+            return resolveSpecVerifyTarget(input);
+        case "run":
+            return resolveRunVerifyTarget(input);
+        case "reduce":
+            return resolveReductionVerifyTarget(input);
+        case "message":
+            return resolveMessageVerifyTarget(input);
+    }
+}
+async function resolveSpecVerifyTarget(input) {
+    const { root, specsFilePath, target } = input;
+    const [record] = await readSpecRecords({
+        root,
+        specsFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.sessionId,
+    });
+    if (!record) {
+        throw new CliError(`Spec session \`${target.sessionId}\` not found.`, [], [
+            "Re-run `voratiq spec` or confirm the session id in `.voratiq/spec/index.json`.",
+        ]);
+    }
+    if (!TERMINAL_SPEC_STATUSES.includes(record.status)) {
+        throw new CliError(`Spec session \`${target.sessionId}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the spec to finish before running `voratiq verify`."]);
+    }
+    return {
+        baseRevisionSha: resolveSpecBaseRevisionSha(record),
+        competitiveCandidates: record.agents
+            .filter((agent) => agent.status === "succeeded" && agent.outputPath)
+            .map((agent) => ({
+            canonicalId: agent.agentId,
+            forbiddenIdentityTokens: [agent.agentId],
+        })),
+        target: {
+            kind: "spec",
+            sessionId: record.sessionId,
+        },
+        specRecord: record,
+    };
+}
+async function resolveRunVerifyTarget(input) {
+    const { root, runsFilePath, target } = input;
+    const { records } = await fetchRunsSafely({
+        root,
+        runsFilePath,
+        runId: target.sessionId,
+        filters: { includeDeleted: true },
+    }).catch((error) => {
+        if (error instanceof RunRecordNotFoundError) {
+            throw new RunNotFoundCliError(target.sessionId);
+        }
+        throw error;
+    });
+    const record = records[0];
+    if (!record) {
+        throw new RunNotFoundCliError(target.sessionId);
+    }
+    if (!isRunStatusCompleteForVerification(record.status)) {
+        throw new CliError(`Run \`${target.sessionId}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the run to finish before running `voratiq verify`."]);
+    }
+    const candidateIds = [
+        ...new Set(record.agents.map((agent) => agent.agentId)),
+    ].sort((left, right) => left.localeCompare(right));
+    if (candidateIds.length === 0) {
+        throw new CliError(`Run \`${target.sessionId}\` has no candidate agents to verify.`, [], ["Re-run `voratiq run` to generate verifiable candidates."]);
+    }
+    return {
+        baseRevisionSha: record.baseRevisionSha,
+        competitiveCandidates: candidateIds.map((candidateId) => ({
+            canonicalId: candidateId,
+            forbiddenIdentityTokens: collectRunCandidateIdentityTokens({
+                runRecord: record,
+                candidateId,
+            }),
+        })),
+        target: {
+            kind: "run",
+            sessionId: record.runId,
+            candidateIds,
+        },
+        runRecord: record,
+    };
+}
+function isRunStatusCompleteForVerification(status) {
+    return status === "pruned" || TERMINAL_RUN_STATUSES.includes(status);
+}
+async function resolveReductionVerifyTarget(input) {
+    const { root, reductionsFilePath, target } = input;
+    const [record] = await readReductionRecords({
+        root,
+        reductionsFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.sessionId,
+    });
+    if (!record) {
+        throw new CliError(`Reduction session \`${target.sessionId}\` not found.`, [], [
+            "Re-run `voratiq reduce` or confirm the session id in `.voratiq/reduce/index.json`.",
+        ]);
+    }
+    if (!TERMINAL_REDUCTION_STATUSES.includes(record.status)) {
+        throw new CliError(`Reduction session \`${target.sessionId}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the reduction to finish before running `voratiq verify`."]);
+    }
+    const referenceRepo = await resolveReductionReferenceRepo({
+        ...input,
+        reductionRecord: record,
+    });
+    const competitiveCandidates = record.reducers
+        .filter((reducer) => reducer.status === "succeeded" && reducer.outputPath)
+        .map((reducer) => ({
+        canonicalId: reducer.agentId,
+        forbiddenIdentityTokens: [reducer.agentId],
+    }));
+    if (referenceRepo.kind === "git") {
+        return {
+            baseRevisionSha: referenceRepo.baseRevisionSha,
+            competitiveCandidates,
+            target: {
+                kind: "reduce",
+                sessionId: record.sessionId,
+            },
+            reductionRecord: record,
+        };
+    }
+    return {
+        competitiveCandidates,
+        target: {
+            kind: "reduce",
+            sessionId: record.sessionId,
+        },
+        reductionRecord: record,
+        referenceRepoUnavailable: {
+            reason: "message-lineage",
+            messageSessionId: referenceRepo.messageSessionId,
+        },
+    };
+}
+async function resolveMessageVerifyTarget(input) {
+    const { root, messagesFilePath, target } = input;
+    const [record] = await readMessageRecords({
+        root,
+        messagesFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.sessionId,
+    });
+    if (!record) {
+        throw new CliError(`Message session \`${target.sessionId}\` not found.`, [], [
+            "Re-run `voratiq message` or confirm the session id in `.voratiq/message/index.json`.",
+        ]);
+    }
+    if (!TERMINAL_MESSAGE_STATUSES.includes(record.status)) {
+        throw new CliError(`Message session \`${target.sessionId}\` is not complete.`, [`Status: \`${record.status}\`.`], [
+            "Wait for the message session to finish before running `voratiq verify`.",
+        ]);
+    }
+    const recipients = resolveVerifiableMessageRecipients(record);
+    if (recipients.length === 0) {
+        throw new CliError(`Message session \`${target.sessionId}\` has no verifiable message responses.`, [
+            "Verification requires at least one succeeded recipient with a durable `response.md` artifact.",
+        ], [
+            "Re-run `voratiq message` to capture at least one succeeded response before running `voratiq verify`.",
+        ]);
+    }
+    return {
+        competitiveCandidates: recipients.map((recipient) => ({
+            canonicalId: recipient.agentId,
+            forbiddenIdentityTokens: [recipient.agentId],
+        })),
+        target: {
+            kind: "message",
+            sessionId: record.sessionId,
+        },
+        messageRecord: record,
+    };
+}
+function collectRunCandidateIdentityTokens(options) {
+    const { runRecord, candidateId } = options;
+    const tokens = new Set();
+    tokens.add(candidateId);
+    for (const agent of runRecord.agents) {
+        if (agent.agentId !== candidateId) {
+            continue;
+        }
+        tokens.add(agent.agentId);
+        if (agent.model.trim().length > 0) {
+            tokens.add(agent.model);
+        }
+    }
+    return Array.from(tokens);
+}
+async function resolveReductionReferenceRepo(options) {
+    const { root, specsFilePath, runsFilePath, reductionsFilePath, messagesFilePath, verificationsFilePath, reductionRecord, seenReductionIds = new Set(), } = options;
+    if (seenReductionIds.has(reductionRecord.sessionId)) {
+        throw new CliError(`Reduction session \`${reductionRecord.sessionId}\` has a recursive target chain.`, [], [
+            "Inspect `.voratiq/reduce/index.json` and repair the reduction target metadata.",
+        ]);
+    }
+    seenReductionIds.add(reductionRecord.sessionId);
+    switch (reductionRecord.target.type) {
+        case "spec": {
+            const [record] = await readSpecRecords({
+                root,
+                specsFilePath,
+                limit: 1,
+                predicate: (entry) => entry.sessionId === reductionRecord.target.id,
+            });
+            if (!record) {
+                throw new CliError(`Spec session \`${reductionRecord.target.id}\` referenced by reduction \`${reductionRecord.sessionId}\` was not found.`);
+            }
+            return {
+                kind: "git",
+                baseRevisionSha: resolveSpecBaseRevisionSha(record, {
+                    ownerLabel: `reduction \`${reductionRecord.sessionId}\``,
+                }),
+            };
+        }
+        case "run": {
+            const { records } = await fetchRunsSafely({
+                root,
+                runsFilePath,
+                runId: reductionRecord.target.id,
+                filters: { includeDeleted: true },
+            }).catch((error) => {
+                if (error instanceof RunRecordNotFoundError) {
+                    throw new RunNotFoundCliError(reductionRecord.target.id);
+                }
+                throw error;
+            });
+            const runRecord = records[0];
+            if (!runRecord) {
+                throw new RunNotFoundCliError(reductionRecord.target.id);
+            }
+            return {
+                kind: "git",
+                baseRevisionSha: runRecord.baseRevisionSha,
+            };
+        }
+        case "verify": {
+            const [verificationRecord] = await readVerificationRecords({
+                root,
+                verificationsFilePath,
+                limit: 1,
+                predicate: (entry) => entry.sessionId === reductionRecord.target.id,
+            });
+            if (!verificationRecord) {
+                throw new CliError(`Verification session \`${reductionRecord.target.id}\` referenced by reduction \`${reductionRecord.sessionId}\` was not found.`);
+            }
+            switch (verificationRecord.target.kind) {
+                case "run": {
+                    const { records } = await fetchRunsSafely({
+                        root,
+                        runsFilePath,
+                        runId: verificationRecord.target.sessionId,
+                        filters: { includeDeleted: true },
+                    }).catch((error) => {
+                        if (error instanceof RunRecordNotFoundError) {
+                            throw new RunNotFoundCliError(verificationRecord.target.sessionId);
+                        }
+                        throw error;
+                    });
+                    const runRecord = records[0];
+                    if (!runRecord) {
+                        throw new RunNotFoundCliError(verificationRecord.target.sessionId);
+                    }
+                    return {
+                        kind: "git",
+                        baseRevisionSha: runRecord.baseRevisionSha,
+                    };
+                }
+                case "spec": {
+                    const [record] = await readSpecRecords({
+                        root,
+                        specsFilePath,
+                        limit: 1,
+                        predicate: (entry) => entry.sessionId === verificationRecord.target.sessionId,
+                    });
+                    if (!record) {
+                        throw new CliError(`Spec session \`${verificationRecord.target.sessionId}\` referenced by verification \`${verificationRecord.sessionId}\` was not found.`);
+                    }
+                    return {
+                        kind: "git",
+                        baseRevisionSha: resolveSpecBaseRevisionSha(record, {
+                            ownerLabel: `verification \`${verificationRecord.sessionId}\``,
+                        }),
+                    };
+                }
+                case "reduce": {
+                    const [parentReduction] = await readReductionRecords({
+                        root,
+                        reductionsFilePath,
+                        limit: 1,
+                        predicate: (entry) => entry.sessionId === verificationRecord.target.sessionId,
+                    });
+                    if (!parentReduction) {
+                        throw new CliError(`Reduction session \`${verificationRecord.target.sessionId}\` referenced by verification \`${verificationRecord.sessionId}\` was not found.`);
+                    }
+                    return await resolveReductionReferenceRepo({
+                        root,
+                        specsFilePath,
+                        runsFilePath,
+                        reductionsFilePath,
+                        messagesFilePath,
+                        verificationsFilePath,
+                        reductionRecord: parentReduction,
+                        seenReductionIds,
+                    });
+                }
+                case "message": {
+                    const [messageRecord] = await readMessageRecords({
+                        root,
+                        messagesFilePath,
+                        limit: 1,
+                        predicate: (entry) => entry.sessionId === verificationRecord.target.sessionId,
+                    });
+                    if (!messageRecord) {
+                        throw new CliError(`Message session \`${verificationRecord.target.sessionId}\` referenced by verification \`${verificationRecord.sessionId}\` was not found.`);
+                    }
+                    return messageRecord.baseRevisionSha
+                        ? {
+                            kind: "git",
+                            baseRevisionSha: messageRecord.baseRevisionSha,
+                        }
+                        : {
+                            kind: "none",
+                            messageSessionId: messageRecord.sessionId,
+                        };
+                }
+            }
+            throw new CliError(`Verification session \`${verificationRecord.sessionId}\` references an unsupported target kind.`);
+        }
+        case "reduce": {
+            const [parentReduction] = await readReductionRecords({
+                root,
+                reductionsFilePath,
+                limit: 1,
+                predicate: (entry) => entry.sessionId === reductionRecord.target.id,
+            });
+            if (!parentReduction) {
+                throw new CliError(`Reduction session \`${reductionRecord.target.id}\` referenced by reduction \`${reductionRecord.sessionId}\` was not found.`);
+            }
+            return await resolveReductionReferenceRepo({
+                root,
+                specsFilePath,
+                runsFilePath,
+                reductionsFilePath,
+                messagesFilePath,
+                verificationsFilePath,
+                reductionRecord: parentReduction,
+                seenReductionIds,
+            });
+        }
+        case "message": {
+            const [messageRecord] = await readMessageRecords({
+                root,
+                messagesFilePath,
+                limit: 1,
+                predicate: (entry) => entry.sessionId === reductionRecord.target.id,
+            });
+            if (!messageRecord) {
+                throw new CliError(`Message session \`${reductionRecord.target.id}\` referenced by reduction \`${reductionRecord.sessionId}\` was not found.`);
+            }
+            return messageRecord.baseRevisionSha
+                ? {
+                    kind: "git",
+                    baseRevisionSha: messageRecord.baseRevisionSha,
+                }
+                : {
+                    kind: "none",
+                    messageSessionId: messageRecord.sessionId,
+                };
+        }
+    }
+}
+function resolveVerifiableMessageRecipients(record) {
+    return record.recipients.flatMap((recipient) => {
+        if (recipient.status !== "succeeded" ||
+            typeof recipient.outputPath !== "string" ||
+            !isCanonicalMessageResponseArtifact(recipient.outputPath)) {
+            return [];
+        }
+        return [
+            {
+                agentId: recipient.agentId,
+                outputPath: recipient.outputPath,
+            },
+        ];
+    });
+}
+function isCanonicalMessageResponseArtifact(outputPath) {
+    return basename(outputPath) === MESSAGE_RESPONSE_FILENAME;
+}
+function resolveSpecBaseRevisionSha(record, options = {}) {
+    if (record.baseRevisionSha) {
+        return record.baseRevisionSha;
+    }
+    const ownerLabel = options.ownerLabel
+        ? `${options.ownerLabel} targets legacy spec session \`${record.sessionId}\``
+        : `Spec session \`${record.sessionId}\``;
+    throw new CliError(`${ownerLabel} is missing \`baseRevisionSha\`.`, [
+        "This spec record was created before base revisions were persisted for spec sessions.",
+    ], [
+        "Re-run `voratiq spec` to regenerate the spec session before running `voratiq verify`.",
+    ]);
+}