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

package/dist/workspace/structure.js

@@ -1,35 +1,57 @@
 import { agentIdSchema } from "../configs/agents/types.js";
-import { evalSlugSchema } from "../configs/evals/types.js";
 import { assertRepoRelativePath, resolvePathWithinRoot, } from "../utils/path.js";
 export const VORATIQ_DIR = ".voratiq";
-export const VORATIQ_RUNS_DIR = "runs";
-export const VORATIQ_RUNS_FILE = "runs/index.json";
-export const VORATIQ_RUNS_SESSIONS_DIR = "runs/sessions";
+export const VORATIQ_SPEC_DIR = "spec";
+export const VORATIQ_SPEC_FILE = "spec/index.json";
+export const VORATIQ_SPEC_SESSIONS_DIR = "spec/sessions";
+export const VORATIQ_RUN_DIR = "run";
+export const VORATIQ_RUN_FILE = "run/index.json";
+export const VORATIQ_RUN_SESSIONS_DIR = "run/sessions";
+export const VORATIQ_REDUCTION_DIR = "reduce";
+export const VORATIQ_REDUCTION_FILE = "reduce/index.json";
+export const VORATIQ_REDUCTION_SESSIONS_DIR = "reduce/sessions";
+export const VORATIQ_VERIFICATION_DIR = "verify";
+export const VORATIQ_VERIFICATION_FILE = "verify/index.json";
+export const VORATIQ_VERIFICATION_SESSIONS_DIR = "verify/sessions";
+export const VORATIQ_VERIFICATION_TEMPLATES_DIR = "verify/templates";
+export const VORATIQ_MESSAGE_DIR = "message";
+export const VORATIQ_MESSAGE_FILE = "message/index.json";
+export const VORATIQ_MESSAGE_SESSIONS_DIR = "message/sessions";
+export const VORATIQ_INTERACTIVE_DIR = "interactive";
+export const VORATIQ_INTERACTIVE_FILE = "interactive/index.json";
+export const VORATIQ_INTERACTIVE_SESSIONS_DIR = "interactive/sessions";
+export const VORATIQ_INDEX_FILENAME = "index.json";
+export const VORATIQ_HISTORY_LOCK_FILENAME = "history.lock";
+export const VORATIQ_SESSIONS_DIRNAME = "sessions";
 export const VORATIQ_AGENTS_FILE = "agents.yaml";
-export const VORATIQ_EVALS_FILE = "evals.yaml";
+export const VORATIQ_VERIFICATION_CONFIG_FILE = "verification.yaml";
 export const VORATIQ_ENVIRONMENT_FILE = "environment.yaml";
 export const VORATIQ_SANDBOX_FILE = "sandbox.yaml";
+export const VORATIQ_ORCHESTRATION_FILE = "orchestration.yaml";
 export const WORKSPACE_DIRNAME = "workspace";
-export const EVALS_DIRNAME = "evals";
+export const CONTEXT_DIRNAME = "context";
 export const STDOUT_FILENAME = "stdout.log";
 export const STDERR_FILENAME = "stderr.log";
 export const DIFF_FILENAME = "diff.patch";
 export const SUMMARY_FILENAME = "summary.txt";
 export const CHAT_JSON_FILENAME = "chat.json";
 export const CHAT_JSONL_FILENAME = "chat.jsonl";
-export const PROMPT_FILENAME = "prompt.txt";
+export const REDUCTION_FILENAME = "reduction.md";
+export const REDUCTION_DATA_FILENAME = "reduction.json";
+export const MESSAGE_RESPONSE_FILENAME = "response.md";
 export const RUNTIME_DIRNAME = "runtime";
 export const ARTIFACTS_DIRNAME = "artifacts";
 export const MANIFEST_FILENAME = "manifest.json";
+export const REDUCTION_ARTIFACT_INFO_FILENAME = "artifact-information.json";
 export const SANDBOX_DIRNAME = "sandbox";
 export const SANDBOX_SETTINGS_FILENAME = "sandbox.json";
