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

package/dist/configs/sandbox/loader.js

@@ -1,3 +1,4 @@
+import { basename } from "node:path";
 import process from "node:process";
 import { assertTestHookRegistrationEnabled } from "../../testing/test-hooks.js";
 import { relativeToRoot } from "../../utils/path.js";
@@ -27,12 +28,13 @@ const sandboxConfigLoader = createConfigLoader({
     resolveFilePath: (root, options) => resolveSandboxFilePath(root, options),
     selectReadFile: (options) => options.readFile,
     handleMissing: ({ root, filePath }) => {
-        throw new SandboxConfigurationError(`Missing sandbox configuration at ${relativeToRoot(root, filePath)}.`);
+        throw new SandboxConfigurationError(`Missing \`${basename(relativeToRoot(root, filePath))}\`.`);
     },
     prepareContent: (content, { root, filePath }) => {
         const trimmed = content.trim();
         if (trimmed.length === 0) {
-            throw new SandboxConfigurationError(`${DEFAULT_SANDBOX_ERROR_CONTEXT}: ${relativeToRoot(root, filePath)} is empty.`);
+            const displayPath = basename(relativeToRoot(root, filePath));
+            throw new SandboxConfigurationError(`${DEFAULT_SANDBOX_ERROR_CONTEXT}: \`${displayPath}\` is empty.`);
         }
         return trimmed;
     },
@@ -123,7 +125,7 @@ export function loadSandboxProviderConfig(options, providerIdOverride) {
     const config = loadSandboxConfiguration(options);
     const providerConfig = config.providers[resolvedProviderId];
     if (!providerConfig) {
-        throw new SandboxConfigurationError(`${DEFAULT_SANDBOX_ERROR_CONTEXT}: Unsupported sandbox provider "${resolvedProviderId}" in ${config.displayPath}.`);
+        throw new SandboxConfigurationError(`${DEFAULT_SANDBOX_ERROR_CONTEXT}: Unsupported sandbox provider \`${resolvedProviderId}\` in \`${basename(config.displayPath)}\`.`);
     }
     return {
         providerId: providerConfig.providerId,
@@ -172,7 +174,7 @@ function validateProviderOverrides(providerOverrides, displayPath) {
     const supportedProviders = new Set(listSandboxProviderIds());
     for (const providerId of Object.keys(providerOverrides)) {
         if (!supportedProviders.has(providerId)) {
-            throw new SandboxConfigurationError(`${DEFAULT_SANDBOX_ERROR_CONTEXT}: Unknown provider "${providerId}" in ${displayPath}.`);
+            throw new SandboxConfigurationError(`${DEFAULT_SANDBOX_ERROR_CONTEXT}: Unknown provider \`${providerId}\` in \`${basename(displayPath)}\`.`);
         }
     }
 }

package/dist/configs/sandbox/schemas.js

@@ -1,3 +1,4 @@
+import { basename } from "node:path";
 import { z } from "zod";
 import { relativeToRoot } from "../../utils/path.js";
 import { DEFAULT_SANDBOX_ERROR_CONTEXT, SandboxConfigurationError, } from "./errors.js";
@@ -73,9 +74,10 @@ export function validateSandboxOverrides(document, root, filePath) {
             const issue = error.issues[0];
             const path = issue?.path?.join(".") ?? "";
             const detail = issue?.message ?? "Invalid configuration";
+            const displayPath = basename(relativeToRoot(root, filePath));
             const scopedDetail = path.length > 0
-                ? `${DEFAULT_SANDBOX_ERROR_CONTEXT}: ${relativeToRoot(root, filePath)} (${path}): ${detail}.`
-                : `${DEFAULT_SANDBOX_ERROR_CONTEXT}: ${relativeToRoot(root, filePath)}: ${detail}.`;
+                ? `${DEFAULT_SANDBOX_ERROR_CONTEXT}: \`${displayPath}\` (\`${path}\`): ${detail}.`
+                : `${DEFAULT_SANDBOX_ERROR_CONTEXT}: \`${displayPath}\`: ${detail}.`;
             throw new SandboxConfigurationError(scopedDetail);
         }
         throw error;

package/dist/configs/settings/loader.d.ts

@@ -0,0 +1,7 @@
+import { type RepoSettings } from "./types.js";
+export interface LoadRepoSettingsOptions {
+    root?: string;
+    filePath?: string;
+    readFile?: (path: string) => string;
+}
+export declare function loadRepoSettings(options?: LoadRepoSettingsOptions): RepoSettings;

package/dist/configs/settings/loader.js

@@ -0,0 +1,81 @@
+import process from "node:process";
+import { parseYamlDocument } from "../../utils/yaml-reader.js";
+import { resolveWorkspacePath } from "../../workspace/structure.js";
+import { createConfigLoader } from "../shared/loader-factory.js";
+import { repoSettingsSchema } from "./types.js";
+const SETTINGS_CONFIG_FILENAME = "settings.yaml";
+const DEFAULT_SETTINGS = {
+    bounded: {
+        codex: {
+            globalConfigPolicy: "ignore",
+        },
+    },
+    mcp: {
+        codex: "ask",
+        claude: "ask",
+        gemini: "ask",
+    },
+};
+function cloneSettings(settings) {
+    return {
+        bounded: {
+            codex: {
+                globalConfigPolicy: settings.bounded.codex.globalConfigPolicy,
+            },
+        },
+        mcp: {
+            codex: settings.mcp.codex,
+            claude: settings.mcp.claude,
+            gemini: settings.mcp.gemini,
+        },
+    };
+}
+const repoSettingsLoader = createConfigLoader({
+    resolveFilePath: (root, options) => options.filePath ?? resolveWorkspacePath(root, SETTINGS_CONFIG_FILENAME),
+    selectReadFile: (options) => options.readFile,
+    handleMissing: () => cloneSettings(DEFAULT_SETTINGS),
+    parse: (content, context) => {
+        const parsed = parseSettingsYaml(content, context);
+        const { bounded, mcp } = parsed;
+        return {
+            bounded: {
+                codex: {
+                    globalConfigPolicy: bounded?.codex?.globalConfigPolicy ??
+                        DEFAULT_SETTINGS.bounded.codex.globalConfigPolicy,
+                },
+            },
+            mcp: {
+                codex: mcp?.codex ?? "ask",
+                claude: mcp?.claude ?? "ask",
+                gemini: mcp?.gemini ?? "ask",
+            },
+        };
+    },
+});
+export function loadRepoSettings(options = {}) {
+    const root = options.root ?? process.cwd();
+    return repoSettingsLoader({ ...options, root });
+}
+function parseSettingsYaml(content, context) {
+    let document;
+    try {
+        document = parseYamlDocument(content, {
+            formatError: (detail) => {
+                const reason = detail.reason ?? detail.message ?? "Unknown YAML error";
+                return new Error(reason);
+            },
+            emptyValue: {},
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown YAML error";
+        throw new Error(`Invalid settings file at ${context.filePath}: ${message.replace(/\s+/gu, " ").trim()}`);
+    }
+    const result = repoSettingsSchema.safeParse(document);
+    if (!result.success) {
+        const issue = result.error.issues[0];
+        const detail = issue?.message ? issue.message : "Invalid settings value";
+        throw new Error(`Invalid settings file at ${context.filePath}: ${detail}`);
+    }
+    return result.data;
+}

package/dist/configs/settings/types.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const codexGlobalConfigPolicySchema: z.ZodEnum<{
+    apply: "apply";
+    ignore: "ignore";
+}>;
+export declare const mcpPreferenceSchema: z.ZodEnum<{
+    never: "never";
+    ask: "ask";
+}>;
+export type CodexGlobalConfigPolicy = z.infer<typeof codexGlobalConfigPolicySchema>;
+export type McpPreference = z.infer<typeof mcpPreferenceSchema>;
+export interface RepoSettings {
+    bounded: {
+        codex: {
+            globalConfigPolicy: CodexGlobalConfigPolicy;
+        };
+    };
+    mcp: {
+        codex: McpPreference;
+        claude: McpPreference;
+        gemini: McpPreference;
+    };
+}
+export declare const repoSettingsSchema: z.ZodObject<{
+    bounded: z.ZodOptional<z.ZodObject<{
+        codex: z.ZodOptional<z.ZodObject<{
+            globalConfigPolicy: z.ZodOptional<z.ZodEnum<{
+                apply: "apply";
+                ignore: "ignore";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    mcp: z.ZodOptional<z.ZodObject<{
+        codex: z.ZodOptional<z.ZodEnum<{
+            never: "never";
+            ask: "ask";
+        }>>;
+        claude: z.ZodOptional<z.ZodEnum<{
+            never: "never";
+            ask: "ask";
+        }>>;
+        gemini: z.ZodOptional<z.ZodEnum<{
+            never: "never";
+            ask: "ask";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;

package/dist/configs/settings/types.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export const codexGlobalConfigPolicySchema = z.enum(["ignore", "apply"]);
+export const mcpPreferenceSchema = z.enum(["ask", "never"]);
+export const repoSettingsSchema = z
+    .object({
+    bounded: z
+        .object({
+        codex: z
+            .object({
+            globalConfigPolicy: codexGlobalConfigPolicySchema.optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    mcp: z
+        .object({
+        codex: mcpPreferenceSchema.optional(),
+        claude: mcpPreferenceSchema.optional(),
+        gemini: mcpPreferenceSchema.optional(),
+    })
+        .optional(),
+})
+    .passthrough();

package/dist/configs/verification/errors.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_VERIFICATION_ERROR_CONTEXT: "Verification config `.voratiq/verification.yaml`";
+export declare class VerificationConfigError extends Error {
+    constructor(message: string);
+}
+export declare class MissingVerificationConfigError extends VerificationConfigError {
+    readonly filePath: string;
+    constructor(filePath: string);
+}
+export declare class VerificationYamlParseError extends VerificationConfigError {
+    constructor(message: string);
+}

package/dist/configs/verification/errors.js

@@ -0,0 +1,21 @@
+export const DEFAULT_VERIFICATION_ERROR_CONTEXT = "Verification config `.voratiq/verification.yaml`";
+export class VerificationConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "VerificationConfigError";
+    }
+}
+export class MissingVerificationConfigError extends VerificationConfigError {
+    filePath;
+    constructor(filePath) {
+        super(`${DEFAULT_VERIFICATION_ERROR_CONTEXT} not found: ${filePath}`);
+        this.name = "MissingVerificationConfigError";
+        this.filePath = filePath;
+    }
+}
+export class VerificationYamlParseError extends VerificationConfigError {
+    constructor(message) {
+        super(message);
+        this.name = "VerificationYamlParseError";
+    }
+}

package/dist/configs/verification/loader.d.ts

@@ -0,0 +1,8 @@
+import { type VerificationConfig } from "./types.js";
+export declare function readVerificationConfig(content: string): VerificationConfig;
+export interface LoadVerificationConfigOptions {
+    root?: string;
+    filePath?: string;
+    readFile?: (path: string) => string;
+}
+export declare function loadVerificationConfig(options?: LoadVerificationConfigOptions): VerificationConfig;

package/dist/configs/verification/loader.js

@@ -0,0 +1,43 @@
+import { ZodError } from "zod";
+import { parseYamlDocument, } from "../../utils/yaml-reader.js";
+import { resolveWorkspacePath, VORATIQ_VERIFICATION_CONFIG_FILE, } from "../../workspace/structure.js";
+import { createConfigLoader } from "../shared/loader-factory.js";
+import { formatYamlErrorMessage } from "../shared/yaml-error-formatter.js";
+import { DEFAULT_VERIFICATION_ERROR_CONTEXT, MissingVerificationConfigError, VerificationConfigError, VerificationYamlParseError, } from "./errors.js";
+import { verificationConfigSchema } from "./types.js";
+export function readVerificationConfig(content) {
+    const parsed = parseYamlDocument(content, {
+        formatError: formatVerificationYamlError,
+    });
+    try {
+        return verificationConfigSchema.parse(parsed);
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            const detail = error.issues
+                .map((issue) => issue.message)
+                .join("; ")
+                .trim();
+            throw new VerificationConfigError(`${DEFAULT_VERIFICATION_ERROR_CONTEXT}: ${detail || "invalid mapping"}`);
+        }
+        throw error;
+    }
+}
+function formatVerificationYamlError(detail) {
+    const message = formatYamlErrorMessage(detail, {
+        context: DEFAULT_VERIFICATION_ERROR_CONTEXT,
+    });
+    return new VerificationYamlParseError(message);
+}
+const loadVerificationConfigInternal = createConfigLoader({
+    resolveFilePath: (root, options) => options.filePath ??
+        resolveWorkspacePath(root, VORATIQ_VERIFICATION_CONFIG_FILE),
+    selectReadFile: (options) => options.readFile,
+    handleMissing: ({ filePath }) => {
+        throw new MissingVerificationConfigError(filePath);
+    },
+    parse: (content) => readVerificationConfig(content),
+});
+export function loadVerificationConfig(options = {}) {
+    return loadVerificationConfigInternal(options);
+}

package/dist/configs/verification/methods.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { CHECK_STATUS_VALUES, type CheckStatus } from "../../status/index.js";
+export declare const programmaticSlugSchema: z.ZodString;
+export type ProgrammaticSlug = z.infer<typeof programmaticSlugSchema>;
+export declare const programmaticStatusSchema: z.ZodEnum<{
+    succeeded: "succeeded";
+    failed: "failed";
+    errored: "errored";
+    skipped: "skipped";
+}>;
+export type ProgrammaticStatus = (typeof CHECK_STATUS_VALUES)[number];
+export declare const programmaticCommandSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>;
+export interface ProgrammaticCommandEntry {
+    slug: ProgrammaticSlug;
+    command?: string;
+}
+export declare const rubricTemplateSchema: z.ZodString;
+export type RubricTemplate = z.infer<typeof rubricTemplateSchema>;
+export declare const programmaticCheckResultSchema: z.ZodObject<{
+    slug: z.ZodString;
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+        errored: "errored";
+        skipped: "skipped";
+    }>;
+    command: z.ZodOptional<z.ZodString>;
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    logPath: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProgrammaticCheckResult = z.infer<typeof programmaticCheckResultSchema>;
+export declare function normalizeProgrammaticCommand(command: string | undefined): string | undefined;
+export declare function sanitizeSlugForFilename(slug: string): string;
+export type { CheckStatus };

package/dist/configs/verification/methods.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { checkStatusSchema, } from "../../status/index.js";
+const PROGRAMMATIC_SLUG_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/u;
+const RUBRIC_TEMPLATE_PATTERN = /^[a-z0-9]+(?:[./-][a-z0-9]+)*$/u;
+export const programmaticSlugSchema = z
+    .string()
+    .min(1, "programmatic slug is required")
+    .regex(PROGRAMMATIC_SLUG_PATTERN, "programmatic slug must contain only lowercase letters, numbers, dots, or hyphens");
+export const programmaticStatusSchema = checkStatusSchema;
+export const programmaticCommandSchema = z
+    .union([z.string(), z.null(), z.undefined()])
+    .transform((value) => {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+});
+export const rubricTemplateSchema = z
+    .string()
+    .trim()
+    .min(1, "rubric template is required")
+    .regex(RUBRIC_TEMPLATE_PATTERN, "rubric template must contain only lowercase letters, numbers, dots, slashes, or hyphens");
+export const programmaticCheckResultSchema = z.object({
+    slug: programmaticSlugSchema,
+    status: programmaticStatusSchema,
+    command: z.string().optional(),
+    exitCode: z.number().nullable().optional(),
+    logPath: z.string().optional(),
+    error: z.string().optional(),
+});
+export function normalizeProgrammaticCommand(command) {
+    if (command === undefined) {
+        return undefined;
+    }
+    const trimmed = command.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+export function sanitizeSlugForFilename(slug) {
+    return slug.replace(/[^a-z0-9.-]/gu, "-");
+}

package/dist/configs/verification/programmatic-defaults.d.ts

@@ -0,0 +1,10 @@
+import type { ProgrammaticSlug } from "./methods.js";
+import { type ProgrammaticSuggestion } from "./programmatic-detect.js";
+export interface ProgrammaticDefault {
+    readonly slug: string;
+    readonly command?: string;
+}
+export declare const DEFAULT_PROGRAMMATIC_TEMPLATE_HEADER: readonly string[];
+export declare const DEFAULT_PROGRAMMATIC_DEFAULTS: readonly ProgrammaticDefault[];
+export declare function combineSuggestedProgrammaticCommands(suggestions: readonly ProgrammaticSuggestion[]): Map<ProgrammaticSlug, string | undefined>;
+export declare function listDetectedProgrammaticDefaults(suggestions: readonly ProgrammaticSuggestion[]): ProgrammaticDefault[];

package/dist/configs/verification/programmatic-defaults.js

@@ -0,0 +1,42 @@
+import { CANONICAL_PROGRAMMATIC_SLUGS, } from "./programmatic-detect.js";
+export const DEFAULT_PROGRAMMATIC_TEMPLATE_HEADER = [
+    "# Repo-level verification config.",
+    "# Configure only the stages and methods you use.",
+    "# `run.programmatic` commands execute in candidate workspaces after a run finishes.",
+    "# Leave any command blank (or delete it entirely) to skip that check.",
+    "",
+];
+export const DEFAULT_PROGRAMMATIC_DEFAULTS = [
+    { slug: "format" },
+    { slug: "lint" },
+    { slug: "typecheck" },
+    { slug: "tests" },
+];
+export function combineSuggestedProgrammaticCommands(suggestions) {
+    const combined = new Map();
+    for (const suggestion of suggestions) {
+        for (const [slug, command] of suggestion.commands) {
+            const commands = combined.get(slug);
+            if (!commands) {
+                combined.set(slug, [command]);
+                continue;
+            }
+            if (!commands.includes(command)) {
+                commands.push(command);
+            }
+        }
+    }
+    const resolved = new Map();
+    for (const slug of CANONICAL_PROGRAMMATIC_SLUGS) {
+        const commands = combined.get(slug);
+        resolved.set(slug, commands && commands.length > 0 ? commands.join(" && ") : undefined);
+    }
+    return resolved;
+}
+export function listDetectedProgrammaticDefaults(suggestions) {
+    const commands = combineSuggestedProgrammaticCommands(suggestions);
+    return CANONICAL_PROGRAMMATIC_SLUGS.map((slug) => ({
+        slug,
+        command: commands.get(slug),
+    }));
+}

package/dist/configs/verification/programmatic-detect.d.ts

@@ -0,0 +1,10 @@
+import { type EnvironmentConfig } from "../environment/types.js";
+import type { ProgrammaticSlug } from "./methods.js";
+export declare const CANONICAL_PROGRAMMATIC_SLUGS: ProgrammaticSlug[];
+export interface ProgrammaticSuggestion {
+    source: "node" | "python";
+    commands: Map<ProgrammaticSlug, string>;
+    notes: string[];
+    warnings: string[];
+}
+export declare function detectProgrammaticSuggestions(root: string, environment: EnvironmentConfig): Promise<ProgrammaticSuggestion[]>;

package/dist/configs/{evals/detect.js → verification/programmatic-detect.js}

@@ -2,25 +2,25 @@ import { readFile } from "node:fs/promises";
 import { pathExists } from "../../utils/fs.js";
 import { resolvePath } from "../../utils/path.js";
 import { getPythonEnvironmentPath, isNodeEnvironmentDisabled, isPythonEnvironmentDisabled, } from "../environment/types.js";
-export const CANONICAL_EVAL_SLUGS = [
+export const CANONICAL_PROGRAMMATIC_SLUGS = [
     "format",
     "lint",
     "typecheck",
     "tests",
 ];
-export async function detectEvalSuggestions(root, environment) {
+export async function detectProgrammaticSuggestions(root, environment) {
     const suggestions = [];
-    const nodeSuggestion = await detectNodeEvalSuggestion(root, environment);
+    const nodeSuggestion = await detectNodeSuggestion(root, environment);
     if (nodeSuggestion) {
         suggestions.push(nodeSuggestion);
     }
-    const pythonSuggestion = await detectPythonEvalSuggestion(root, environment);
+    const pythonSuggestion = await detectPythonSuggestion(root, environment);
     if (pythonSuggestion) {
         suggestions.push(pythonSuggestion);
     }
     return suggestions;
 }
-async function detectNodeEvalSuggestion(root, environment) {
+async function detectNodeSuggestion(root, environment) {
     if (isNodeEnvironmentDisabled(environment)) {
         return undefined;
     }
@@ -77,7 +77,7 @@ async function detectNodeEvalSuggestion(root, environment) {
         warnings,
     };
 }
-async function detectPythonEvalSuggestion(root, environment) {
+async function detectPythonSuggestion(root, environment) {
     if (isPythonEnvironmentDisabled(environment)) {
         return undefined;
     }
@@ -185,40 +185,29 @@ async function readPythonDependencies(root) {
     return result;
 }
 function extractPyprojectDependencies(content, result) {
-    const lines = content.split(/\r?\n/);
-    for (const line of lines) {
-        const normalized = line.toLowerCase();
-        if (normalized.includes("ruff")) {
-            result.add("ruff");
-        }
-        if (normalized.includes("pytest")) {
-            result.add("pytest");
-        }
-        if (normalized.includes("pyright")) {
-            result.add("pyright");
-        }
+    const patterns = [
+        /^\s*dependencies\s*=\s*\[/imu,
+        /^\s*\[project.optional-dependencies\]\s*$/imu,
+    ];
+    if (!patterns.some((pattern) => pattern.test(content))) {
+        return;
+    }
+    for (const match of content.matchAll(/"([A-Za-z0-9_.-]+)\\b[^"]*"/gu)) {
+        result.add(match[1].toLowerCase());
     }
 }
 function extractRequirementDependencies(content, result) {
-    const lines = content.split(/\r?\n/);
-    for (const line of lines) {
+    for (const line of content.split("\n")) {
         const trimmed = line.trim();
-        if (trimmed.length === 0 || trimmed.startsWith("#")) {
+        if (!trimmed || trimmed.startsWith("#")) {
             continue;
         }
-        const normalized = trimmed.toLowerCase();
-        if (normalized.startsWith("ruff")) {
-            result.add("ruff");
-        }
-        if (normalized.startsWith("pytest")) {
-            result.add("pytest");
-        }
-        if (normalized.startsWith("pyright")) {
-            result.add("pyright");
+        const match = trimmed.match(/^([A-Za-z0-9_.-]+)/u);
+        if (match?.[1]) {
+            result.add(match[1].toLowerCase());
         }
     }
 }
-function hasDependency(packageJson, name) {
-    const { dependencies = {}, devDependencies = {} } = packageJson;
-    return Boolean(dependencies[name] ?? devDependencies[name]);
+function hasDependency(pkg, name) {
+    return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name]);
 }

package/dist/configs/verification/types.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const verificationRubricEntrySchema: z.ZodObject<{
+    template: z.ZodString;
+}, z.core.$strict>;
+export type VerificationRubricEntry = z.infer<typeof verificationRubricEntrySchema>;
+declare const verificationRubricOnlyStageConfigSchema: z.ZodObject<{
+    rubric: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        template: z.ZodString;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+declare const verificationRunStageConfigSchema: z.ZodObject<{
+    programmatic: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>>, z.ZodTransform<{
+        slug: string;
+        command?: string;
+    }[], Record<string, string | undefined>>>>>;
+    rubric: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        template: z.ZodString;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export type VerificationRubricOnlyStageConfig = z.infer<typeof verificationRubricOnlyStageConfigSchema>;
+export type VerificationRunStageConfig = z.infer<typeof verificationRunStageConfigSchema>;
+export declare const verificationConfigSchema: z.ZodObject<{
+    spec: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        rubric: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            template: z.ZodString;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>;
+    run: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        programmatic: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>>, z.ZodTransform<{
+            slug: string;
+            command?: string;
+        }[], Record<string, string | undefined>>>>>;
+        rubric: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            template: z.ZodString;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>;
+    reduce: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        rubric: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            template: z.ZodString;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>;
+    message: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        rubric: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            template: z.ZodString;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type VerificationConfig = z.infer<typeof verificationConfigSchema>;
+export {};

package/dist/configs/verification/types.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { programmaticCommandSchema, programmaticSlugSchema, } from "./methods.js";
+export const verificationRubricEntrySchema = z
+    .object({
+    template: z.string().trim().min(1),
+})
+    .strict();
+const verificationProgrammaticMapSchema = z
+    .record(z.string(), programmaticCommandSchema)
+    .transform((value) => {
+    const entries = [];
+    for (const [rawSlug, rawCommand] of Object.entries(value)) {
+        const slug = programmaticSlugSchema.parse(rawSlug.trim());
+        const command = rawCommand ?? undefined;
+        entries.push({ slug, ...(command ? { command } : {}) });
+    }
+    return entries;
+});
+const verificationRubricOnlyStageConfigSchema = z
+    .object({
+    rubric: z.array(verificationRubricEntrySchema).optional().default([]),
+})
+    .strict();
+const verificationRunStageConfigSchema = z
+    .object({
+    programmatic: verificationProgrammaticMapSchema.optional().default([]),
+    rubric: z.array(verificationRubricEntrySchema).optional().default([]),
+})
+    .strict();
+export const verificationConfigSchema = z
+    .object({
+    spec: verificationRubricOnlyStageConfigSchema
+        .optional()
+        .default({ rubric: [] }),
+    run: verificationRunStageConfigSchema
+        .optional()
+        .default({ programmatic: [], rubric: [] }),
+    reduce: verificationRubricOnlyStageConfigSchema
+        .optional()
+        .default({ rubric: [] }),
+    message: verificationRubricOnlyStageConfigSchema
+        .optional()
+        .default({ rubric: [] }),
+})
+    .strict();