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

package/dist/workspace/setup.js

@@ -1,89 +1,392 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { ensureDirectoryExists, ensureFileExists, isDirectory, pathExists, } from "../utils/fs.js";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { readAgentsConfig } from "../configs/agents/loader.js";
+import { loadEnvironmentConfig, } from "../configs/environment/loader.js";
+import { buildDefaultOrchestrationTemplate } from "../configs/orchestration/bootstrap.js";
+import { toErrorMessage } from "../utils/errors.js";
+import { isDirectory, isFile, pathExists } from "../utils/fs.js";
 import { relativeToRoot } from "../utils/path.js";
-import { WorkspaceMissingEntryError, WorkspaceNotInitializedError, } from "./errors.js";
-import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ENVIRONMENT_FILE, VORATIQ_EVALS_FILE, VORATIQ_RUNS_DIR, VORATIQ_RUNS_FILE, VORATIQ_RUNS_SESSIONS_DIR, VORATIQ_SANDBOX_FILE, } from "./structure.js";
-import { buildDefaultAgentsTemplate, buildDefaultEnvironmentTemplate, buildDefaultEvalsTemplate, buildDefaultSandboxTemplate, } from "./templates.js";
+import { WorkspaceMissingEntryError, WorkspaceNotInitializedError, WorkspaceSetupError, WorkspaceWrongTypeEntryError, } from "./errors.js";
+import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ENVIRONMENT_FILE, VORATIQ_INTERACTIVE_DIR, VORATIQ_INTERACTIVE_FILE, VORATIQ_INTERACTIVE_SESSIONS_DIR, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_MESSAGE_SESSIONS_DIR, VORATIQ_ORCHESTRATION_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_REDUCTION_SESSIONS_DIR, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_RUN_SESSIONS_DIR, VORATIQ_SANDBOX_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_SPEC_SESSIONS_DIR, VORATIQ_VERIFICATION_CONFIG_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, VORATIQ_VERIFICATION_SESSIONS_DIR, VORATIQ_VERIFICATION_TEMPLATES_DIR, } from "./structure.js";
+import { buildDefaultAgentsTemplate, buildDefaultEnvironmentTemplate, buildDefaultSandboxTemplate, } from "./templates.js";
+import { buildDefaultVerificationConfigYaml, SHIPPED_VERIFICATION_TEMPLATES, } from "./verification-defaults.js";
+async function seedVerificationSurface(root, options = {}) {
+    const createdDirectories = [];
+    const createdFiles = [];
+    const verificationConfigPath = options.verificationConfigPath ??
+        resolveWorkspacePath(root, VORATIQ_VERIFICATION_CONFIG_FILE);
+    const configExists = options.configExists ?? (await pathExists(verificationConfigPath));
+    if (!configExists) {
+        await mkdir(dirname(verificationConfigPath), { recursive: true });
+        const seededConfig = await buildSeededVerificationConfig(root);
+        await writeFile(verificationConfigPath, seededConfig, { encoding: "utf8" });
+        createdFiles.push(relativeToRoot(root, verificationConfigPath));
+    }
+    if (options.restoreTemplates === false) {
+        return { createdDirectories, createdFiles };
+    }
+    const templatesRoot = resolveWorkspacePath(root, VORATIQ_VERIFICATION_TEMPLATES_DIR);
+    if (!(await pathExists(templatesRoot))) {
+        await mkdir(templatesRoot, { recursive: true });
+        createdDirectories.push(relativeToRoot(root, templatesRoot));
+    }
+    for (const template of SHIPPED_VERIFICATION_TEMPLATES) {
+        const templateDir = join(templatesRoot, template.name);
+        if (!(await pathExists(templateDir))) {
+            await mkdir(templateDir, { recursive: true });
+            createdDirectories.push(relativeToRoot(root, templateDir));
+        }
+        const promptPath = join(templateDir, "prompt.md");
+        const rubricPath = join(templateDir, "rubric.md");
+        const schemaPath = join(templateDir, "schema.yaml");
+        if (!(await pathExists(promptPath))) {
+            await writeFile(promptPath, `${template.prompt.trimEnd()}\n`, "utf8");
+            createdFiles.push(relativeToRoot(root, promptPath));
+        }
+        if (!(await pathExists(rubricPath))) {
+            await writeFile(rubricPath, `${template.rubric.trimEnd()}\n`, "utf8");
+            createdFiles.push(relativeToRoot(root, rubricPath));
+        }
+        if (!(await pathExists(schemaPath))) {
+            await writeFile(schemaPath, `${template.schema.trimEnd()}\n`, "utf8");
+            createdFiles.push(relativeToRoot(root, schemaPath));
+        }
+    }
+    return { createdDirectories, createdFiles };
+}
+const DOMAIN_STRUCTURE_DEFINITIONS = [
+    {
+        directorySegment: VORATIQ_SPEC_DIR,
+        sessionsSegment: VORATIQ_SPEC_SESSIONS_DIR,
+        indexSegment: VORATIQ_SPEC_FILE,
+        indexVersion: 1,
+    },
+    {
+        directorySegment: VORATIQ_RUN_DIR,
+        sessionsSegment: VORATIQ_RUN_SESSIONS_DIR,
+        indexSegment: VORATIQ_RUN_FILE,
+        indexVersion: 2,
+    },
+    {
+        directorySegment: VORATIQ_REDUCTION_DIR,
+        sessionsSegment: VORATIQ_REDUCTION_SESSIONS_DIR,
+        indexSegment: VORATIQ_REDUCTION_FILE,
+        indexVersion: 1,
+    },
+    {
+        directorySegment: VORATIQ_VERIFICATION_DIR,
+        sessionsSegment: VORATIQ_VERIFICATION_SESSIONS_DIR,
+        indexSegment: VORATIQ_VERIFICATION_FILE,
+        indexVersion: 1,
+    },
+    {
+        directorySegment: VORATIQ_MESSAGE_DIR,
+        sessionsSegment: VORATIQ_MESSAGE_SESSIONS_DIR,
+        indexSegment: VORATIQ_MESSAGE_FILE,
+        indexVersion: 1,
+    },
+    {
+        directorySegment: VORATIQ_INTERACTIVE_DIR,
+        sessionsSegment: VORATIQ_INTERACTIVE_SESSIONS_DIR,
+        indexSegment: VORATIQ_INTERACTIVE_FILE,
+        indexVersion: 1,
+    },
+];
+const WORKSPACE_CONFIG_SEGMENTS = [
+    VORATIQ_AGENTS_FILE,
+    VORATIQ_VERIFICATION_CONFIG_FILE,
+    VORATIQ_ENVIRONMENT_FILE,
+    VORATIQ_SANDBOX_FILE,
+    VORATIQ_ORCHESTRATION_FILE,
+];
 export async function createWorkspace(root) {
     const createdDirectories = [];
     const createdFiles = [];
     const workspaceDir = resolveWorkspacePath(root);
-    if (!(await pathExists(workspaceDir))) {
+    const domainStructures = resolveWorkspaceDomainStructures(root);
+    const agentsConfigPath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
+    const environmentConfigPath = resolveWorkspacePath(root, VORATIQ_ENVIRONMENT_FILE);
+    const sandboxConfigPath = resolveWorkspacePath(root, VORATIQ_SANDBOX_FILE);
+    const orchestrationConfigPath = resolveWorkspacePath(root, VORATIQ_ORCHESTRATION_FILE);
+    const verificationConfigPath = resolveWorkspacePath(root, VORATIQ_VERIFICATION_CONFIG_FILE);
+    const workspaceExists = await pathExists(workspaceDir);
+    const [agentsConfigExists, environmentConfigExists] = await Promise.all([
+        pathExists(agentsConfigPath),
+        pathExists(environmentConfigPath),
+    ]);
+    const [sandboxConfigExists, orchestrationConfigExists, verificationExists] = await Promise.all([
+        pathExists(sandboxConfigPath),
+        pathExists(orchestrationConfigPath),
+        pathExists(verificationConfigPath),
+    ]);
+    if (!workspaceExists) {
         await mkdir(workspaceDir, { recursive: true });
         createdDirectories.push(relativeToRoot(root, workspaceDir));
     }
-    const runsDir = resolveWorkspacePath(root, VORATIQ_RUNS_DIR);
-    if (!(await pathExists(runsDir))) {
-        await mkdir(runsDir, { recursive: true });
-        createdDirectories.push(relativeToRoot(root, runsDir));
-    }
-    const sessionsDir = resolveWorkspacePath(root, VORATIQ_RUNS_SESSIONS_DIR);
-    if (!(await pathExists(sessionsDir))) {
-        await mkdir(sessionsDir, { recursive: true });
-        createdDirectories.push(relativeToRoot(root, sessionsDir));
-    }
-    const runsIndexPath = resolveWorkspacePath(root, VORATIQ_RUNS_FILE);
-    if (!(await pathExists(runsIndexPath))) {
-        const initialIndex = JSON.stringify({ version: 2, sessions: [] }, null, 2);
-        await writeFile(runsIndexPath, `${initialIndex}\n`, { encoding: "utf8" });
-        createdFiles.push(relativeToRoot(root, runsIndexPath));
+    for (const domain of domainStructures) {
+        if (!(await pathExists(domain.directoryPath))) {
+            await mkdir(domain.directoryPath, { recursive: true });
+            createdDirectories.push(relativeToRoot(root, domain.directoryPath));
+        }
+        if (!(await pathExists(domain.sessionsPath))) {
+            await mkdir(domain.sessionsPath, { recursive: true });
+            createdDirectories.push(relativeToRoot(root, domain.sessionsPath));
+        }
+        if (!(await pathExists(domain.indexPath))) {
+            await writeInitialIndex(domain.indexPath, domain.indexVersion);
+            createdFiles.push(relativeToRoot(root, domain.indexPath));
+        }
     }
-    const agentsConfigPath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
-    if (!(await pathExists(agentsConfigPath))) {
+    if (!agentsConfigExists) {
         const agentsTemplate = buildDefaultAgentsTemplate();
         await writeFile(agentsConfigPath, agentsTemplate, { encoding: "utf8" });
         createdFiles.push(relativeToRoot(root, agentsConfigPath));
     }
-    const evalsConfigPath = resolveWorkspacePath(root, VORATIQ_EVALS_FILE);
-    if (!(await pathExists(evalsConfigPath))) {
-        const evalsTemplate = buildDefaultEvalsTemplate();
-        await writeFile(evalsConfigPath, evalsTemplate, { encoding: "utf8" });
-        createdFiles.push(relativeToRoot(root, evalsConfigPath));
-    }
-    const environmentConfigPath = resolveWorkspacePath(root, VORATIQ_ENVIRONMENT_FILE);
-    if (!(await pathExists(environmentConfigPath))) {
+    if (!environmentConfigExists) {
         const environmentTemplate = buildDefaultEnvironmentTemplate();
         await writeFile(environmentConfigPath, environmentTemplate, {
             encoding: "utf8",
         });
         createdFiles.push(relativeToRoot(root, environmentConfigPath));
     }
-    const sandboxConfigPath = resolveWorkspacePath(root, VORATIQ_SANDBOX_FILE);
-    if (!(await pathExists(sandboxConfigPath))) {
+    if (!sandboxConfigExists) {
         const sandboxTemplate = buildDefaultSandboxTemplate();
         await writeFile(sandboxConfigPath, sandboxTemplate, {
             encoding: "utf8",
         });
         createdFiles.push(relativeToRoot(root, sandboxConfigPath));
     }
+    if (!orchestrationConfigExists) {
+        const agentsContent = await readFile(agentsConfigPath, "utf8");
+        const agentsConfig = readAgentsConfig(agentsContent);
+        const orchestrationTemplate = buildDefaultOrchestrationTemplate(agentsConfig);
+        await writeFile(orchestrationConfigPath, orchestrationTemplate, {
+            encoding: "utf8",
+        });
+        createdFiles.push(relativeToRoot(root, orchestrationConfigPath));
+    }
+    const seededVerification = await seedVerificationSurface(root, {
+        verificationConfigPath,
+        configExists: verificationExists,
+    });
+    createdDirectories.push(...seededVerification.createdDirectories);
+    createdFiles.push(...seededVerification.createdFiles);
     return { createdDirectories, createdFiles };
 }
+export async function repairWorkspaceStructure(root, options = {}) {
+    const createdDirectories = [];
+    const createdFiles = [];
+    const workspaceDir = resolveWorkspacePath(root);
+    await ensureWorkspaceDirectoryEntry(root, workspaceDir);
+    // Additive repair must not mutate config semantics.
+    for (const configPath of resolveWorkspaceConfigPaths(root)) {
+        const kind = await detectPathKind(configPath);
+        if (kind === "missing" &&
+            configPath.endsWith(VORATIQ_VERIFICATION_CONFIG_FILE)) {
+            await mkdir(dirname(configPath), { recursive: true });
+            const seededConfig = await buildSeededVerificationConfig(root);
+            await writeFile(configPath, seededConfig, { encoding: "utf8" });
+            createdFiles.push(relativeToRoot(root, configPath));
+            continue;
+        }
+        await ensureWorkspaceFileEntry(root, configPath);
+    }
+    const seededVerification = await seedVerificationSurface(root, {
+        restoreTemplates: options.restoreShippedVerificationTemplates ?? true,
+    });
+    createdDirectories.push(...seededVerification.createdDirectories);
+    createdFiles.push(...seededVerification.createdFiles);
+    const domainStructures = resolveWorkspaceDomainStructures(root);
+    const missingDirectories = [];
+    const missingIndexes = [];
+    const existingIndexes = [];
+    for (const domain of domainStructures) {
+        await classifyExpectedDirectory({
+            root,
+            path: domain.directoryPath,
+            onMissing: () => {
+                missingDirectories.push(domain.directoryPath);
+            },
+        });
+        await classifyExpectedDirectory({
+            root,
+            path: domain.sessionsPath,
+            onMissing: () => {
+                missingDirectories.push(domain.sessionsPath);
+            },
+        });
+        await classifyExpectedFile({
+            root,
+            path: domain.indexPath,
+            onMissing: () => {
+                missingIndexes.push(domain);
+            },
+            onPresent: () => {
+                existingIndexes.push(domain);
+            },
+        });
+    }
+    const repaired = missingDirectories.length > 0 || missingIndexes.length > 0;
+    if (!repaired) {
+        return { repaired: false, createdDirectories, createdFiles };
+    }
+    for (const domain of existingIndexes) {
+        await validateWorkspaceIndexFile(root, domain);
+    }
+    for (const directoryPath of missingDirectories) {
+        await mkdir(directoryPath, { recursive: true });
+        createdDirectories.push(relativeToRoot(root, directoryPath));
+    }
+    for (const domain of missingIndexes) {
+        await writeInitialIndex(domain.indexPath, domain.indexVersion);
+        createdFiles.push(relativeToRoot(root, domain.indexPath));
+    }
+    return { repaired: true, createdDirectories, createdFiles };
+}
+function loadVerificationSeedingEnvironment(root, options = {}) {
+    try {
+        return loadEnvironmentConfig({
+            root,
+            optional: true,
+            ...options,
+        });
+    }
+    catch {
+        return {};
+    }
+}
+async function buildSeededVerificationConfig(root) {
+    const environment = loadVerificationSeedingEnvironment(root);
+    return buildDefaultVerificationConfigYaml({ root, environment });
+}
 export async function validateWorkspace(root) {
     const workspaceDir = resolveWorkspacePath(root);
-    const runsDir = resolveWorkspacePath(root, VORATIQ_RUNS_DIR);
-    const sessionsDir = resolveWorkspacePath(root, VORATIQ_RUNS_SESSIONS_DIR);
-    const runsIndexPath = resolveWorkspacePath(root, VORATIQ_RUNS_FILE);
-    const agentsConfigPath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
-    const evalsConfigPath = resolveWorkspacePath(root, VORATIQ_EVALS_FILE);
-    const environmentConfigPath = resolveWorkspacePath(root, VORATIQ_ENVIRONMENT_FILE);
-    const sandboxConfigPath = resolveWorkspacePath(root, VORATIQ_SANDBOX_FILE);
+    const domainStructures = resolveWorkspaceDomainStructures(root);
+    const configPaths = resolveWorkspaceConfigPaths(root);
     if (!(await isDirectory(workspaceDir))) {
-        const missingEntries = [
-            `${relativeToRoot(root, workspaceDir)}/`,
-            `${relativeToRoot(root, runsDir)}/`,
-            `${relativeToRoot(root, sessionsDir)}/`,
-            relativeToRoot(root, runsIndexPath),
-            relativeToRoot(root, agentsConfigPath),
-            relativeToRoot(root, environmentConfigPath),
-            relativeToRoot(root, sandboxConfigPath),
-        ];
+        const missingEntries = buildWorkspaceMissingEntryList({
+            root,
+            workspaceDir,
+            domainStructures,
+            configPaths,
+        });
         throw new WorkspaceNotInitializedError(missingEntries);
     }
-    await ensureDirectoryExists(runsDir, () => new WorkspaceMissingEntryError(relativeToRoot(root, runsDir)));
-    await ensureDirectoryExists(sessionsDir, () => new WorkspaceMissingEntryError(relativeToRoot(root, sessionsDir)));
-    await ensureFileExists(runsIndexPath, () => new WorkspaceMissingEntryError(relativeToRoot(root, runsIndexPath)));
-    await ensureFileExists(agentsConfigPath, () => new WorkspaceMissingEntryError(relativeToRoot(root, agentsConfigPath)));
-    await ensureFileExists(evalsConfigPath, () => new WorkspaceMissingEntryError(relativeToRoot(root, evalsConfigPath)));
-    await ensureFileExists(environmentConfigPath, () => new WorkspaceMissingEntryError(relativeToRoot(root, environmentConfigPath)));
-    await ensureFileExists(sandboxConfigPath, () => new WorkspaceMissingEntryError(relativeToRoot(root, sandboxConfigPath)));
+    for (const domain of domainStructures) {
+        await ensureWorkspaceDirectoryEntry(root, domain.directoryPath);
+        await ensureWorkspaceDirectoryEntry(root, domain.sessionsPath);
+        await ensureWorkspaceFileEntry(root, domain.indexPath);
+        await validateWorkspaceIndexFile(root, domain);
+    }
+    for (const configPath of configPaths) {
+        await ensureWorkspaceFileEntry(root, configPath);
+    }
+}
+function resolveWorkspaceDomainStructures(root) {
+    return DOMAIN_STRUCTURE_DEFINITIONS.map((domain) => ({
+        directoryPath: resolveWorkspacePath(root, domain.directorySegment),
+        sessionsPath: resolveWorkspacePath(root, domain.sessionsSegment),
+        indexPath: resolveWorkspacePath(root, domain.indexSegment),
+        indexVersion: domain.indexVersion,
+    }));
+}
+function resolveWorkspaceConfigPaths(root) {
+    return WORKSPACE_CONFIG_SEGMENTS.map((segment) => resolveWorkspacePath(root, segment));
+}
+function buildWorkspaceMissingEntryList(options) {
+    const { root, workspaceDir, domainStructures, configPaths } = options;
+    const missing = [`${relativeToRoot(root, workspaceDir)}/`];
+    for (const domain of domainStructures) {
+        missing.push(`${relativeToRoot(root, domain.directoryPath)}/`);
+        missing.push(`${relativeToRoot(root, domain.sessionsPath)}/`);
+        missing.push(relativeToRoot(root, domain.indexPath));
+    }
+    for (const configPath of configPaths) {
+        missing.push(relativeToRoot(root, configPath));
+    }
+    return missing;
+}
+async function classifyExpectedDirectory(options) {
+    const { root, path, onMissing } = options;
+    const kind = await detectPathKind(path);
+    if (kind === "missing") {
+        onMissing();
+        return;
+    }
+    if (kind !== "directory") {
+        throw new WorkspaceWrongTypeEntryError(relativeToRoot(root, path), "directory");
+    }
+}
+async function classifyExpectedFile(options) {
+    const { root, path, onMissing, onPresent } = options;
+    const kind = await detectPathKind(path);
+    if (kind === "missing") {
+        onMissing();
+        return;
+    }
+    if (kind !== "file") {
+        throw new WorkspaceWrongTypeEntryError(relativeToRoot(root, path), "file");
+    }
+    onPresent();
+}
+async function ensureWorkspaceDirectoryEntry(root, path) {
+    const kind = await detectPathKind(path);
+    if (kind === "missing") {
+        throw new WorkspaceMissingEntryError(relativeToRoot(root, path));
+    }
+    if (kind !== "directory") {
+        throw new WorkspaceWrongTypeEntryError(relativeToRoot(root, path), "directory");
+    }
+}
+async function ensureWorkspaceFileEntry(root, path) {
+    const kind = await detectPathKind(path);
+    if (kind === "missing") {
+        throw new WorkspaceMissingEntryError(relativeToRoot(root, path));
+    }
+    if (kind !== "file") {
+        throw new WorkspaceWrongTypeEntryError(relativeToRoot(root, path), "file");
+    }
+}
+async function detectPathKind(path) {
+    if (!(await pathExists(path))) {
+        return "missing";
+    }
+    if (await isDirectory(path)) {
+        return "directory";
+    }
+    if (await isFile(path)) {
+        return "file";
+    }
+    return "other";
+}
+async function validateWorkspaceIndexFile(root, domain) {
+    const displayPath = relativeToRoot(root, domain.indexPath);
+    let raw;
+    try {
+        raw = await readFile(domain.indexPath, "utf8");
+    }
+    catch (error) {
+        throw new WorkspaceSetupError(`Failed to read workspace index \`${displayPath}\`: ${toErrorMessage(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new WorkspaceSetupError(`Failed to parse workspace index \`${displayPath}\`: ${toErrorMessage(error)}`);
+    }
+    if (!isValidWorkspaceIndexPayload(parsed, domain.indexVersion)) {
+        throw new WorkspaceSetupError(`Invalid workspace index \`${displayPath}\`: expected \`{ version: ${domain.indexVersion}, sessions: [] }\`.`);
+    }
+}
+function isValidWorkspaceIndexPayload(payload, version) {
+    if (typeof payload !== "object" || payload === null) {
+        return false;
+    }
+    const candidate = payload;
+    return candidate.version === version && Array.isArray(candidate.sessions);
+}
+async function writeInitialIndex(path, version) {
+    const initialIndex = JSON.stringify({ version, sessions: [] }, null, 2);
+    await writeFile(path, `${initialIndex}\n`, { encoding: "utf8" });
 }

package/dist/workspace/shim.js

@@ -28,7 +28,7 @@ export async function ensureWorkspaceShim(options) {
             throw error;
         }
         if (isFileSystemError(error) && error.code === "ENOENT") {
-            throw new WorkspaceSetupError(`Voratiq CLI shim missing at ${sourcePath}. Run "npm run build" in the Voratiq CLI checkout before invoking agents.`);
+            throw new WorkspaceSetupError(`Voratiq CLI shim is missing at \`${sourcePath}\`. Run \`npm run build\` in the Voratiq CLI checkout before invoking agents.`);
         }
         throw error;
     }

package/dist/workspace/structure.d.ts

@@ -1,35 +1,118 @@
-import type { EvalStatus } from "../configs/evals/types.js";
 import type { ChatArtifactFormat } from "./chat/types.js";
 export declare const VORATIQ_DIR = ".voratiq";
-export declare const VORATIQ_RUNS_DIR = "runs";
-export declare const VORATIQ_RUNS_FILE = "runs/index.json";
-export declare const VORATIQ_RUNS_SESSIONS_DIR = "runs/sessions";
+export declare const VORATIQ_SPEC_DIR = "spec";
+export declare const VORATIQ_SPEC_FILE = "spec/index.json";
+export declare const VORATIQ_SPEC_SESSIONS_DIR = "spec/sessions";
+export declare const VORATIQ_RUN_DIR = "run";
+export declare const VORATIQ_RUN_FILE = "run/index.json";
+export declare const VORATIQ_RUN_SESSIONS_DIR = "run/sessions";
+export declare const VORATIQ_REDUCTION_DIR = "reduce";
+export declare const VORATIQ_REDUCTION_FILE = "reduce/index.json";
+export declare const VORATIQ_REDUCTION_SESSIONS_DIR = "reduce/sessions";
+export declare const VORATIQ_VERIFICATION_DIR = "verify";
+export declare const VORATIQ_VERIFICATION_FILE = "verify/index.json";
+export declare const VORATIQ_VERIFICATION_SESSIONS_DIR = "verify/sessions";
+export declare const VORATIQ_VERIFICATION_TEMPLATES_DIR = "verify/templates";
+export declare const VORATIQ_MESSAGE_DIR = "message";
+export declare const VORATIQ_MESSAGE_FILE = "message/index.json";
+export declare const VORATIQ_MESSAGE_SESSIONS_DIR = "message/sessions";
+export declare const VORATIQ_INTERACTIVE_DIR = "interactive";
+export declare const VORATIQ_INTERACTIVE_FILE = "interactive/index.json";
+export declare const VORATIQ_INTERACTIVE_SESSIONS_DIR = "interactive/sessions";
+export declare const VORATIQ_INDEX_FILENAME = "index.json";
+export declare const VORATIQ_HISTORY_LOCK_FILENAME = "history.lock";
+export declare const VORATIQ_SESSIONS_DIRNAME = "sessions";
 export declare const VORATIQ_AGENTS_FILE = "agents.yaml";
-export declare const VORATIQ_EVALS_FILE = "evals.yaml";
+export declare const VORATIQ_VERIFICATION_CONFIG_FILE = "verification.yaml";
 export declare const VORATIQ_ENVIRONMENT_FILE = "environment.yaml";
 export declare const VORATIQ_SANDBOX_FILE = "sandbox.yaml";
+export declare const VORATIQ_ORCHESTRATION_FILE = "orchestration.yaml";
 export declare const WORKSPACE_DIRNAME = "workspace";
-export declare const EVALS_DIRNAME = "evals";
+export declare const CONTEXT_DIRNAME = "context";
 export declare const STDOUT_FILENAME = "stdout.log";
 export declare const STDERR_FILENAME = "stderr.log";
 export declare const DIFF_FILENAME = "diff.patch";
 export declare const SUMMARY_FILENAME = "summary.txt";
 export declare const CHAT_JSON_FILENAME = "chat.json";
 export declare const CHAT_JSONL_FILENAME = "chat.jsonl";
-export declare const PROMPT_FILENAME = "prompt.txt";
+export declare const REDUCTION_FILENAME = "reduction.md";
+export declare const REDUCTION_DATA_FILENAME = "reduction.json";
+export declare const MESSAGE_RESPONSE_FILENAME = "response.md";
 export declare const RUNTIME_DIRNAME = "runtime";
 export declare const ARTIFACTS_DIRNAME = "artifacts";
 export declare const MANIFEST_FILENAME = "manifest.json";
+export declare const REDUCTION_ARTIFACT_INFO_FILENAME = "artifact-information.json";
 export declare const SANDBOX_DIRNAME = "sandbox";
 export declare const SANDBOX_SETTINGS_FILENAME = "sandbox.json";
+export declare const PROGRAMMATIC_RESULT_FILENAME = "result.json";
 export declare function resolveWorkspacePath(root: string, ...segments: string[]): string;
 export declare function formatWorkspacePath(...segments: string[]): string;
+export declare function getDomainDirectoryPath(domain: string): string;
+export declare function getDomainIndexPath(domain: string): string;
+export declare function getDomainHistoryLockPath(domain: string): string;
+export declare function getSpecDirectoryPath(): string;
+export declare function getSpecIndexPath(): string;
+export declare function getSpecHistoryLockPath(): string;
+export declare function getSpecSessionsDirectoryPath(): string;
+export declare function getReductionDirectoryPath(): string;
+export declare function getReductionIndexPath(): string;
+export declare function getReductionSessionsDirectoryPath(): string;
+export declare function getVerificationDirectoryPath(): string;
+export declare function getVerificationIndexPath(): string;
+export declare function getVerificationSessionsDirectoryPath(): string;
+export declare function getMessageDirectoryPath(): string;
+export declare function getMessageIndexPath(): string;
+export declare function getMessageSessionsDirectoryPath(): string;
+export declare function getInteractiveDirectoryPath(): string;
+export declare function getInteractiveIndexPath(): string;
+export declare function getInteractiveHistoryLockPath(): string;
+export declare function getInteractiveSessionsDirectoryPath(): string;
+export declare function getInteractiveSessionDirectoryPath(sessionId: string): string;
+export declare function getInteractiveSessionRecordPath(sessionId: string): string;
+export declare function getInteractiveSessionArtifactsDirectoryPath(sessionId: string): string;
+export declare function getDomainSessionsDirectoryPath(domain: string): string;
+export declare function getSessionDirectoryPath(domain: string, sessionId: string): string;
+export declare function getSpecSessionDirectoryPath(sessionId: string): string;
+export declare function getReductionSessionDirectoryPath(sessionId: string): string;
+export declare function getMessageSessionDirectoryPath(sessionId: string): string;
+export declare function getVerificationSessionDirectoryPath(sessionId: string): string;
+export declare function getVerificationSessionArtifactsDirectoryPath(sessionId: string): string;
+export declare function getVerificationSessionRecordPath(sessionId: string): string;
+export declare function getVerificationProgrammaticResultPath(sessionId: string): string;
+export declare function getVerificationRubricResultPath(options: {
+    sessionId: string;
+    verifierId: string;
+    template: string;
+}): string;
+export declare function getVerificationRubricExecutionDirectoryPath(options: {
+    sessionId: string;
+    verifierId: string;
+    template: string;
+}): string;
+export declare function getAgentSessionDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getSpecAgentSessionDirectoryPath(sessionId: string, agentId: string): string;
+export declare function getAgentSessionManifestPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionRuntimeDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionWorkspaceDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionContextDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionArtifactsDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionStdoutPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionStderrPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionDiffPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionSummaryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionReductionPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionReductionDataPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionChatArtifactPath(domain: string, sessionId: string, agentId: string, format: ChatArtifactFormat): string;
+export declare function getAgentSessionSandboxDirectoryPath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionSandboxHomePath(domain: string, sessionId: string, agentId: string): string;
+export declare function getAgentSessionSandboxSettingsPath(domain: string, sessionId: string, agentId: string): string;
 export declare function getRunDirectoryPath(runId: string): string;
-export declare function getRunPromptPath(runId: string): string;
 export declare function getAgentDirectoryPath(runId: string, agentId: string): string;
 export declare function getAgentManifestPath(runId: string, agentId: string): string;
 export declare function getAgentRuntimeDirectoryPath(runId: string, agentId: string): string;
 export declare function getAgentWorkspaceDirectoryPath(runId: string, agentId: string): string;
+export declare function getAgentContextDirectoryPath(runId: string, agentId: string): string;
+export declare function getAgentArtifactsDirectoryPath(runId: string, agentId: string): string;
 export declare function getAgentStdoutPath(runId: string, agentId: string): string;
 export declare function getAgentStderrPath(runId: string, agentId: string): string;
 export declare function getAgentDiffPath(runId: string, agentId: string): string;
@@ -50,29 +133,11 @@ export interface AgentArtifactPaths {
     summaryPath?: string;
     chatPath?: string;
 }
-export interface AgentEvalSnapshotLike {
-    slug: string;
-    status: EvalStatus;
-    command?: string;
-    exitCode?: number | null;
-    hasLog?: boolean;
-    error?: string;
-}
-export interface AgentEvalViewLike extends AgentEvalSnapshotLike {
-    logPath?: string;
-}
 export declare function buildAgentArtifactPaths(options: {
     runId: string;
     agentId: string;
     artifacts?: AgentArtifactsSnapshot | null;
 }): AgentArtifactPaths;
-export declare function buildAgentEvalViews(options: {
-    runId: string;
-    agentId: string;
-    evals?: readonly AgentEvalSnapshotLike[] | null;
-}): AgentEvalViewLike[];
-export declare function getAgentEvalsDirectoryPath(runId: string, agentId: string): string;
-export declare function getAgentEvalLogPath(runId: string, agentId: string, evalSlug: string): string;
 export declare function getAgentSandboxDirectoryPath(runId: string, agentId: string): string;
 export declare function getAgentSandboxHomePath(runId: string, agentId: string): string;
 export declare function getAgentSandboxSettingsPath(runId: string, agentId: string): string;