+export const PROGRAMMATIC_RESULT_FILENAME = "result.json";
 export function resolveWorkspacePath(root, ...segments) {
     return resolvePathWithinRoot(root, [VORATIQ_DIR, ...segments]);
 }
 export function formatWorkspacePath(...segments) {
     return [VORATIQ_DIR, ...segments].join("/");
 }
-const RUNS_SESSION_SEGMENTS = [VORATIQ_RUNS_DIR, "sessions"];
 function assertPathSegment(label, value) {
     if (typeof value !== "string") {
         throw new Error(`${label} must be a string`);
@@ -38,55 +60,233 @@ function assertPathSegment(label, value) {
         throw new Error(`${label} must be non-empty`);
     }
     if (value.includes("/") || value.includes("\\") || value.includes("..")) {
-        throw new Error(`${label} "${value}" must not contain path separators`);
+        throw new Error(`${label} \`${value}\` must not contain path separators`);
     }
     return value;
 }
+function assertDomainSegment(domain) {
+    return assertPathSegment("domain", domain);
+}
+function assertSessionId(sessionId) {
+    return assertPathSegment("sessionId", sessionId);
+}
+function formatDomainScopedPath(domain, ...segments) {
+    const safeDomain = assertDomainSegment(domain);
+    const scoped = formatWorkspacePath(safeDomain, ...segments);
+    return assertRepoRelativePath(scoped);
+}
+function formatSessionScopedPath(domain, sessionId, ...segments) {
+    const safeSessionId = assertSessionId(sessionId);
+    return formatDomainScopedPath(domain, VORATIQ_SESSIONS_DIRNAME, safeSessionId, ...segments);
+}
+function formatAgentSessionScopedPath(domain, sessionId, agentId, ...segments) {
+    const safeAgentId = agentIdSchema.parse(agentId);
+    return formatSessionScopedPath(domain, sessionId, safeAgentId, ...segments);
+}
 function formatRunScopedPath(runId, ...segments) {
     const safeRunId = assertPathSegment("runId", runId);
-    const scoped = formatWorkspacePath(...RUNS_SESSION_SEGMENTS, safeRunId, ...segments);
+    const scoped = formatDomainScopedPath(VORATIQ_RUN_DIR, VORATIQ_SESSIONS_DIRNAME, safeRunId, ...segments);
     return assertRepoRelativePath(scoped);
 }
 function formatAgentScopedPath(runId, agentId, ...segments) {
     const safeAgentId = agentIdSchema.parse(agentId);
     return formatRunScopedPath(runId, safeAgentId, ...segments);
 }
-function assertEvalSlug(evalSlug) {
-    return evalSlugSchema.parse(assertPathSegment("evalSlug", evalSlug));
+export function getDomainDirectoryPath(domain) {
+    return formatDomainScopedPath(domain);
+}
+export function getDomainIndexPath(domain) {
+    return formatDomainScopedPath(domain, VORATIQ_INDEX_FILENAME);
+}
+export function getDomainHistoryLockPath(domain) {
+    return formatDomainScopedPath(domain, VORATIQ_HISTORY_LOCK_FILENAME);
+}
+export function getSpecDirectoryPath() {
+    return getDomainDirectoryPath(VORATIQ_SPEC_DIR);
+}
+export function getSpecIndexPath() {
+    return getDomainIndexPath(VORATIQ_SPEC_DIR);
+}
+export function getSpecHistoryLockPath() {
+    return getDomainHistoryLockPath(VORATIQ_SPEC_DIR);
+}
+export function getSpecSessionsDirectoryPath() {
+    return getDomainSessionsDirectoryPath(VORATIQ_SPEC_DIR);
+}
+export function getReductionDirectoryPath() {
+    return getDomainDirectoryPath(VORATIQ_REDUCTION_DIR);
+}
+export function getReductionIndexPath() {
+    return getDomainIndexPath(VORATIQ_REDUCTION_DIR);
+}
+export function getReductionSessionsDirectoryPath() {
+    return getDomainSessionsDirectoryPath(VORATIQ_REDUCTION_DIR);
+}
+export function getVerificationDirectoryPath() {
+    return getDomainDirectoryPath(VORATIQ_VERIFICATION_DIR);
+}
+export function getVerificationIndexPath() {
+    return getDomainIndexPath(VORATIQ_VERIFICATION_DIR);
+}
+export function getVerificationSessionsDirectoryPath() {
+    return getDomainSessionsDirectoryPath(VORATIQ_VERIFICATION_DIR);
+}
+export function getMessageDirectoryPath() {
+    return getDomainDirectoryPath(VORATIQ_MESSAGE_DIR);
+}
+export function getMessageIndexPath() {
+    return getDomainIndexPath(VORATIQ_MESSAGE_DIR);
+}
+export function getMessageSessionsDirectoryPath() {
+    return getDomainSessionsDirectoryPath(VORATIQ_MESSAGE_DIR);
+}
+export function getInteractiveDirectoryPath() {
+    return getDomainDirectoryPath(VORATIQ_INTERACTIVE_DIR);
+}
+export function getInteractiveIndexPath() {
+    return getDomainIndexPath(VORATIQ_INTERACTIVE_DIR);
+}
+export function getInteractiveHistoryLockPath() {
+    return formatDomainScopedPath(VORATIQ_INTERACTIVE_DIR, "history.lock");
+}
+export function getInteractiveSessionsDirectoryPath() {
+    return getDomainSessionsDirectoryPath(VORATIQ_INTERACTIVE_DIR);
+}
+export function getInteractiveSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_INTERACTIVE_DIR, sessionId);
+}
+export function getInteractiveSessionRecordPath(sessionId) {
+    return formatSessionScopedPath(VORATIQ_INTERACTIVE_DIR, sessionId, "record.json");
+}
+export function getInteractiveSessionArtifactsDirectoryPath(sessionId) {
+    return formatSessionScopedPath(VORATIQ_INTERACTIVE_DIR, sessionId, ARTIFACTS_DIRNAME);
+}
+export function getDomainSessionsDirectoryPath(domain) {
+    return formatDomainScopedPath(domain, VORATIQ_SESSIONS_DIRNAME);
+}
+export function getSessionDirectoryPath(domain, sessionId) {
+    return formatSessionScopedPath(domain, sessionId);
+}
+export function getSpecSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_SPEC_DIR, sessionId);
+}
+export function getReductionSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_REDUCTION_DIR, sessionId);
+}
+export function getMessageSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_MESSAGE_DIR, sessionId);
+}
+export function getVerificationSessionDirectoryPath(sessionId) {
+    return getSessionDirectoryPath(VORATIQ_VERIFICATION_DIR, sessionId);
+}
+export function getVerificationSessionArtifactsDirectoryPath(sessionId) {
+    return formatSessionScopedPath(VORATIQ_VERIFICATION_DIR, sessionId, ARTIFACTS_DIRNAME);
+}
+export function getVerificationSessionRecordPath(sessionId) {
+    return formatSessionScopedPath(VORATIQ_VERIFICATION_DIR, sessionId, "record.json");
+}
+export function getVerificationProgrammaticResultPath(sessionId) {
+    return formatSessionScopedPath(VORATIQ_VERIFICATION_DIR, sessionId, "programmatic", ARTIFACTS_DIRNAME, PROGRAMMATIC_RESULT_FILENAME);
+}
+export function getVerificationRubricResultPath(options) {
+    const { sessionId, verifierId, template } = options;
+    const safeVerifierId = agentIdSchema.parse(verifierId);
+    const safeTemplate = assertPathSegment("segment", template);
+    return formatAgentSessionScopedPath(VORATIQ_VERIFICATION_DIR, sessionId, safeVerifierId, safeTemplate, ARTIFACTS_DIRNAME, "result.json");
+}
+export function getVerificationRubricExecutionDirectoryPath(options) {
+    const { sessionId, verifierId, template } = options;
+    const safeVerifierId = agentIdSchema.parse(verifierId);
+    const safeTemplate = assertPathSegment("segment", template);
+    return formatAgentSessionScopedPath(VORATIQ_VERIFICATION_DIR, sessionId, safeVerifierId, safeTemplate);
+}
+export function getAgentSessionDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId);
+}
+export function getSpecAgentSessionDirectoryPath(sessionId, agentId) {
+    return getAgentSessionDirectoryPath(VORATIQ_SPEC_DIR, sessionId, agentId);
+}
+export function getAgentSessionManifestPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, RUNTIME_DIRNAME, MANIFEST_FILENAME);
+}
+export function getAgentSessionRuntimeDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, RUNTIME_DIRNAME);
+}
+export function getAgentSessionWorkspaceDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, WORKSPACE_DIRNAME);
+}
+export function getAgentSessionContextDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, CONTEXT_DIRNAME);
+}
+export function getAgentSessionArtifactsDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME);
+}
+export function getAgentSessionStdoutPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME, STDOUT_FILENAME);
+}
+export function getAgentSessionStderrPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME, STDERR_FILENAME);
+}
+export function getAgentSessionDiffPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME, DIFF_FILENAME);
+}
+export function getAgentSessionSummaryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME, SUMMARY_FILENAME);
+}
+export function getAgentSessionReductionPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME, REDUCTION_FILENAME);
+}
+export function getAgentSessionReductionDataPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME, REDUCTION_DATA_FILENAME);
+}
+export function getAgentSessionChatArtifactPath(domain, sessionId, agentId, format) {
+    const filename = format === "json" ? CHAT_JSON_FILENAME : CHAT_JSONL_FILENAME;
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, ARTIFACTS_DIRNAME, filename);
+}
+export function getAgentSessionSandboxDirectoryPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, SANDBOX_DIRNAME);
+}
+export function getAgentSessionSandboxHomePath(domain, sessionId, agentId) {
+    return getAgentSessionSandboxDirectoryPath(domain, sessionId, agentId);
+}
+export function getAgentSessionSandboxSettingsPath(domain, sessionId, agentId) {
+    return formatAgentSessionScopedPath(domain, sessionId, agentId, RUNTIME_DIRNAME, SANDBOX_SETTINGS_FILENAME);
 }
 export function getRunDirectoryPath(runId) {
     return formatRunScopedPath(runId);
 }
