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

package/dist/domain/verify/competition/shared-layout.js

@@ -0,0 +1,365 @@
+import { copyFile, mkdir, rm, symlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative as relativePath, resolve, sep, } from "node:path";
+import { pathExists } from "../../../utils/fs.js";
+import { createDetachedWorktree, removeWorktree } from "../../../utils/git.js";
+import { ensureWorkspaceDependencies } from "../../../workspace/dependencies.js";
+import { buildAgentWorkspacePaths, } from "../../../workspace/layout.js";
+import { MESSAGE_RESPONSE_FILENAME, VORATIQ_VERIFICATION_SESSIONS_DIR, } from "../../../workspace/structure.js";
+import { aliasForCandidate } from "./blinding.js";
+const BLINDED_VERIFY_SPEC_ARTIFACT_ALLOWLIST = [
+    {
+        sourcePathKey: "outputPath",
+        stagedFilename: "spec.md",
+        required: true,
+    },
+    {
+        sourcePathKey: "dataPath",
+        stagedFilename: "spec.json",
+        required: false,
+    },
+];
+const BLINDED_VERIFY_RUN_ARTIFACT_ALLOWLIST = [
+    {
+        sourceFilename: "diff.patch",
+        stagedFilename: "diff.patch",
+        requiredArtifactStateKey: "diffCaptured",
+    },
+    {
+        sourceFilename: "summary.txt",
+        stagedFilename: "summary.txt",
+        requiredArtifactStateKey: undefined,
+    },
+];
+export async function prepareSharedVerificationInputs(options) {
+    const { root, verificationId, resolvedTarget, environment, aliasMap } = options;
+    const sharedRootAbsolute = resolve(root, ".voratiq", VORATIQ_VERIFICATION_SESSIONS_DIR, verificationId, ".shared");
+    const sharedInputsAbsolute = resolve(sharedRootAbsolute, "inputs");
+    const referenceRepoAbsolute = resolve(sharedRootAbsolute, "reference", "repo");
+    await mkdir(sharedInputsAbsolute, { recursive: true });
+    let detachedWorktreeCreated = false;
+    try {
+        if ("baseRevisionSha" in resolvedTarget) {
+            await mkdir(dirname(referenceRepoAbsolute), { recursive: true });
+            await createDetachedWorktree({
+                root,
+                worktreePath: referenceRepoAbsolute,
+                baseRevision: resolvedTarget.baseRevisionSha,
+            });
+            detachedWorktreeCreated = true;
+            await ensureWorkspaceDependencies({
+                root,
+                workspacePath: referenceRepoAbsolute,
+                environment,
+            });
+        }
+        if ("specRecord" in resolvedTarget) {
+            const descriptionAbsolute = resolve(sharedInputsAbsolute, "description.md");
+            await writeFile(descriptionAbsolute, `${resolvedTarget.specRecord.description.trimEnd()}\n`, "utf8");
+            const draftsDir = resolve(sharedInputsAbsolute, "drafts");
+            await mkdir(draftsDir, { recursive: true });
+            const candidates = await Promise.all(resolvedTarget.specRecord.agents
+                .filter((agent) => agent.status === "succeeded" && agent.outputPath)
+                .map(async (agent) => {
+                const alias = aliasForCandidate(agent.agentId, aliasMap);
+                const dir = resolve(draftsDir, alias);
+                await mkdir(dir, { recursive: true });
+                const copiedArtifacts = await Promise.all(BLINDED_VERIFY_SPEC_ARTIFACT_ALLOWLIST.map((artifact) => copyRetainedVerificationArtifact({
+                    root,
+                    sourceRelativePath: agent[artifact.sourcePathKey],
+                    destinationAbsolute: resolve(dir, artifact.stagedFilename),
+                    ownerLabel: `Spec \`${resolvedTarget.target.sessionId}\` candidate \`${agent.agentId}\``,
+                    artifactLabel: artifact.stagedFilename,
+                    required: artifact.required,
+                })));
+                if (!copiedArtifacts[0]) {
+                    throw new Error(`Spec \`${resolvedTarget.target.sessionId}\` candidate \`${agent.agentId}\` is missing required verification artifact \`spec.md\`.`);
+                }
+                return {
+                    alias,
+                    hasSpecData: copiedArtifacts[1] !== undefined,
+                };
+            }));
+            return {
+                kind: "spec",
+                sharedRootAbsolute,
+                sharedInputsAbsolute,
+                referenceRepoAbsolute,
+                worktreesToRemove: [referenceRepoAbsolute],
+                candidates,
+            };
+        }
+        if ("runRecord" in resolvedTarget) {
+            const specDestination = resolve(sharedInputsAbsolute, "spec.md");
+            await copyFile(resolve(root, resolvedTarget.runRecord.spec.path), specDestination);
+            const candidatesDir = resolve(sharedInputsAbsolute, "candidates");
+            await mkdir(candidatesDir, { recursive: true });
+            const candidates = await Promise.all(resolvedTarget.target.candidateIds.map(async (candidateId) => {
+                const alias = aliasForCandidate(candidateId, aliasMap);
+                const dir = resolve(candidatesDir, alias);
+                await mkdir(dir, { recursive: true });
+                const runPaths = buildAgentWorkspacePaths({
+                    root,
+                    runId: resolvedTarget.target.sessionId,
+                    agentId: candidateId,
+                });
+                const runAgentRecord = resolvedTarget.runRecord.agents.find((agent) => agent.agentId === candidateId);
+                const copiedArtifacts = await Promise.all(BLINDED_VERIFY_RUN_ARTIFACT_ALLOWLIST.map((artifact) => copyArtifactForRunCandidate({
+                    sourceAbsolute: resolve(runPaths.artifactsPath, artifact.sourceFilename),
+                    destinationAbsolute: resolve(dir, artifact.stagedFilename),
+                    required: artifact.requiredArtifactStateKey
+                        ? (runAgentRecord?.artifacts?.[artifact.requiredArtifactStateKey] ?? false)
+                        : false,
+                    runId: resolvedTarget.target.sessionId,
+                    candidateId,
+                    label: artifact.stagedFilename,
+                })));
+                return {
+                    alias,
+                    hasDiff: copiedArtifacts[0] !== undefined,
+                    hasSummary: copiedArtifacts[1] !== undefined,
+                };
+            }));
+            return {
+                kind: "run",
+                sharedRootAbsolute,
+                sharedInputsAbsolute,
+                referenceRepoAbsolute,
+                worktreesToRemove: [referenceRepoAbsolute],
+                candidates,
+            };
+        }
+        if ("messageRecord" in resolvedTarget) {
+            const promptAbsolute = resolve(sharedInputsAbsolute, "prompt.md");
+            await writeFile(promptAbsolute, `${resolvedTarget.messageRecord.prompt.trimEnd()}\n`, "utf8");
+            const candidatesDir = resolve(sharedInputsAbsolute, "candidates");
+            await mkdir(candidatesDir, { recursive: true });
+            const candidates = await Promise.all(resolvedTarget.messageRecord.recipients
+                .filter((recipient) => recipient.status === "succeeded" &&
+                typeof recipient.outputPath === "string" &&
+                basename(recipient.outputPath) === MESSAGE_RESPONSE_FILENAME)
+                .map(async (recipient) => {
+                const alias = aliasForCandidate(recipient.agentId, aliasMap);
+                const dir = resolve(candidatesDir, alias);
+                await mkdir(dir, { recursive: true });
+                await copyRetainedVerificationArtifact({
+                    root,
+                    sourceRelativePath: recipient.outputPath,
+                    destinationAbsolute: resolve(dir, "response.md"),
+                    ownerLabel: `Message \`${resolvedTarget.target.sessionId}\` recipient \`${recipient.agentId}\``,
+                    artifactLabel: "response.md",
+                    required: true,
+                });
+                return { alias };
+            }));
+            return {
+                kind: "message",
+                sharedRootAbsolute,
+                sharedInputsAbsolute,
+                worktreesToRemove: [],
+                promptAbsolute,
+                candidates,
+            };
+        }
+        const candidatesDir = resolve(sharedInputsAbsolute, "candidates");
+        await mkdir(candidatesDir, { recursive: true });
+        const candidates = await Promise.all(resolvedTarget.reductionRecord.reducers
+            .filter((reducer) => reducer.status === "succeeded" && reducer.outputPath)
+            .map(async (reducer) => {
+            const alias = aliasForCandidate(reducer.agentId, aliasMap);
+            const dir = resolve(candidatesDir, alias);
+            await mkdir(dir, { recursive: true });
+            await copyRetainedVerificationArtifact({
+                root,
+                sourceRelativePath: reducer.outputPath,
+                destinationAbsolute: resolve(dir, "reduction.md"),
+                ownerLabel: `Reduction \`${resolvedTarget.target.sessionId}\` candidate \`${reducer.agentId}\``,
+                artifactLabel: "reduction.md",
+                required: true,
+            });
+            return { alias };
+        }));
+        if ("referenceRepoUnavailable" in resolvedTarget) {
+            return {
+                kind: "reduce-no-reference",
+                sharedRootAbsolute,
+                sharedInputsAbsolute,
+                worktreesToRemove: [],
+                referenceRepoUnavailable: resolvedTarget.referenceRepoUnavailable,
+                candidates,
+            };
+        }
+        return {
+            kind: "reduce",
+            sharedRootAbsolute,
+            sharedInputsAbsolute,
+            referenceRepoAbsolute,
+            worktreesToRemove: [referenceRepoAbsolute],
+            candidates,
+        };
+    }
+    catch (error) {
+        if (detachedWorktreeCreated) {
+            await removeWorktree({
+                root,
+                worktreePath: referenceRepoAbsolute,
+            }).catch(() => { });
+        }
+        await rm(sharedRootAbsolute, {
+            recursive: true,
+            force: true,
+        }).catch(() => { });
+        throw error;
+    }
+}
+export async function cleanupSharedVerificationInputs(options) {
+    const { root, sharedInputs } = options;
+    for (const worktreePath of sharedInputs.worktreesToRemove) {
+        await removeWorktree({ root, worktreePath }).catch(() => { });
+    }
+    await rm(sharedInputs.sharedRootAbsolute, {
+        recursive: true,
+        force: true,
+    }).catch(() => { });
+}
+export function buildStagedVerificationInputs(options) {
+    const { workspacePaths, sharedInputs } = options;
+    const inputsRoot = resolve(workspacePaths.workspacePath, "inputs");
+    if (sharedInputs.kind === "spec") {
+        return {
+            kind: "spec",
+            referenceRepoPath: "reference_repo",
+            descriptionPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "description.md")),
+            candidates: sharedInputs.candidates.map((candidate) => ({
+                alias: candidate.alias,
+                specPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "drafts", candidate.alias, "spec.md")),
+                ...(candidate.hasSpecData
+                    ? {
+                        specDataPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "drafts", candidate.alias, "spec.json")),
+                    }
+                    : {}),
+            })),
+        };
+    }
+    if (sharedInputs.kind === "run") {
+        return {
+            kind: "run",
+            referenceRepoPath: "reference_repo",
+            specPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "spec.md")),
+            candidates: sharedInputs.candidates.map((candidate) => ({
+                alias: candidate.alias,
+                ...(candidate.hasDiff
+                    ? {
+                        diffPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "candidates", candidate.alias, "diff.patch")),
+                    }
+                    : {}),
+                ...(candidate.hasSummary
+                    ? {
+                        summaryPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "candidates", candidate.alias, "summary.txt")),
+                    }
+                    : {}),
+            })),
+        };
+    }
+    if (sharedInputs.kind === "message") {
+        return {
+            kind: "message",
+            promptPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "prompt.md")),
+            candidates: sharedInputs.candidates.map((candidate) => ({
+                alias: candidate.alias,
+                responsePath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "candidates", candidate.alias, "response.md")),
+            })),
+        };
+    }
+    if (sharedInputs.kind === "reduce-no-reference") {
+        return {
+            kind: "reduce-no-reference",
+            referenceRepoUnavailable: sharedInputs.referenceRepoUnavailable,
+            candidates: sharedInputs.candidates.map((candidate) => ({
+                alias: candidate.alias,
+                reductionPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "candidates", candidate.alias, "reduction.md")),
+            })),
+        };
+    }
+    return {
+        kind: "reduce",
+        referenceRepoPath: "reference_repo",
+        candidates: sharedInputs.candidates.map((candidate) => ({
+            alias: candidate.alias,
+            reductionPath: toWorkspaceRelative(workspacePaths.workspacePath, resolve(inputsRoot, "candidates", candidate.alias, "reduction.md")),
+        })),
+    };
+}
+export function sharedInputsUseReferenceRepo(sharedInputs) {
+    return (sharedInputs.kind === "spec" ||
+        sharedInputs.kind === "run" ||
+        sharedInputs.kind === "reduce");
+}
+export async function attachVerifierWorkspaceMounts(options) {
+    const { workspacePath, contextPath, sharedInputs } = options;
+    await attachSharedInputsToVerifierWorkspace({
+        workspacePath,
+        sharedInputsAbsolute: sharedInputs.sharedInputsAbsolute,
+    });
+    if (sharedInputsUseReferenceRepo(sharedInputs)) {
+        await attachWorkspaceDirectorySymlink({
+            workspacePath,
+            mountName: "reference_repo",
+            targetAbsolutePath: sharedInputs.referenceRepoAbsolute,
+        });
+    }
+    await attachWorkspaceDirectorySymlink({
+        workspacePath,
+        mountName: "context",
+        targetAbsolutePath: contextPath,
+    });
+}
+async function attachSharedInputsToVerifierWorkspace(options) {
+    const { workspacePath, sharedInputsAbsolute } = options;
+    await mkdir(workspacePath, { recursive: true });
+    const verifierInputsPath = join(workspacePath, "inputs");
+    await rm(verifierInputsPath, { recursive: true, force: true }).catch(() => { });
+    const linkType = process.platform === "win32" ? "junction" : "dir";
+    await symlink(sharedInputsAbsolute, verifierInputsPath, linkType);
+}
+async function attachWorkspaceDirectorySymlink(options) {
+    const { workspacePath, mountName, targetAbsolutePath } = options;
+    const mountPath = join(workspacePath, mountName);
+    await rm(mountPath, { recursive: true, force: true }).catch(() => { });
+    const linkType = process.platform === "win32" ? "junction" : "dir";
+    await symlink(targetAbsolutePath, mountPath, linkType);
+}
+function toWorkspaceRelative(workspacePath, absoluteWorkspaceFilePath) {
+    return relativePath(workspacePath, absoluteWorkspaceFilePath)
+        .split(sep)
+        .join("/");
+}
+async function copyIfExists(sourceAbsolute, destinationAbsolute) {
+    if (!(await pathExists(sourceAbsolute))) {
+        return undefined;
+    }
+    await copyFile(sourceAbsolute, destinationAbsolute);
+    return destinationAbsolute;
+}
+async function copyRetainedVerificationArtifact(options) {
+    const { root, sourceRelativePath, destinationAbsolute, ownerLabel, artifactLabel, required, } = options;
+    if (!sourceRelativePath) {
+        if (!required) {
+            return undefined;
+        }
+        throw new Error(`${ownerLabel} is missing required verification artifact \`${artifactLabel}\`.`);
+    }
+    const sourceAbsolute = resolve(root, sourceRelativePath);
+    const copied = await copyIfExists(sourceAbsolute, destinationAbsolute);
+    if (copied || !required) {
+        return copied;
+    }
+    throw new Error(`${ownerLabel} is missing required verification artifact \`${artifactLabel}\` (${sourceAbsolute}).`);
+}
+async function copyArtifactForRunCandidate(options) {
+    const { sourceAbsolute, destinationAbsolute, required, runId, candidateId, label, } = options;
+    const copied = await copyIfExists(sourceAbsolute, destinationAbsolute);
+    if (copied || !required) {
+        return copied;
+    }
+    throw new Error(`Run \`${runId}\` candidate \`${candidateId}\` is missing required verification artifact \`${label}\` (${sourceAbsolute}).`);
+}

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

