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

package/dist/domain/verify/competition/programmatic.d.ts

@@ -0,0 +1,15 @@
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { VerificationConfig } from "../../../configs/verification/types.js";
+import type { VerifyProgressRenderer } from "../../../render/transcripts/verify.js";
+import type { VerificationRecordMutators } from "../model/mutators.js";
+import type { VerificationRecord } from "../model/types.js";
+import type { ResolvedVerificationTarget } from "./target.js";
+export declare function executeAndPersistProgrammaticMethod(options: {
+    root: string;
+    verificationId: string;
+    resolvedTarget: ResolvedVerificationTarget;
+    verificationConfig: VerificationConfig;
+    environment: EnvironmentConfig;
+    mutators: VerificationRecordMutators;
+    renderer?: VerifyProgressRenderer;
+}): Promise<VerificationRecord["methods"][number] | undefined>;

package/dist/domain/verify/competition/programmatic.js

@@ -0,0 +1,352 @@
+import { mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { runPreparedWithLimit } from "../../../competition/core.js";
+import { emitStageProgressEvent } from "../../../render/transcripts/stage-progress.js";
+import { toErrorMessage } from "../../../utils/errors.js";
+import { pathExists } from "../../../utils/fs.js";
+import { createDetachedWorktree, getGitStderr, removeWorktree, runGitCommand, } from "../../../utils/git.js";
+import { buildAgentWorkspacePaths } from "../../../workspace/layout.js";
+import { getVerificationProgrammaticResultPath, VORATIQ_VERIFICATION_DIR, } from "../../../workspace/structure.js";
+import { executeProgrammaticChecks } from "../programmatic/runner.js";
+import { writeVerificationArtifact } from "./artifacts.js";
+const PROGRAMMATIC_CANDIDATE_MAX_PARALLEL = 2;
+export async function executeAndPersistProgrammaticMethod(options) {
+    const { root, verificationId, resolvedTarget, verificationConfig, environment, mutators, renderer, } = options;
+    const methodPlan = resolveProgrammaticMethodPlan({
+        resolvedTarget,
+        verificationConfig,
+    });
+    if (methodPlan.kind === "none") {
+        return undefined;
+    }
+    const startedAt = new Date().toISOString();
+    const artifactPath = getVerificationProgrammaticResultPath(verificationId);
+    const methodScope = "runRecord" in resolvedTarget
+        ? { kind: "run" }
+        : { kind: "target" };
+    await mutators.recordMethodSnapshot({
+        method: "programmatic",
+        slug: "programmatic",
+        scope: methodScope,
+        status: "running",
+        startedAt,
+    });
+    emitStageProgressEvent(renderer, {
+        type: "stage.candidate",
+        stage: "verify",
+        candidate: {
+            methodKey: "programmatic",
+            verifierLabel: "programmatic",
+            status: "running",
+            startedAt,
+            artifactPath,
+        },
+    });
+    try {
+        if (methodPlan.kind === "run" && "runRecord" in resolvedTarget) {
+            const candidates = await runPreparedWithLimit({
+                prepared: resolvedTarget.target.candidateIds,
+                maxParallel: PROGRAMMATIC_CANDIDATE_MAX_PARALLEL,
+                executePrepared: async (candidateId) => await executeProgrammaticChecksForRunCandidate({
+                    root,
+                    verificationId,
+                    artifactPath,
+                    candidateId,
+                    checks: methodPlan.checks,
+                    runId: resolvedTarget.target.sessionId,
+                    runRecord: resolvedTarget.runRecord,
+                    baseRevisionSha: resolvedTarget.baseRevisionSha,
+                    environment,
+                }),
+            });
+            await writeVerificationArtifact({
+                root,
+                artifactPath,
+                artifact: {
+                    method: "programmatic",
+                    generatedAt: new Date().toISOString(),
+                    target: resolvedTarget.target,
+                    scope: "run",
+                    candidates,
+                },
+            });
+            const completedRef = {
+                method: "programmatic",
+                slug: "programmatic",
+                scope: methodScope,
+                status: "succeeded",
+                artifactPath,
+                startedAt,
+                completedAt: new Date().toISOString(),
+            };
+            await mutators.recordMethodSnapshot(completedRef);
+            emitStageProgressEvent(renderer, {
+                type: "stage.candidate",
+                stage: "verify",
+                candidate: {
+                    methodKey: "programmatic",
+                    verifierLabel: "programmatic",
+                    status: "succeeded",
+                    startedAt,
+                    completedAt: completedRef.completedAt,
+                    artifactPath,
+                },
+            });
+            return completedRef;
+        }
+        throw new Error(`Programmatic verification is only supported for run targets; \`${resolvedTarget.target.kind}\` targets must use rubric verification.`);
+    }
+    catch (error) {
+        const completedAt = new Date().toISOString();
+        const errorMessage = toErrorMessage(error);
+        await writeFailureProgrammaticArtifact({
+            root,
+            artifactPath,
+            resolvedTarget,
+            generatedAt: completedAt,
+            error: errorMessage,
+        });
+        const failedRef = {
+            method: "programmatic",
+            slug: "programmatic",
+            scope: methodScope,
+            status: "failed",
+            artifactPath,
+            startedAt,
+            completedAt,
+            error: errorMessage,
+        };
+        await mutators.recordMethodSnapshot(failedRef);
+        emitStageProgressEvent(renderer, {
+            type: "stage.candidate",
+            stage: "verify",
+            candidate: {
+                methodKey: "programmatic",
+                verifierLabel: "programmatic",
+                status: "failed",
+                startedAt,
+                completedAt,
+                artifactPath,
+            },
+        });
+        return failedRef;
+    }
+}
+async function executeProgrammaticChecksForRunCandidate(options) {
+    const { root, verificationId, artifactPath, candidateId, checks, runId, runRecord, baseRevisionSha, environment, } = options;
+    const paths = buildAgentWorkspacePaths({
+        root,
+        runId,
+        agentId: candidateId,
+    });
+    const runAgentRecord = runRecord.agents.find((agent) => agent.agentId === candidateId);
+    if (!runAgentRecord) {
+        throw new Error(`Run \`${runId}\` is missing candidate metadata for \`${candidateId}\`.`);
+    }
+    const workspace = await resolveProgrammaticCandidateWorkspace({
+        root,
+        verificationId,
+        candidateId,
+        paths,
+        runId,
+        baseRevisionSha,
+        diffCaptured: runAgentRecord.artifacts?.diffCaptured ?? false,
+    });
+    try {
+        const logsDirectory = resolve(root, dirname(artifactPath), candidateId);
+        const outcome = await executeProgrammaticChecks({
+            checks,
+            cwd: workspace.cwd,
+            root,
+            logsDirectory,
+            environment,
+            envDirectoryGuard: {
+                trustedAbsoluteRoots: workspace.trustedAbsoluteRoots,
+                includeHomeForPythonStack: true,
+                failOnDirectoryPreparationError: true,
+            },
+        });
+        return {
+            candidateId,
+            results: outcome.results,
+        };
+    }
+    finally {
+        await workspace.cleanup();
+    }
+}
+async function resolveProgrammaticCandidateWorkspace(options) {
+    const { root, verificationId, candidateId, paths, runId, baseRevisionSha, diffCaptured, } = options;
+    if (await pathExists(paths.workspacePath)) {
+        return {
+            cwd: paths.workspacePath,
+            trustedAbsoluteRoots: [
+                paths.workspacePath,
+                paths.agentRoot,
+                paths.sandboxHomePath,
+            ],
+            cleanup: async () => { },
+        };
+    }
+    const reconstructionRoot = resolve(root, ".voratiq", VORATIQ_VERIFICATION_DIR, "sessions", verificationId, "programmatic", "reconstructed");
+    await mkdir(reconstructionRoot, { recursive: true });
+    const candidateRoot = await mkdtemp(join(reconstructionRoot, `${candidateId}-`));
+    const reconstructedWorkspacePath = resolve(candidateRoot, "workspace");
+    let worktreeCreated = false;
+    try {
+        try {
+            await createDetachedWorktree({
+                root,
+                worktreePath: reconstructedWorkspacePath,
+                baseRevision: baseRevisionSha,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to reconstruct temporary verification workspace for run \`${runId}\` candidate \`${candidateId}\` at base \`${baseRevisionSha}\`: ${toErrorMessage(error)}`);
+        }
+        worktreeCreated = true;
+        if (diffCaptured) {
+            const diffAbsolutePath = resolve(paths.artifactsPath, "diff.patch");
+            if (!(await pathExists(diffAbsolutePath))) {
+                throw new Error(`Run \`${runId}\` candidate \`${candidateId}\` is missing required durable diff artifact \`${diffAbsolutePath}\`.`);
+            }
+            const diffContent = await readFile(diffAbsolutePath, "utf8");
+            if (diffContent.trim().length > 0) {
+                await applyDurableCandidatePatch({
+                    runId,
+                    candidateId,
+                    workspacePath: reconstructedWorkspacePath,
+                    diffAbsolutePath,
+                });
+            }
+        }
+    }
+    catch (error) {
+        if (worktreeCreated) {
+            await removeWorktree({
+                root,
+                worktreePath: reconstructedWorkspacePath,
+            }).catch(() => { });
+        }
+        await rm(candidateRoot, { recursive: true, force: true }).catch(() => { });
+        throw error;
+    }
+    return {
+        cwd: reconstructedWorkspacePath,
+        trustedAbsoluteRoots: [
+            reconstructedWorkspacePath,
+            paths.agentRoot,
+            paths.sandboxHomePath,
+        ],
+        cleanup: async () => {
+            await removeWorktree({
+                root,
+                worktreePath: reconstructedWorkspacePath,
+            }).catch(() => { });
+            await rm(candidateRoot, { recursive: true, force: true }).catch(() => { });
+        },
+    };
+}
+async function applyDurableCandidatePatch(options) {
+    const { runId, candidateId, workspacePath, diffAbsolutePath } = options;
+    try {
+        await runGitCommand(["apply", "--whitespace=nowarn", "--", diffAbsolutePath], {
+            cwd: workspacePath,
+        });
+    }
+    catch (error) {
+        const detail = getGitStderr(error) ?? toErrorMessage(error);
+        throw new Error(`Failed to apply retained diff for run \`${runId}\` candidate \`${candidateId}\`: ${detail}`);
+    }
+}
+function resolveProgrammaticMethodPlan(options) {
+    const { resolvedTarget, verificationConfig } = options;
+    if (resolvedTarget.target.kind === "run") {
+        const checks = verificationConfig.run.programmatic.reduce((plan, entry) => {
+            const command = entry.command?.trim();
+            if (command) {
+                plan.push({ slug: entry.slug, command });
+            }
+            return plan;
+        }, []);
+        if (checks.length === 0) {
+            return { kind: "none" };
+        }
+        return {
+            kind: "run",
+            checks,
+        };
+    }
+    if (resolvedTarget.target.kind === "message") {
+        return { kind: "none" };
+    }
+    const configuredChecks = extractUnsupportedProgrammaticChecks(resolvedTarget.target.kind === "spec"
+        ? verificationConfig.spec
+        : verificationConfig.reduce);
+    if (configuredChecks.length === 0) {
+        return { kind: "none" };
+    }
+    const checks = configuredChecks.reduce((plan, entry) => {
+        const command = entry.command?.trim();
+        if (command) {
+            plan.push({ slug: entry.slug, command });
+        }
+        return plan;
+    }, []);
+    if (checks.length === 0) {
+        return { kind: "none" };
+    }
+    return {
+        kind: "unsupported",
+        targetKind: resolvedTarget.target.kind,
+        checks,
+    };
+}
+function extractUnsupportedProgrammaticChecks(stageConfig) {
+    const rawEntries = Reflect.get(stageConfig, "programmatic");
+    if (!Array.isArray(rawEntries)) {
+        return [];
+    }
+    return rawEntries.flatMap((entry) => {
+        if (!entry || typeof entry !== "object") {
+            return [];
+        }
+        const slugValue = Reflect.get(entry, "slug");
+        const commandValue = Reflect.get(entry, "command");
+        const slug = typeof slugValue === "string" ? slugValue : undefined;
+        const command = typeof commandValue === "string" ? commandValue : undefined;
+        return slug ? [{ slug, ...(command ? { command } : {}) }] : [];
+    });
+}
+async function writeFailureProgrammaticArtifact(options) {
+    const { root, artifactPath, resolvedTarget, generatedAt, error } = options;
+    if ("runRecord" in resolvedTarget) {
+        await writeVerificationArtifact({
+            root,
+            artifactPath,
+            artifact: {
+                method: "programmatic",
+                generatedAt,
+                status: "failed",
+                error,
+                target: resolvedTarget.target,
+                scope: "run",
+                candidates: [],
+            },
+        });
+        return;
+    }
+    await writeVerificationArtifact({
+        root,
+        artifactPath,
+        artifact: {
+            method: "programmatic",
+            generatedAt,
+            status: "failed",
+            error,
+            target: resolvedTarget.target,
+            scope: "target",
+            results: [],
+        },
+    });
+}

package/dist/domain/verify/competition/prompt.d.ts

@@ -0,0 +1,19 @@
+import type { ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+import type { VerificationTarget } from "../model/types.js";
+import type { StagedVerificationInputs } from "./shared-layout.js";
+export interface RubricTemplateContents {
+    template: string;
+    prompt: string;
+    rubric: string;
+    schema: string;
+}
+export declare function loadRubricTemplate(options: {
+    root: string;
+    template: string;
+}): Promise<RubricTemplateContents>;
+export declare function buildRubricPrompt(options: {
+    template: RubricTemplateContents;
+    target: VerificationTarget;
+    staged: StagedVerificationInputs;
+    extraContextFiles: readonly ResolvedExtraContextFile[];
+}): string;

package/dist/domain/verify/competition/prompt.js

@@ -0,0 +1,63 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { appendConstraints, appendOutputRequirements, buildWorkspaceArtifactRequirements, } from "../../../competition/shared/prompt-helpers.js";
+import { toExtraContextContextSubpath } from "../../../extra-context/contract.js";
+import { VORATIQ_VERIFICATION_DIR } from "../../../workspace/structure.js";
+export async function loadRubricTemplate(options) {
+    const { root, template } = options;
+    const base = resolve(root, ".voratiq", VORATIQ_VERIFICATION_DIR, "templates", template);
+    const [prompt, rubric, schema] = await Promise.all([
+        readFile(resolve(base, "prompt.md"), "utf8"),
+        readFile(resolve(base, "rubric.md"), "utf8"),
+        readFile(resolve(base, "schema.yaml"), "utf8"),
+    ]);
+    return { template, prompt, rubric, schema };
+}
+export function buildRubricPrompt(options) {
+    const { template, target, staged, extraContextFiles } = options;
+    const lines = [];
+    lines.push(`# Verifier Template: ${template.template}`, "", template.prompt.trimEnd(), "", template.rubric.trimEnd(), "", "## Inputs");
+    if (staged.kind === "spec") {
+        lines.push(`- Base repository snapshot (read-only): \`${staged.referenceRepoPath}/\``, `- Original description: \`${staged.descriptionPath}\``, "- Drafts:", ...staged.candidates.map((candidate) => {
+            const parts = [`spec: \`${candidate.specPath}\``];
+            if (candidate.specDataPath) {
+                parts.push(`metadata: \`${candidate.specDataPath}\``);
+            }
+            return `  - ${candidate.alias} (${parts.join(", ")})`;
+        }));
+    }
+    else if (staged.kind === "run") {
+        lines.push(`- Base repository snapshot (read-only): \`${staged.referenceRepoPath}/\``, `- Selected spec: \`${staged.specPath}\``, "- Candidates:", ...staged.candidates.map((candidate) => {
+            const parts = [];
+            if (candidate.diffPath)
+                parts.push(`diff: \`${candidate.diffPath}\``);
+            if (candidate.summaryPath) {
+                parts.push(`summary: \`${candidate.summaryPath}\``);
+            }
+            const suffix = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+            return `  - ${candidate.alias}${suffix}`;
+        }));
+    }
+    else if (staged.kind === "message") {
+        lines.push(`- Original message prompt: \`${staged.promptPath}\``, "- Candidate responses:", ...staged.candidates.map((candidate) => `  - ${candidate.alias}: \`${candidate.responsePath}\``));
+    }
+    else if (staged.kind === "reduce-no-reference") {
+        lines.push(`- No repository snapshot is available for this reduction target because its lineage reaches message session \`${staged.referenceRepoUnavailable.messageSessionId}\` without a durable base revision.`, "- Reduction candidates:", ...staged.candidates.map((candidate) => `  - ${candidate.alias}: \`${candidate.reductionPath}\``));
+    }
+    else {
+        lines.push(`- Base repository snapshot (read-only): \`${staged.referenceRepoPath}/\``, "- Reduction candidates:", ...staged.candidates.map((candidate) => `  - ${candidate.alias}: \`${candidate.reductionPath}\``));
+    }
+    lines.push("", "## Output schema", "Return JSON matching this YAML schema exactly:", "", "```yaml", template.schema.trimEnd(), "```");
+    appendConstraints(lines);
+    appendOutputRequirements(lines, buildWorkspaceArtifactRequirements([
+        {
+            instruction: "Save the structured rubric result as JSON",
+            path: "result.json",
+        },
+    ]));
+    lines.push("", "Target metadata:", `- kind: ${target.kind}`, `- sessionId: ${target.sessionId}`);
+    if (extraContextFiles.length > 0) {
+        lines.push("", "Extra context files:", ...extraContextFiles.map((file) => `- \`context/${toExtraContextContextSubpath(file.stagedRelativePath)}\` (source: \`${file.displayPath}\`)`), "- Treat these files as supplemental context for this invocation.");
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/domain/verify/competition/rubric.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+import type { TeardownController } from "../../../competition/shared/teardown.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { VerificationConfig } from "../../../configs/verification/types.js";
+import type { VerifyProgressRenderer } from "../../../render/transcripts/verify.js";
+import type { VerificationRecordMutators } from "../model/mutators.js";
+import type { VerificationRecord } from "../model/types.js";
+import type { ResolvedVerificationTarget } from "./target.js";
+export declare function executeAndPersistRubricMethods(options: {
+    root: string;
+    verificationId: string;
+    resolvedTarget: ResolvedVerificationTarget;
+    verificationConfig: VerificationConfig;
+    verifierAgents: readonly AgentDefinition[];
+    aliasMap?: Record<string, string>;
+    environment: EnvironmentConfig;
+    extraContextFiles: readonly ResolvedExtraContextFile[];
+    maxParallel: number;
+    teardown: TeardownController;
+    mutators: VerificationRecordMutators;
+    renderer?: VerifyProgressRenderer;
+}): Promise<VerificationRecord["methods"]>;

package/dist/domain/verify/competition/rubric.js

@@ -0,0 +1,77 @@
+import { executeCompetitionWithAdapter } from "../../../competition/command-adapter.js";
+import { createVerifyCompetitionAdapter, } from "./adapter.js";
+import { loadRubricTemplate } from "./prompt.js";
+import { prepareSharedVerificationInputs } from "./shared-layout.js";
+export async function executeAndPersistRubricMethods(options) {
+    const { root, verificationId, resolvedTarget, verificationConfig, verifierAgents, aliasMap, environment, extraContextFiles, maxParallel, teardown, mutators, renderer, } = options;
+    const rubricTemplates = resolvedTarget.target.kind === "spec"
+        ? verificationConfig.spec.rubric
+        : resolvedTarget.target.kind === "run"
+            ? verificationConfig.run.rubric
+            : resolvedTarget.target.kind === "reduce"
+                ? verificationConfig.reduce.rubric
+                : verificationConfig.message.rubric;
+    if (resolvedTarget.target.kind === "message" &&
+        rubricTemplates.length === 0) {
+        throw new Error("Message verification requires at least one configured rubric template under `message.rubric` in `.voratiq/verification.yaml`.");
+    }
+    if (rubricTemplates.length === 0 || verifierAgents.length === 0) {
+        return [];
+    }
+    const sharedInputs = await prepareSharedVerificationInputs({
+        root,
+        verificationId,
+        resolvedTarget,
+        environment,
+        aliasMap,
+    });
+    for (const worktreePath of sharedInputs.worktreesToRemove) {
+        teardown.addWorktree({
+            root,
+            worktreePath,
+            label: "detached reference worktree",
+        });
+    }
+    teardown.addPath(sharedInputs.sharedRootAbsolute, "shared verification inputs");
+    const loadedTemplates = await Promise.all(rubricTemplates.map(async (rubric) => ({
+        rubric,
+        template: await loadRubricTemplate({
+            root,
+            template: rubric.template,
+        }),
+    })));
+    const candidates = loadedTemplates.flatMap(({ template }) => verifierAgents.map((agent) => ({
+        agent,
+        template,
+    })));
+    const executions = await executeCompetitionWithAdapter({
+        candidates,
+        maxParallel,
+        adapter: createVerifyCompetitionAdapter({
+            root,
+            verificationId,
+            resolvedTarget,
+            aliasMap,
+            environment,
+            extraContextFiles,
+            sharedInputs,
+            teardown,
+            mutators,
+            renderer,
+        }),
+    });
+    return executions.map((execution) => ({
+        method: "rubric",
+        template: execution.template,
+        verifierId: execution.verifierId,
+        scope: resolvedTarget.target.kind === "run"
+            ? { kind: "run" }
+            : { kind: "target" },
+        status: execution.status,
+        artifactPath: execution.artifactPath,
+        startedAt: execution.startedAt,
+        completedAt: execution.completedAt,
+        tokenUsage: execution.tokenUsage,
+        ...(execution.status === "failed" ? { error: execution.error } : {}),
+    }));
+}

package/dist/domain/verify/competition/shared-layout.d.ts

@@ -0,0 +1,121 @@
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import { type AgentWorkspacePaths } from "../../../workspace/layout.js";
+import type { ResolvedVerificationTarget } from "./target.js";
+export type SharedVerificationInputs = {
+    kind: "spec";
+    sharedRootAbsolute: string;
+    sharedInputsAbsolute: string;
+    referenceRepoAbsolute: string;
+    worktreesToRemove: readonly string[];
+    candidates: readonly {
+        alias: string;
+        hasSpecData: boolean;
+    }[];
+} | {
+    kind: "run";
+    sharedRootAbsolute: string;
+    sharedInputsAbsolute: string;
+    referenceRepoAbsolute: string;
+    worktreesToRemove: readonly string[];
+    candidates: readonly {
+        alias: string;
+        hasDiff: boolean;
+        hasSummary: boolean;
+    }[];
+} | {
+    kind: "reduce";
+    sharedRootAbsolute: string;
+    sharedInputsAbsolute: string;
+    referenceRepoAbsolute: string;
+    worktreesToRemove: readonly string[];
+    candidates: readonly {
+        alias: string;
+    }[];
+} | {
+    kind: "reduce-no-reference";
+    sharedRootAbsolute: string;
+    sharedInputsAbsolute: string;
+    worktreesToRemove: readonly string[];
+    referenceRepoUnavailable: {
+        reason: "message-lineage";
+        messageSessionId: string;
+    };
+    candidates: readonly {
+        alias: string;
+    }[];
+} | {
+    kind: "message";
+    sharedRootAbsolute: string;
+    sharedInputsAbsolute: string;
+    worktreesToRemove: readonly string[];
+    promptAbsolute: string;
+    candidates: readonly {
+        alias: string;
+    }[];
+};
+export type StagedVerificationInputs = {
+    kind: "spec";
+    referenceRepoPath: string;
+    descriptionPath: string;
+    candidates: readonly {
+        alias: string;
+        specPath: string;
+        specDataPath?: string;
+    }[];
+} | {
+    kind: "run";
+    referenceRepoPath: string;
+    specPath: string;
+    candidates: readonly {
+        alias: string;
+        diffPath?: string;
+        summaryPath?: string;
+    }[];
+} | {
+    kind: "reduce";
+    referenceRepoPath: string;
+    candidates: readonly {
+        alias: string;
+        reductionPath: string;
+    }[];
+} | {
+    kind: "reduce-no-reference";
+    referenceRepoUnavailable: {
+        reason: "message-lineage";
+        messageSessionId: string;
+    };
+    candidates: readonly {
+        alias: string;
+        reductionPath: string;
+    }[];
+} | {
+    kind: "message";
+    promptPath: string;
+    candidates: readonly {
+        alias: string;
+        responsePath: string;
+    }[];
+};
+export declare function prepareSharedVerificationInputs(options: {
+    root: string;
+    verificationId: string;
+    resolvedTarget: ResolvedVerificationTarget;
+    environment: EnvironmentConfig;
+    aliasMap?: Record<string, string>;
+}): Promise<SharedVerificationInputs>;
+export declare function cleanupSharedVerificationInputs(options: {
+    root: string;
+    sharedInputs: SharedVerificationInputs;
+}): Promise<void>;
+export declare function buildStagedVerificationInputs(options: {
+    workspacePaths: AgentWorkspacePaths;
+    sharedInputs: SharedVerificationInputs;
+}): StagedVerificationInputs;
+export declare function sharedInputsUseReferenceRepo(sharedInputs: SharedVerificationInputs): sharedInputs is Extract<SharedVerificationInputs, {
+    kind: "spec" | "run" | "reduce";
+}>;
+export declare function attachVerifierWorkspaceMounts(options: {
+    workspacePath: string;
+    contextPath: string;
+    sharedInputs: SharedVerificationInputs;
+}): Promise<void>;