-export function getRunPromptPath(runId) {
-    return formatRunScopedPath(runId, PROMPT_FILENAME);
-}
 export function getAgentDirectoryPath(runId, agentId) {
     return formatAgentScopedPath(runId, agentId);
 }
 export function getAgentManifestPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, RUNTIME_DIRNAME, MANIFEST_FILENAME);
+    return getAgentSessionManifestPath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentRuntimeDirectoryPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, RUNTIME_DIRNAME);
+    return getAgentSessionRuntimeDirectoryPath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentWorkspaceDirectoryPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, WORKSPACE_DIRNAME);
+    return getAgentSessionWorkspaceDirectoryPath(VORATIQ_RUN_DIR, runId, agentId);
+}
+export function getAgentContextDirectoryPath(runId, agentId) {
+    return getAgentSessionContextDirectoryPath(VORATIQ_RUN_DIR, runId, agentId);
+}
+export function getAgentArtifactsDirectoryPath(runId, agentId) {
+    return getAgentSessionArtifactsDirectoryPath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentStdoutPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, ARTIFACTS_DIRNAME, STDOUT_FILENAME);
+    return getAgentSessionStdoutPath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentStderrPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, ARTIFACTS_DIRNAME, STDERR_FILENAME);
+    return getAgentSessionStderrPath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentDiffPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, ARTIFACTS_DIRNAME, DIFF_FILENAME);
+    return getAgentSessionDiffPath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentSummaryPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, ARTIFACTS_DIRNAME, SUMMARY_FILENAME);
+    return getAgentSessionSummaryPath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentChatArtifactPath(runId, agentId, format) {
-    const filename = format === "json" ? CHAT_JSON_FILENAME : CHAT_JSONL_FILENAME;
-    return formatAgentScopedPath(runId, agentId, ARTIFACTS_DIRNAME, filename);
+    return getAgentSessionChatArtifactPath(VORATIQ_RUN_DIR, runId, agentId, format);
 }
 export function buildAgentArtifactPaths(options) {
     const { runId, agentId, artifacts } = options;
@@ -108,28 +308,12 @@ export function buildAgentArtifactPaths(options) {
             : undefined,
     };
 }
