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

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

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { agentIdSchema } from "../../../configs/agents/types.js";
+import { extractedTokenUsageSchema } from "../../../domain/run/model/types.js";
+import { extraContextMetadataEntrySchema, persistedExtraContextPathSchema, } from "../../../persistence/extra-context.js";
+import { repoRelativeRecordPathSchema } from "../../../persistence/record-path-schema.js";
+import { specAgentStatusSchema, specRecordStatusSchema, TERMINAL_SPEC_AGENT_STATUSES, TERMINAL_SPEC_STATUSES, } from "../../../status/index.js";
+import { validateOperationLifecycleTimestamps, validateRecordLifecycleTimestamps, } from "../../shared/lifecycle.js";
+export { specAgentStatusSchema, specRecordStatusSchema, TERMINAL_SPEC_AGENT_STATUSES, TERMINAL_SPEC_STATUSES, };
+const IN_PROGRESS_SPEC_STATUSES = [
+    "running",
+];
+export const specAgentEntrySchema = z
+    .object({
+    agentId: agentIdSchema,
+    status: specAgentStatusSchema,
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    outputPath: repoRelativeRecordPathSchema.optional(),
+    dataPath: repoRelativeRecordPathSchema.optional(),
+    tokenUsage: extractedTokenUsageSchema.optional(),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((data, ctx) => {
+    if (data.status === "succeeded") {
+        if (!data.outputPath) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["outputPath"],
+                message: "succeeded spec agents must persist `outputPath`",
+            });
+        }
+        if (!data.dataPath) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["dataPath"],
+                message: "succeeded spec agents must persist `dataPath`",
+            });
+        }
+    }
+    validateOperationLifecycleTimestamps({
+        status: data.status,
+        startedAt: data.startedAt,
+        completedAt: data.completedAt,
+    }, ctx, {
+        queued: ["queued"],
+        running: ["running"],
+        terminal: TERMINAL_SPEC_AGENT_STATUSES,
+    });
+});
+export const specRecordSchema = z
+    .object({
+    sessionId: z.string(),
+    createdAt: z.string(),
+    startedAt: z.string(),
+    completedAt: z.string().optional(),
+    status: specRecordStatusSchema,
+    baseRevisionSha: z.string().optional(),
+    description: z.string(),
+    extraContext: z.array(persistedExtraContextPathSchema).optional(),
+    extraContextMetadata: z.array(extraContextMetadataEntrySchema).optional(),
+    agents: z.array(specAgentEntrySchema),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((record, ctx) => {
+    // Enforce the canonical running/terminal timestamp contract.
+    validateRecordLifecycleTimestamps({
+        status: record.status,
+        createdAt: record.createdAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    }, ctx, {
+        queued: [],
+        running: IN_PROGRESS_SPEC_STATUSES,
+        terminal: TERMINAL_SPEC_STATUSES,
+    });
+});
+/**
+ * Derive the session-level spec status from per-agent outcomes.
+ * Returns "succeeded" when at least one agent succeeds; otherwise "failed".
+ */
+export function deriveSpecStatusFromAgents(agentStatuses) {
+    const hasSuccess = agentStatuses.some((status) => status === "succeeded");
+    return hasSuccess ? "succeeded" : "failed";
+}

package/dist/domain/spec/persistence/adapter.d.ts

@@ -0,0 +1,51 @@
+import { type SpecAgentEntry, type SpecRecord, type SpecRecordStatus } from "../model/types.js";
+export type SpecRecordPredicate = (record: SpecRecord) => boolean;
+export interface SpecRecordWarningMissing {
+    kind: "missing-record";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+}
+export interface SpecRecordWarningParse {
+    kind: "parse-error";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+    details: string;
+}
+export type SpecRecordWarning = SpecRecordWarningMissing | SpecRecordWarningParse;
+export interface ReadSpecRecordsOptions {
+    root: string;
+    specsFilePath: string;
+    limit?: number;
+    predicate?: SpecRecordPredicate;
+    onWarning?: (warning: SpecRecordWarning) => void;
+}
+export interface RewriteSpecRecordOptions {
+    root: string;
+    specsFilePath: string;
+    sessionId: string;
+    mutate: (record: SpecRecord) => SpecRecord;
+}
+export interface AppendSpecRecordOptions {
+    root: string;
+    specsFilePath: string;
+    record: SpecRecord;
+}
+export declare function readSpecRecords(options: ReadSpecRecordsOptions): Promise<SpecRecord[]>;
+export declare function appendSpecRecord(options: AppendSpecRecordOptions): Promise<void>;
+export declare function rewriteSpecRecord(options: RewriteSpecRecordOptions): Promise<SpecRecord>;
+export declare function finalizeSpecRecord(options: {
+    root: string;
+    specsFilePath: string;
+    sessionId: string;
+    status: SpecRecordStatus;
+    agents?: readonly SpecAgentEntry[];
+    error?: string | null;
+    completedAt?: string;
+}): Promise<SpecRecord>;
+export declare function flushSpecRecordBuffer(options: {
+    specsFilePath: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function flushAllSpecRecordBuffers(): Promise<void>;

package/dist/domain/spec/persistence/adapter.js

@@ -0,0 +1,140 @@
+import { dirname, join } from "node:path";
+import { mapSessionStoreError, sessionStoreErrorMapper, } from "../../../persistence/error-mapping.js";
+import { SessionRecordParseError } from "../../../persistence/errors.js";
+import { acquireHistoryLock } from "../../../persistence/history-lock.js";
+import { createSessionStore, } from "../../../persistence/session-store.js";
+import { buildRecordLifecycleCompleteFields } from "../../shared/lifecycle.js";
+import { specRecordSchema, TERMINAL_SPEC_STATUSES, } from "../model/types.js";
+const SPEC_INDEX_VERSION = 1;
+const SPEC_RECORD_FILENAME = "record.json";
+const SPEC_HISTORY_LOCK_FILENAME = "history.lock";
+const specPersistence = createSessionStore({
+    recordFilename: SPEC_RECORD_FILENAME,
+    indexVersion: SPEC_INDEX_VERSION,
+    acquireLock: acquireHistoryLock,
+    parseRecord: ({ path, raw }) => {
+        const parsed = JSON.parse(raw);
+        const result = specRecordSchema.safeParse(parsed);
+        if (!result.success) {
+            const issues = result.error.issues
+                .map((issue) => issue.message)
+                .join(", ");
+            throw new SessionRecordParseError(path, issues);
+        }
+        return result.data;
+    },
+    buildIndexEntry: (record) => ({
+        sessionId: record.sessionId,
+        createdAt: record.createdAt,
+        status: record.status,
+    }),
+    getIndexEntryId: (entry) => entry.sessionId,
+    shouldForceFlush: (record) => TERMINAL_SPEC_STATUSES.includes(record.status),
+    getRecordId: (record) => record.sessionId,
+    getRecordStatus: (record) => record.status,
+    readIndexEntries: (parsed) => {
+        const payload = parsed;
+        return Array.isArray(payload.sessions) ? payload.sessions : [];
+    },
+});
+const readSpecRecordsInternal = async (options) => {
+    const { root, specsFilePath, limit, predicate, onWarning } = options;
+    const paths = buildSpecPaths(root, specsFilePath);
+    try {
+        return await specPersistence.readRecords({
+            paths,
+            limit,
+            predicate,
+            onWarning: onWarning
+                ? (warning) => onWarning(mapWarning(warning))
+                : undefined,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+};
+export async function readSpecRecords(options) {
+    return readSpecRecordsInternal(options);
+}
+export async function appendSpecRecord(options) {
+    const { root, specsFilePath, record } = options;
+    const paths = buildSpecPaths(root, specsFilePath);
+    try {
+        await specPersistence.appendRecord({ paths, record });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function rewriteSpecRecord(options) {
+    const { root, specsFilePath, sessionId, mutate } = options;
+    const paths = buildSpecPaths(root, specsFilePath);
+    try {
+        return await specPersistence.rewriteRecord({ paths, sessionId, mutate });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function finalizeSpecRecord(options) {
+    const { root, specsFilePath, sessionId, status, agents, error, completedAt } = options;
+    return await rewriteSpecRecord({
+        root,
+        specsFilePath,
+        sessionId,
+        mutate: (existing) => ({
+            ...existing,
+            status,
+            ...buildRecordLifecycleCompleteFields({ existing, completedAt }),
+            ...(agents ? { agents: [...agents] } : {}),
+            error: error ?? existing.error ?? null,
+        }),
+    });
+}
+export async function flushSpecRecordBuffer(options) {
+    const { specsFilePath, sessionId } = options;
+    const paths = buildSpecPaths("", specsFilePath);
+    try {
+        await specPersistence.flushRecordBuffer({ paths, sessionId });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushAllSpecRecordBuffers() {
+    try {
+        await specPersistence.flushAllRecordBuffers();
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+function buildSpecPaths(root, specsFilePath) {
+    const specsRoot = dirname(specsFilePath);
+    return {
+        root,
+        indexPath: specsFilePath,
+        sessionsDir: join(specsRoot, "sessions"),
+        lockPath: join(specsRoot, SPEC_HISTORY_LOCK_FILENAME),
+    };
+}
+function mapWarning(warning) {
+    if (warning.kind === "parse-error") {
+        const parseWarning = warning;
+        return {
+            kind: "parse-error",
+            sessionId: parseWarning.sessionId,
+            recordPath: parseWarning.recordPath,
+            displayPath: parseWarning.displayPath,
+            details: parseWarning.details,
+        };
+    }
+    const missingWarning = warning;
+    return {
+        kind: "missing-record",
+        sessionId: missingWarning.sessionId,
+        recordPath: missingWarning.recordPath,
+        displayPath: missingWarning.displayPath,
+    };
+}

package/dist/domain/verify/blinding/aliases.d.ts

@@ -0,0 +1,7 @@
+export declare const BLINDED_ALIAS_PATTERN: RegExp;
+export type BlindedCandidateAlias = `v_${string}`;
+export declare function isBlindedCandidateAlias(value: string): value is BlindedCandidateAlias;
+export declare function generateBlindedCandidateAlias(options: {
+    seen: ReadonlySet<string>;
+    length?: number;
+}): BlindedCandidateAlias;

package/dist/domain/verify/blinding/aliases.js

@@ -0,0 +1,23 @@
+import { randomInt } from "node:crypto";
+export const BLINDED_ALIAS_PATTERN = /^v_[a-z0-9]{10,16}$/u;
+const ALIAS_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+export function isBlindedCandidateAlias(value) {
+    return BLINDED_ALIAS_PATTERN.test(value);
+}
+export function generateBlindedCandidateAlias(options) {
+    const { seen, length = 12 } = options;
+    if (!Number.isInteger(length) || length < 10 || length > 16) {
+        throw new Error("Blinded alias length must be an integer in [10, 16].");
+    }
+    for (let attempt = 0; attempt < 512; attempt += 1) {
+        let suffix = "";
+        for (let i = 0; i < length; i += 1) {
+            suffix += ALIAS_ALPHABET[randomInt(ALIAS_ALPHABET.length)];
+        }
+        const alias = `v_${suffix}`;
+        if (!seen.has(alias)) {
+            return alias;
+        }
+    }
+    throw new Error("Failed to generate unique blinded alias.");
+}

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

@@ -0,0 +1,54 @@
+import type { CompetitionCommandAdapter } from "../../../competition/command-adapter.js";
+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 { VerifyProgressRenderer } from "../../../render/transcripts/verify.js";
+import type { TokenUsageResult } from "../../../workspace/chat/token-usage-result.js";
+import { type AgentWorkspacePaths } from "../../../workspace/layout.js";
+import type { ExtractedTokenUsage } from "../../run/model/types.js";
+import type { VerificationRecordMutators } from "../model/mutators.js";
+import { type RubricTemplateContents } from "./prompt.js";
+import { type SharedVerificationInputs } from "./shared-layout.js";
+import type { ResolvedVerificationTarget } from "./target.js";
+export interface VerifyCompetitionCandidate {
+    readonly agent: AgentDefinition;
+    readonly template: RubricTemplateContents;
+}
+export interface PreparedVerifyCompetitionCandidate {
+    readonly candidate: VerifyCompetitionCandidate;
+    readonly workspacePaths: AgentWorkspacePaths;
+}
+export type VerifyCompetitionExecution = {
+    readonly template: string;
+    readonly verifierId: string;
+    readonly status: "failed";
+    readonly artifactPath: string;
+    readonly startedAt: string;
+    readonly completedAt: string;
+    readonly error: string;
+    readonly tokenUsage?: ExtractedTokenUsage;
+    readonly tokenUsageResult: TokenUsageResult;
+} | {
+    readonly template: string;
+    readonly verifierId: string;
+    readonly status: "succeeded";
+    readonly artifactPath: string;
+    readonly startedAt: string;
+    readonly completedAt: string;
+    readonly tokenUsage?: ExtractedTokenUsage;
+    readonly tokenUsageResult: TokenUsageResult;
+};
+export interface CreateVerifyCompetitionAdapterInput {
+    readonly root: string;
+    readonly verificationId: string;
+    readonly resolvedTarget: ResolvedVerificationTarget;
+    readonly aliasMap?: Record<string, string>;
+    readonly environment: EnvironmentConfig;
+    readonly extraContextFiles: readonly ResolvedExtraContextFile[];
+    readonly sharedInputs: SharedVerificationInputs;
+    readonly teardown: TeardownController;
+    readonly mutators: VerificationRecordMutators;
+    readonly renderer?: VerifyProgressRenderer;
+}
+export declare function createVerifyCompetitionAdapter(input: CreateVerifyCompetitionAdapterInput): CompetitionCommandAdapter<VerifyCompetitionCandidate, PreparedVerifyCompetitionCandidate, VerifyCompetitionExecution>;