voratiq 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/commands/verify/targets.js

@@ -1,4 +1,4 @@
-import { basename } from "node:path";
+import { basename, join } from "node:path";
 import { CliError, RunNotFoundCliError } from "../../cli/errors.js";
 import { TERMINAL_MESSAGE_STATUSES } from "../../domain/message/model/types.js";
 import { readMessageRecords } from "../../domain/message/persistence/adapter.js";
@@ -10,7 +10,10 @@ import { TERMINAL_SPEC_STATUSES } from "../../domain/spec/model/types.js";
 import { readSpecRecords } from "../../domain/spec/persistence/adapter.js";
 import { readVerificationRecords } from "../../domain/verify/persistence/adapter.js";
 import { TERMINAL_RUN_STATUSES } from "../../status/index.js";
-import { MESSAGE_RESPONSE_FILENAME } from "../../workspace/structure.js";
+import { pathExists } from "../../utils/fs.js";
+import { normalizePathForDisplay, resolvePath } from "../../utils/path.js";
+import { DIFF_FILENAME, MESSAGE_RESPONSE_FILENAME, } from "../../workspace/constants.js";
+import { buildAgentWorkspacePaths } from "../../workspace/layout.js";
 export async function resolveVerifyTarget(input) {
     const { target } = input;
     switch (target.kind) {
@@ -40,14 +43,31 @@ async function resolveSpecVerifyTarget(input) {
     if (!TERMINAL_SPEC_STATUSES.includes(record.status)) {
         throw new CliError(`Spec session \`${target.sessionId}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the spec to finish before running `voratiq verify`."]);
     }
+    const competitiveCandidates = record.agents
+        .filter((agent) => agent.status === "succeeded" && agent.outputPath)
+        .map((agent) => ({
+        canonicalId: agent.agentId,
+        forbiddenIdentityTokens: [agent.agentId],
+    }));
+    if (competitiveCandidates.length === 0) {
+        throw new CliError(`Spec session \`${target.sessionId}\` has no verifiable drafts.`, [], [
+            "Re-run `voratiq spec` to generate at least one succeeded draft before running `voratiq verify`.",
+        ]);
+    }
+    const missingSpecArtifacts = await collectMissingSpecVerificationArtifacts({
+        root,
+        outputPaths: record.agents
+            .filter((agent) => agent.status === "succeeded" && typeof agent.outputPath === "string")
+            .map((agent) => agent.outputPath),
+    });
+    if (missingSpecArtifacts.length > 0) {
+        throw new CliError(`Spec session \`${target.sessionId}\` is missing required verification artifacts.`, missingSpecArtifacts.map((artifact) => `Missing: \`${artifact}\`.`), [
+            "Re-run `voratiq spec` to regenerate the retained artifacts before running `voratiq verify`.",
+        ]);
+    }
     return {
         baseRevisionSha: resolveSpecBaseRevisionSha(record),
-        competitiveCandidates: record.agents
-            .filter((agent) => agent.status === "succeeded" && agent.outputPath)
-            .map((agent) => ({
-            canonicalId: agent.agentId,
-            forbiddenIdentityTokens: [agent.agentId],
-        })),
+        competitiveCandidates,
         target: {
             kind: "spec",
             sessionId: record.sessionId,
@@ -81,6 +101,16 @@ async function resolveRunVerifyTarget(input) {
     if (candidateIds.length === 0) {
         throw new CliError(`Run \`${target.sessionId}\` has no candidate agents to verify.`, [], ["Re-run `voratiq run` to generate verifiable candidates."]);
     }
+    const missingRequiredArtifacts = await collectMissingRunVerificationArtifacts({
+        root,
+        record,
+        candidateIds,
+    });
+    if (missingRequiredArtifacts.length > 0) {
+        throw new CliError(`Run \`${target.sessionId}\` is missing required verification artifacts.`, missingRequiredArtifacts.map((artifact) => `Missing: \`${artifact}\`.`), [
+            "Re-run `voratiq run` to regenerate the retained artifacts before running `voratiq verify`.",
+        ]);
+    }
     return {
         baseRevisionSha: record.baseRevisionSha,
         competitiveCandidates: candidateIds.map((candidateId) => ({
@@ -117,16 +147,33 @@ async function resolveReductionVerifyTarget(input) {
     if (!TERMINAL_REDUCTION_STATUSES.includes(record.status)) {
         throw new CliError(`Reduction session \`${target.sessionId}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the reduction to finish before running `voratiq verify`."]);
     }
-    const referenceRepo = await resolveReductionReferenceRepo({
-        ...input,
-        reductionRecord: record,
-    });
     const competitiveCandidates = record.reducers
         .filter((reducer) => reducer.status === "succeeded" && reducer.outputPath)
         .map((reducer) => ({
         canonicalId: reducer.agentId,
         forbiddenIdentityTokens: [reducer.agentId],
     }));
+    if (competitiveCandidates.length === 0) {
+        throw new CliError(`Reduction session \`${target.sessionId}\` has no verifiable reductions.`, [], [
+            "Re-run `voratiq reduce` to produce at least one succeeded reduction before running `voratiq verify`.",
+        ]);
+    }
+    const missingReductionArtifacts = await collectMissingRetainedVerificationArtifacts({
+        root,
+        relativePaths: record.reducers
+            .filter((reducer) => reducer.status === "succeeded" &&
+            typeof reducer.outputPath === "string")
+            .map((reducer) => reducer.outputPath),
+    });
+    if (missingReductionArtifacts.length > 0) {
+        throw new CliError(`Reduction session \`${target.sessionId}\` is missing required verification artifacts.`, missingReductionArtifacts.map((artifact) => `Missing: \`${artifact}\`.`), [
+            "Re-run `voratiq reduce` to regenerate the retained artifacts before running `voratiq verify`.",
+        ]);
+    }
+    const referenceRepo = await resolveReductionReferenceRepo({
+        ...input,
+        reductionRecord: record,
+    });
     if (referenceRepo.kind === "git") {
         return {
             baseRevisionSha: referenceRepo.baseRevisionSha,
@@ -177,6 +224,15 @@ async function resolveMessageVerifyTarget(input) {
             "Re-run `voratiq message` to capture at least one succeeded response before running `voratiq verify`.",
         ]);
     }
+    const missingMessageArtifacts = await collectMissingRetainedVerificationArtifacts({
+        root,
+        relativePaths: recipients.map((recipient) => recipient.outputPath),
+    });
+    if (missingMessageArtifacts.length > 0) {
+        throw new CliError(`Message session \`${target.sessionId}\` is missing required verification artifacts.`, missingMessageArtifacts.map((artifact) => `Missing: \`${artifact}\`.`), [
+            "Re-run `voratiq message` to regenerate the retained artifacts before running `voratiq verify`.",
+        ]);
+    }
     return {
         competitiveCandidates: recipients.map((recipient) => ({
             canonicalId: recipient.agentId,
@@ -189,6 +245,46 @@ async function resolveMessageVerifyTarget(input) {
         messageRecord: record,
     };
 }
+async function collectMissingSpecVerificationArtifacts(options) {
+    return collectMissingRetainedVerificationArtifacts({
+        root: options.root,
+        relativePaths: options.outputPaths,
+    });
+}
+async function collectMissingRunVerificationArtifacts(options) {
+    const { root, record, candidateIds } = options;
+    const missing = new Set();
+    const specAbsolute = resolvePath(root, record.spec.path);
+    if (!(await pathExists(specAbsolute))) {
+        missing.add(normalizePathForDisplay(record.spec.path));
+    }
+    for (const candidateId of candidateIds) {
+        const runAgentRecord = record.agents.find((agent) => agent.agentId === candidateId);
+        if (runAgentRecord?.artifacts?.diffCaptured !== true) {
+            continue;
+        }
+        const paths = buildAgentWorkspacePaths({
+            root,
+            runId: record.runId,
+            agentId: candidateId,
+        });
+        const diffAbsolute = join(paths.artifactsPath, DIFF_FILENAME);
+        if (!(await pathExists(diffAbsolute))) {
+            missing.add(normalizePathForDisplay(join(".voratiq", "run", "sessions", record.runId, candidateId, "artifacts", DIFF_FILENAME)));
+        }
+    }
+    return Array.from(missing).sort((left, right) => left.localeCompare(right));
+}
+async function collectMissingRetainedVerificationArtifacts(options) {
+    const { root, relativePaths } = options;
+    const missing = new Set();
+    for (const relativePath of relativePaths) {
+        if (!(await pathExists(resolvePath(root, relativePath)))) {
+            missing.add(normalizePathForDisplay(relativePath));
+        }
+    }
+    return Array.from(missing).sort((left, right) => left.localeCompare(right));
+}
 function collectRunCandidateIdentityTokens(options) {
     const { runRecord, candidateId } = options;
     const tokens = new Set();

package/dist/competition/shared/preflight.d.ts

@@ -7,5 +7,5 @@ export interface FormatPreflightIssueLinesOptions {
     readonly unlabeledAgentIds?: readonly string[];
 }
 export declare const PREFLIGHT_SUMMARY_MAX_CHARS: 120;
-export declare const PREFLIGHT_HINT: "Run `voratiq init` to configure the workspace.";
+export declare const PREFLIGHT_HINT: "Run `voratiq doctor --fix` to repair workspace setup.";
 export declare function formatPreflightIssueLines(issues: readonly PreflightIssue[], options?: FormatPreflightIssueLinesOptions): string[];

package/dist/competition/shared/preflight.js

@@ -1,5 +1,6 @@
 export const PREFLIGHT_SUMMARY_MAX_CHARS = 120;
-export const PREFLIGHT_HINT = "Run `voratiq init` to configure the workspace.";
+export const PREFLIGHT_HINT = "Run `voratiq doctor --fix` to repair workspace setup.";
+const SETTINGS_FILE_MESSAGE_PATTERN = /^Invalid settings file at (?:(?:.+\/)?(?:\.voratiq\/)?)settings\.yaml(?::\s*(.+))?$/u;
 export function formatPreflightIssueLines(issues, options = {}) {
     const { maxChars = PREFLIGHT_SUMMARY_MAX_CHARS, unlabeledAgentIds = [] } = options;
     const unlabeled = new Set(unlabeledAgentIds);
@@ -17,15 +18,27 @@ function formatIssueLine(agentId, message, unlabeledAgentIds) {
     if (unlabeledAgentIds.has(agentId)) {
         return `- ${message}`;
     }
-    return `- ${agentId}: ${message}`;
+    return `- \`${agentId}\`: ${message}`;
 }
 function normalizeIssueMessage(message) {
     const split = message
         .split(/\r?\n/u)
         .map((line) => line.replace(/\s+/gu, " ").trim())
+        .map(normalizeIssueText)
         .filter((line) => line.length > 0);
     return split.length > 0 ? split : ["unknown error"];
 }
+function normalizeIssueText(line) {
+    const settingsMatch = SETTINGS_FILE_MESSAGE_PATTERN.exec(line);
+    if (!settingsMatch) {
+        return line;
+    }
+    const detail = settingsMatch[1]?.trim();
+    if (!detail) {
+        return "Invalid `settings.yaml`.";
+    }
+    return `Invalid \`settings.yaml\`: ${detail}`;
+}
 function truncateLine(value, maxChars) {
     if (value.length <= maxChars) {
         return value;

package/dist/competition/shared/teardown.d.ts

@@ -32,5 +32,12 @@ export interface TeardownController {
     }): void;
     listResources(): readonly TeardownResource[];
 }
+export interface ScratchWorkspaceTeardownPaths {
+    readonly workspacePath: string;
+    readonly contextPath: string;
+    readonly runtimePath: string;
+    readonly sandboxPath: string;
+}
 export declare function createTeardownController(label: string): TeardownController;
+export declare function registerScratchWorkspaceTeardownPaths(teardown: TeardownController, workspacePaths: ScratchWorkspaceTeardownPaths, labelPrefix: string): void;
 export declare function runTeardown(controller: TeardownController | undefined): Promise<readonly TeardownDiagnostic[]>;

package/dist/competition/shared/teardown.js

@@ -34,6 +34,12 @@ export function createTeardownController(label) {
         },
     };
 }
+export function registerScratchWorkspaceTeardownPaths(teardown, workspacePaths, labelPrefix) {
+    teardown.addPath(workspacePaths.workspacePath, `${labelPrefix} workspace`);
+    teardown.addPath(workspacePaths.contextPath, `${labelPrefix} context`);
+    teardown.addPath(workspacePaths.runtimePath, `${labelPrefix} runtime`);
+    teardown.addPath(workspacePaths.sandboxPath, `${labelPrefix} sandbox`);
+}
 export async function runTeardown(controller) {
     if (!controller) {
         return [];

package/dist/configs/agents/defaults.js

@@ -87,30 +87,16 @@ const DEFAULT_AGENT_CATALOG_ENTRIES = [
         extraArgs: ["--effort", "high"],
     },
     {
-        id: "gpt-5-codex",
-        provider: "codex",
-        model: "gpt-5-codex",
-    },
-    {
-        id: "gpt-5-1-codex-mini",
-        provider: "codex",
-        model: "gpt-5.1-codex-mini",
-    },
-    {
-        id: "gpt-5-1-codex",
-        provider: "codex",
-        model: "gpt-5.1-codex",
-    },
-    {
-        id: "gpt-5-1-codex-max",
-        provider: "codex",
-        model: "gpt-5.1-codex-max",
+        id: "claude-opus-4-7-high",
+        provider: "claude",
+        model: "claude-opus-4-7",
+        extraArgs: ["--effort", "high"],
     },
     {
-        id: "gpt-5-1-codex-max-xhigh",
-        provider: "codex",
-        model: "gpt-5.1-codex-max",
-        extraArgs: ["--config", "model_reasoning_effort=xhigh"],
+        id: "claude-opus-4-7-xhigh",
+        provider: "claude",
+        model: "claude-opus-4-7",
+        extraArgs: ["--effort", "xhigh"],
     },
     {
         id: "gpt-5-2",
@@ -129,23 +115,6 @@ const DEFAULT_AGENT_CATALOG_ENTRIES = [
         model: "gpt-5.2",
         extraArgs: ["--config", "model_reasoning_effort=xhigh"],
     },
-    {
-        id: "gpt-5-2-codex",
-        provider: "codex",
-        model: "gpt-5.2-codex",
-    },
-    {
-        id: "gpt-5-2-codex-high",
-        provider: "codex",
-        model: "gpt-5.2-codex",
-        extraArgs: ["--config", "model_reasoning_effort=high"],
-    },
-    {
-        id: "gpt-5-2-codex-xhigh",
-        provider: "codex",
-        model: "gpt-5.2-codex",
-        extraArgs: ["--config", "model_reasoning_effort=xhigh"],
-    },
     {
         id: "gpt-5-3-codex-spark",
         provider: "codex",
@@ -218,10 +187,10 @@ const DEFAULT_AGENT_CATALOG_ENTRIES = [
 ];
 const PRO_AGENT_PRESET_ENTRIES = [
     {
-        id: "claude-opus-4-6",
+        id: "claude-opus-4-7-xhigh",
         provider: "claude",
-        model: "claude-opus-4-6",
-        extraArgs: ["--effort", "high"],
+        model: "claude-opus-4-7",
+        extraArgs: ["--effort", "xhigh"],
     },
     {
         id: "gpt-5-4-high",
@@ -244,9 +213,9 @@ const LITE_AGENT_PRESET_ENTRIES = [
         extraArgs: ["--effort", "high"],
     },
     {
-        id: "gpt-5-3-codex-spark",
+        id: "gpt-5-4-mini",
         provider: "codex",
-        model: "gpt-5.3-codex-spark",
+        model: "gpt-5.4-mini",
     },
     {
         id: "gemini-3-flash-preview",

package/dist/configs/agents/loader.js

@@ -3,7 +3,7 @@ import { basename } from "node:path";
 import { toErrorMessage } from "../../utils/errors.js";
 import { isFileSystemError } from "../../utils/fs.js";
 import { parseYamlDocument, } from "../../utils/yaml-reader.js";
-import { resolveWorkspacePath } from "../../workspace/structure.js";
+import { resolveWorkspacePath } from "../../workspace/path-resolvers.js";
 import { createConfigLoader } from "../shared/loader-factory.js";
 import { formatYamlErrorMessage } from "../shared/yaml-error-formatter.js";
 import { getAgentDefault, MODEL_PLACEHOLDER, } from "./defaults.js";

package/dist/configs/environment/loader.js

@@ -1,5 +1,6 @@
 import { parseYamlDocument, } from "../../utils/yaml-reader.js";
-import { resolveWorkspacePath, VORATIQ_ENVIRONMENT_FILE, } from "../../workspace/structure.js";
+import { VORATIQ_ENVIRONMENT_FILE } from "../../workspace/constants.js";
+import { resolveWorkspacePath } from "../../workspace/path-resolvers.js";
 import { createConfigLoader } from "../shared/loader-factory.js";
 import { formatYamlErrorDetail } from "../shared/yaml-error-formatter.js";
 import { EnvironmentConfigParseError, MissingEnvironmentConfigError, } from "./errors.js";

package/dist/configs/orchestration/loader.js

@@ -1,7 +1,8 @@
 import { readAgentsConfig } from "../../configs/agents/loader.js";
 import { isMissing, readUtf8File } from "../../utils/fs.js";
 import { parseYamlDocument, } from "../../utils/yaml-reader.js";
-import { resolveWorkspacePath, VORATIQ_AGENTS_FILE, VORATIQ_ORCHESTRATION_FILE, } from "../../workspace/structure.js";
+import { VORATIQ_AGENTS_FILE, VORATIQ_ORCHESTRATION_FILE, } from "../../workspace/constants.js";
+import { resolveWorkspacePath } from "../../workspace/path-resolvers.js";
 import { createConfigLoader } from "../shared/loader-factory.js";
 import { DEFAULT_ORCHESTRATION_ERROR_CONTEXT, MissingOrchestrationConfigError, OrchestrationSchemaValidationError, OrchestrationYamlParseError, } from "./errors.js";
 import { ORCHESTRATION_STAGE_IDS, orchestrationConfigSchema, } from "./types.js";

package/dist/configs/sandbox/loader.js

@@ -3,7 +3,8 @@ import process from "node:process";
 import { assertTestHookRegistrationEnabled } from "../../testing/test-hooks.js";
 import { relativeToRoot } from "../../utils/path.js";
 import { parseYamlDocument, } from "../../utils/yaml-reader.js";
-import { resolveWorkspacePath, VORATIQ_SANDBOX_FILE, } from "../../workspace/structure.js";
+import { VORATIQ_SANDBOX_FILE } from "../../workspace/constants.js";
+import { resolveWorkspacePath } from "../../workspace/path-resolvers.js";
 import { createConfigLoader } from "../shared/loader-factory.js";
 import { formatYamlErrorMessage } from "../shared/yaml-error-formatter.js";
 import { listSandboxProviderDefaults, listSandboxProviderIds, } from "./defaults.js";

package/dist/configs/settings/loader.js

@@ -1,6 +1,6 @@
 import process from "node:process";
 import { parseYamlDocument } from "../../utils/yaml-reader.js";
-import { resolveWorkspacePath } from "../../workspace/structure.js";
+import { resolveWorkspacePath } from "../../workspace/path-resolvers.js";
 import { createConfigLoader } from "../shared/loader-factory.js";
 import { repoSettingsSchema } from "./types.js";
 const SETTINGS_CONFIG_FILENAME = "settings.yaml";

package/dist/configs/verification/loader.js

@@ -1,6 +1,7 @@
 import { ZodError } from "zod";
 import { parseYamlDocument, } from "../../utils/yaml-reader.js";
-import { resolveWorkspacePath, VORATIQ_VERIFICATION_CONFIG_FILE, } from "../../workspace/structure.js";
+import { VORATIQ_VERIFICATION_CONFIG_FILE } from "../../workspace/constants.js";
+import { resolveWorkspacePath } from "../../workspace/path-resolvers.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";