@@ -0,0 +1,47 @@
+import type { MessageRecord } from "../../message/model/types.js";
+import type { ReductionRecord } from "../../reduce/model/types.js";
+import type { RunRecord } from "../../run/model/types.js";
+import type { SpecRecord } from "../../spec/model/types.js";
+import type { VerificationTarget } from "../model/types.js";
+export interface VerificationCompetitiveCandidate {
+    canonicalId: string;
+    forbiddenIdentityTokens: readonly string[];
+}
+export type ResolvedVerificationTarget = {
+    baseRevisionSha: string;
+    competitiveCandidates: readonly VerificationCompetitiveCandidate[];
+    target: Extract<VerificationTarget, {
+        kind: "spec";
+    }>;
+    specRecord: SpecRecord;
+} | {
+    baseRevisionSha: string;
+    competitiveCandidates: readonly VerificationCompetitiveCandidate[];
+    target: Extract<VerificationTarget, {
+        kind: "run";
+    }>;
+    runRecord: RunRecord;
+} | {
+    baseRevisionSha: string;
+    competitiveCandidates: readonly VerificationCompetitiveCandidate[];
+    target: Extract<VerificationTarget, {
+        kind: "reduce";
+    }>;
+    reductionRecord: ReductionRecord;
+} | {
+    competitiveCandidates: readonly VerificationCompetitiveCandidate[];
+    target: Extract<VerificationTarget, {
+        kind: "reduce";
+    }>;
+    reductionRecord: ReductionRecord;
+    referenceRepoUnavailable: {
+        reason: "message-lineage";
+        messageSessionId: string;
+    };
+} | {
+    competitiveCandidates: readonly VerificationCompetitiveCandidate[];
+    target: Extract<VerificationTarget, {
+        kind: "message";
+    }>;
+    messageRecord: MessageRecord;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+import type { VerificationMethodResultRef, VerificationRecord, VerificationStatus } from "./types.js";
+export interface VerificationRecordMutators {
+    recordVerificationRunning: (timestamp?: string) => Promise<void>;
+    recordMethodSnapshot: (method: VerificationMethodResultRef) => Promise<void>;
+    completeVerification: (options: {
+        status: VerificationStatus;
+        error?: string | null;
+    }) => Promise<VerificationRecord>;
+    readRecord: () => Promise<VerificationRecord | undefined>;
+}
+export interface CreateVerificationRecordMutatorsInput {
+    readonly root: string;
+    readonly verificationsFilePath: string;
+    readonly verificationId: string;
+}
+export declare function createVerificationRecordMutators(input: CreateVerificationRecordMutatorsInput): VerificationRecordMutators;

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

@@ -0,0 +1,126 @@
+import { buildLifecycleStartFields, buildRecordLifecycleCompleteFields, } from "../../shared/lifecycle.js";
+import { rewriteVerificationRecord } from "../persistence/adapter.js";
+export function createVerificationRecordMutators(input) {
+    const { root, verificationsFilePath, verificationId } = input;
+    return {
+        recordVerificationRunning: async (timestamp = new Date().toISOString()) => {
+            await rewriteVerificationRecord({
+                root,
+                verificationsFilePath,
+                sessionId: verificationId,
+                mutate: (existing) => {
+                    if (existing.status !== "queued" && existing.status !== "running") {
+                        return existing;
+                    }
+                    return {
+                        ...existing,
+                        status: "running",
+                        ...buildLifecycleStartFields({
+                            existingStartedAt: existing.startedAt,
+                            timestamp,
+                        }),
+                    };
+                },
+            });
+        },
+        recordMethodSnapshot: async (method) => {
+            await rewriteVerificationRecord({
+                root,
+                verificationsFilePath,
+                sessionId: verificationId,
+                mutate: (existing) => {
+                    if (existing.status !== "queued" && existing.status !== "running") {
+                        return existing;
+                    }
+                    const methods = [...existing.methods];
+                    const index = methods.findIndex((entry) => methodRefKey(entry) === methodRefKey(method));
+                    const current = index >= 0 ? methods[index] : undefined;
+                    const merged = mergeMethodRefs(current, method);
+                    if (index >= 0) {
+                        methods[index] = merged;
+                    }
+                    else {
+                        methods.push(merged);
+                    }
+                    const startedAt = merged.startedAt;
+                    return {
+                        ...existing,
+                        status: existing.status === "queued" && merged.status === "running"
+                            ? "running"
+                            : existing.status,
+                        ...(startedAt
+                            ? buildLifecycleStartFields({
+                                existingStartedAt: existing.startedAt,
+                                timestamp: startedAt,
+                            })
+                            : {}),
+                        methods,
+                    };
+                },
+            });
+        },
+        completeVerification: async ({ status, error }) => await rewriteVerificationRecord({
+            root,
+            verificationsFilePath,
+            sessionId: verificationId,
+            mutate: (existing) => {
+                if (existing.status !== "queued" && existing.status !== "running") {
+                    return existing;
+                }
+                const completedAt = new Date().toISOString();
+                return {
+                    ...existing,
+                    status,
+                    ...buildRecordLifecycleCompleteFields({
+                        existing,
+                        startedAt: existing.startedAt ?? completedAt,
+                        completedAt,
+                    }),
+                    ...(error ? { error } : {}),
+                };
+            },
+            forceFlush: true,
+        }),
+        readRecord: async () => await rewriteVerificationRecord({
+            root,
+            verificationsFilePath,
+            sessionId: verificationId,
+            mutate: (record) => record,
+        }),
+    };
+}
+function methodRefKey(method) {
+    return method.method === "programmatic"
+        ? `${method.method}:${method.scope.kind}`
+        : `${method.method}:${method.template}:${method.verifierId}:${method.scope.kind}:${method.scope.kind === "candidate" ? method.scope.candidateId : "_"}`;
+}
+function mergeMethodRefs(existing, incoming) {
+    if (existing &&
+        isTerminalVerificationStatus(existing.status) &&
+        !isTerminalVerificationStatus(incoming.status)) {
+        return existing;
+    }
+    const merged = {
+        ...(existing ?? {}),
+        ...incoming,
+    };
+    if (incoming.artifactPath === undefined && existing?.artifactPath) {
+        merged.artifactPath = existing.artifactPath;
+    }
+    if (incoming.startedAt === undefined && existing?.startedAt) {
+        merged.startedAt = existing.startedAt;
+    }
+    if (incoming.completedAt === undefined && existing?.completedAt) {
+        merged.completedAt = existing.completedAt;
+    }
+    if (incoming.tokenUsage === undefined && existing?.tokenUsage) {
+        merged.tokenUsage = existing.tokenUsage;
+    }
+    if (incoming.error === undefined && existing?.error !== undefined) {
+        merged.error = existing.error;
+    }
+    return merged;
+}
+function isTerminalVerificationStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "aborted";
+}