-export function buildAgentEvalViews(options) {
-    const { runId, agentId, evals } = options;
-    return (evals ?? []).map((evaluation) => ({
-        ...evaluation,
-        logPath: evaluation.hasLog
-            ? getAgentEvalLogPath(runId, agentId, evaluation.slug)
-            : undefined,
-    }));
-}
-export function getAgentEvalsDirectoryPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, EVALS_DIRNAME);
-}
-export function getAgentEvalLogPath(runId, agentId, evalSlug) {
-    const safeSlug = assertEvalSlug(evalSlug);
-    return formatAgentScopedPath(runId, agentId, EVALS_DIRNAME, `${safeSlug}.log`);
-}
 export function getAgentSandboxDirectoryPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, SANDBOX_DIRNAME);
+    return getAgentSessionSandboxDirectoryPath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentSandboxHomePath(runId, agentId) {
-    return getAgentSandboxDirectoryPath(runId, agentId);
+    return getAgentSessionSandboxHomePath(VORATIQ_RUN_DIR, runId, agentId);
 }
 export function getAgentSandboxSettingsPath(runId, agentId) {
-    return formatAgentScopedPath(runId, agentId, RUNTIME_DIRNAME, SANDBOX_SETTINGS_FILENAME);
+    return getAgentSessionSandboxSettingsPath(VORATIQ_RUN_DIR, runId, agentId);
 }

package/dist/workspace/templates.d.ts

@@ -1,9 +1,15 @@
-import { type AgentDefault } from "../configs/agents/defaults.js";
+import { type AgentDefault, type AgentPreset } from "../configs/agents/defaults.js";
 import { type AgentConfigEntry } from "../configs/agents/types.js";
-export { DEFAULT_AGENT_DEFAULTS, MODEL_PLACEHOLDER, sanitizeAgentIdFromModel, } from "../configs/agents/defaults.js";
+export type { AgentPreset } from "../configs/agents/defaults.js";
+export { AGENT_PRESET_CHOICES } from "../configs/agents/defaults.js";
 export type VendorTemplate = AgentDefault;
 export declare function serializeAgentsConfigEntries(entries: ReadonlyArray<AgentConfigEntry>): string;
 export declare function buildDefaultAgentsTemplate(): string;
-export declare function buildDefaultEvalsTemplate(): string;
+export declare function buildAgentsTemplate(preset: AgentPreset): string;
+export interface AgentPresetTemplateDescriptor {
+    preset: AgentPreset;
+    template: string;
+}
+export declare function listAgentPresetTemplates(): AgentPresetTemplateDescriptor[];
 export declare function buildDefaultEnvironmentTemplate(): string;
 export declare function buildDefaultSandboxTemplate(): string;

package/dist/workspace/templates.js

@@ -1,9 +1,7 @@
-import { DEFAULT_AGENT_DEFAULTS, sanitizeAgentIdFromModel, } from "../configs/agents/defaults.js";
+import { AGENT_PRESET_CHOICES, getAgentDefaultId, getSupportedAgentDefaults, } from "../configs/agents/defaults.js";
 import { agentConfigEntrySchema, } from "../configs/agents/types.js";
-import { listEvalDefaults, serializeEvalDefaults, } from "../configs/evals/defaults.js";
 import { listSandboxProviderDefaults } from "../configs/sandbox/defaults.js";
-import { detectBinary } from "../utils/binaries.js";
-export { DEFAULT_AGENT_DEFAULTS, MODEL_PLACEHOLDER, sanitizeAgentIdFromModel, } from "../configs/agents/defaults.js";
+export { AGENT_PRESET_CHOICES } from "../configs/agents/defaults.js";
 function formatScalar(value) {
     if (/^[A-Za-z0-9._/-]+$/.test(value)) {
         return value;
@@ -12,16 +10,17 @@ function formatScalar(value) {
     return `"${escaped}"`;
 }
 function serializeAgentEntry(entry) {
-    const enabled = entry.enabled !== false;
     const binary = entry.binary ?? "";
     const extraArgs = entry.extraArgs ?? [];
     const lines = [
         `  - id: ${entry.id}`,
         `    provider: ${formatScalar(entry.provider)}`,
         `    model: ${formatScalar(entry.model)}`,
-        `    enabled: ${enabled ? "true" : "false"}`,
-        `    binary: ${formatScalar(binary)}`,
     ];
+    if (entry.enabled === false) {
+        lines.push("    enabled: false");
+    }
+    lines.push(`    binary: ${formatScalar(binary)}`);
     if (extraArgs.length > 0) {
         lines.push("    extraArgs:");
         for (const arg of extraArgs) {
@@ -31,27 +30,39 @@ function serializeAgentEntry(entry) {
     return lines.join("\n");
 }
 export function serializeAgentsConfigEntries(entries) {
+    if (entries.length === 0) {
+        return "agents: []\n";
+    }
     const header = "agents:\n";
     const body = entries.map(serializeAgentEntry).join("\n\n");
     return `${header}${body}\n`;
 }
 function buildAgentEntryFromTemplate(template) {
-    const binary = detectBinary(template.provider) ?? "";
     return agentConfigEntrySchema.parse({
-        id: sanitizeAgentIdFromModel(template.model),
+        id: getAgentDefaultId(template),
         provider: template.provider,
         model: template.model,
-        enabled: false,
-        binary,
+        enabled: true,
+        binary: "",
+        extraArgs: template.extraArgs && template.extraArgs.length > 0
+            ? [...template.extraArgs]
+            : undefined,
     });
 }
 export function buildDefaultAgentsTemplate() {
-    const entries = DEFAULT_AGENT_DEFAULTS.map((template) => buildAgentEntryFromTemplate(template));
+    return buildAgentsTemplate("pro");
+}
+export function buildAgentsTemplate(preset) {
+    void preset;
+    const templates = getSupportedAgentDefaults();
+    const entries = templates.map((template) => buildAgentEntryFromTemplate(template));
     return serializeAgentsConfigEntries(entries);
 }
-export function buildDefaultEvalsTemplate() {
-    const lines = serializeEvalDefaults(listEvalDefaults());
-    return `${lines.join("\n")}\n`;
+export function listAgentPresetTemplates() {
+    return AGENT_PRESET_CHOICES.map((preset) => ({
+        preset,
+        template: buildAgentsTemplate(preset),
+    }));
 }
 export function buildDefaultEnvironmentTemplate() {
     return "";

package/dist/workspace/verification-defaults.d.ts

@@ -0,0 +1,12 @@
+import type { EnvironmentConfig } from "../configs/environment/types.js";
+export declare function buildDefaultVerificationConfigYaml(params: {
+    root: string;
+    environment: EnvironmentConfig;
+}): Promise<string>;
+export interface ShippedVerificationTemplate {
+    name: "spec-verification" | "run-verification" | "reduce-verification" | "message-verification";
+    prompt: string;
+    rubric: string;
+    schema: string;
+}
+export declare const SHIPPED_VERIFICATION_TEMPLATES: readonly ShippedVerificationTemplate[];