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

package/dist/commands/run/validation.js

@@ -1,86 +1,49 @@
-import { readFile } from "node:fs/promises";
-import { verifyAgentProviders } from "../../agents/runtime/auth.js";
-import { loadAgentCatalogDiagnostics } from "../../configs/agents/loader.js";
-import { EnvironmentConfigParseError, MissingEnvironmentConfigError, } from "../../configs/environment/errors.js";
-import { DEFAULT_ENVIRONMENT_FILE_DISPLAY, loadEnvironmentConfig, } from "../../configs/environment/loader.js";
-import { loadRepoSettings } from "../../configs/settings/loader.js";
 import { NoAgentsEnabledError, RunPreflightError, } from "../../domain/run/competition/errors.js";
 import { RunOptionValidationError } from "../../domain/run/model/errors.js";
-import { toErrorMessage } from "../../utils/errors.js";
+import { loadOperatorEnvironment } from "../../preflight/environment.js";
+import { prepareConfiguredOperatorReadiness } from "../../preflight/operator.js";
 import { getHeadRevision } from "../../utils/git.js";
-import { WorkspaceMissingEntryError } from "../../workspace/errors.js";
 import { resolveEffectiveMaxParallel } from "../shared/max-parallel.js";
+import { loadRunSpecInput } from "./spec-provenance.js";
 /**
  * Validate command parameters, load spec, and prepare execution prerequisites.
  */
 export async function validateAndPrepare(input) {
-    const { root, specAbsolutePath, resolvedAgentIds, maxParallel: requestedMaxParallel, } = input;
+    const { root, specAbsolutePath, specDisplayPath, specsFilePath, resolvedAgentIds, maxParallel: requestedMaxParallel, } = input;
     if (requestedMaxParallel !== undefined &&
         (!Number.isInteger(requestedMaxParallel) || requestedMaxParallel <= 0)) {
         throw new RunOptionValidationError("maxParallel", "must be a positive integer");
     }
-    const specContent = await readFile(specAbsolutePath, "utf8");
+    const { specContent, specTarget } = await loadRunSpecInput({
+        root,
+        specAbsolutePath,
+        specDisplayPath: specDisplayPath ?? specAbsolutePath,
+        specsFilePath,
+    });
     const baseRevisionSha = await getHeadRevision(root);
-    const preflightIssues = [];
-    let agents;
-    if (resolvedAgentIds) {
-        if (resolvedAgentIds.length === 0) {
-            throw new NoAgentsEnabledError();
-        }
-        const selectedAgentIds = new Set(resolvedAgentIds);
-        const agentDiagnostics = loadAgentCatalogDiagnostics({ root });
-        preflightIssues.push(...agentDiagnostics.issues.filter((issue) => selectedAgentIds.has(issue.agentId)));
-        const catalogById = new Map(agentDiagnostics.catalog.map((agent) => [agent.id, agent]));
-        agents = resolvedAgentIds.flatMap((agentId) => {
-            const agent = catalogById.get(agentId);
-            return agent ? [agent] : [];
-        });
-    }
-    else {
-        const agentDiagnostics = loadAgentCatalogDiagnostics({ root });
-        const enabledAgents = agentDiagnostics.enabledAgents;
-        if (enabledAgents.length === 0) {
-            throw new NoAgentsEnabledError();
-        }
-        preflightIssues.push(...agentDiagnostics.issues);
-        agents = agentDiagnostics.catalog;
-    }
-    try {
-        loadRepoSettings({ root });
-    }
-    catch (error) {
-        preflightIssues.push({
-            agentId: "settings",
-            message: toErrorMessage(error),
-        });
+    const preflight = await prepareConfiguredOperatorReadiness({
+        root,
+        resolvedAgentIds,
+        includeEnvironment: false,
+    });
+    if (preflight.noAgentsEnabled) {
+        throw new NoAgentsEnabledError();
     }
-    const preProviderIssueCount = preflightIssues.length;
-    const providerIssues = await verifyAgentProviders(agents.map((agent) => ({
-        id: agent.id,
-        provider: agent.provider,
-    })));
-    preflightIssues.push(...providerIssues);
-    if (preflightIssues.length > 0) {
-        throw new RunPreflightError(preflightIssues, preProviderIssueCount === 0 ? [] : undefined);
+    if (preflight.issues.length > 0) {
+        throw new RunPreflightError(preflight.issues, preflight.preProviderIssueCount);
     }
-    const environment = (() => {
-        try {
-            return loadEnvironmentConfig({ root });
-        }
-        catch (error) {
-            if (error instanceof MissingEnvironmentConfigError ||
-                error instanceof EnvironmentConfigParseError) {
-                throw new WorkspaceMissingEntryError(DEFAULT_ENVIRONMENT_FILE_DISPLAY);
-            }
-            throw error;
-        }
-    })();
+    const agents = preflight.agents;
+    const environment = loadOperatorEnvironment({
+        root,
+        errorMode: "workspace-missing",
+    });
     const effectiveMaxParallel = resolveEffectiveMaxParallel({
         competitorCount: agents.length,
         requestedMaxParallel,
     });
     return {
         specContent,
+        specTarget,
         baseRevisionSha,
         agents,
         effectiveMaxParallel,

package/dist/commands/shared/resolve-stage-competitors.js

@@ -4,7 +4,8 @@ import { loadAgentById } from "../../configs/agents/loader.js";
 import { loadOrchestrationConfig } from "../../configs/orchestration/loader.js";
 import { HintedError } from "../../utils/errors.js";
 import { readUtf8File } from "../../utils/fs.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";
 const ORCHESTRATION_CONFIG_DISPLAY_PATH = VORATIQ_ORCHESTRATION_FILE;
 const DEFAULT_PROFILE_NAME = "default";
 export function resolveStageCompetitors(input) {

package/dist/commands/spec/command.js

@@ -1,20 +1,22 @@
 import { executeCompetitionWithAdapter } from "../../competition/command-adapter.js";
 import { AgentNotFoundError } from "../../configs/agents/errors.js";
-import { loadEnvironmentConfig } from "../../configs/environment/loader.js";
-import { buildLifecycleStartFields, buildOperationLifecycleCompleteFields, } from "../../domain/shared/lifecycle.js";
 import { createSpecCompetitionAdapter, } from "../../domain/spec/competition/adapter.js";
+import { createSpecRecordMutators } from "../../domain/spec/model/mutators.js";
 import { deriveSpecStatusFromAgents, } from "../../domain/spec/model/types.js";
-import { appendSpecRecord, finalizeSpecRecord, flushSpecRecordBuffer, rewriteSpecRecord, } from "../../domain/spec/persistence/adapter.js";
+import { appendSpecRecord, flushSpecRecordBuffer, } from "../../domain/spec/persistence/adapter.js";
 import { buildPersistedExtraContextFields } from "../../extra-context/contract.js";
+import { loadOperatorEnvironment } from "../../preflight/environment.js";
+import { prepareConfiguredOperatorReadiness } from "../../preflight/operator.js";
 import { toErrorMessage } from "../../utils/errors.js";
 import { getHeadRevision } from "../../utils/git.js";
+import { emitSwarmSessionAcknowledgement } from "../../utils/swarm-session-ack.js";
 import { resolveEffectiveMaxParallel } from "../shared/max-parallel.js";
 import { resolveStageCompetitors } from "../shared/resolve-stage-competitors.js";
 import { generateSessionId } from "../shared/session-id.js";
-import { SpecAgentNotFoundError, SpecGenerationFailedError } from "./errors.js";
+import { SpecAgentNotFoundError, SpecGenerationFailedError, SpecPreflightError, } from "./errors.js";
 export async function executeSpecCommand(input) {
     const { root, specsFilePath, description, agentIds: cliAgentIds, profileName, maxParallel: requestedMaxParallel, title: providedTitle, extraContextFiles = [], onStatus, renderer, } = input;
-    let competitors;
+    let resolvedAgentIds;
     try {
         const normalizedCliIds = cliAgentIds && cliAgentIds.length > 0 ? [...cliAgentIds] : undefined;
         const resolution = resolveStageCompetitors({
@@ -22,9 +24,10 @@ export async function executeSpecCommand(input) {
             stageId: "spec",
             cliAgentIds: normalizedCliIds,
             profileName,
+            includeDefinitions: false,
         });
-        competitors = resolution.competitors;
-        if (competitors.length === 0) {
+        resolvedAgentIds = resolution.agentIds;
+        if (resolvedAgentIds.length === 0) {
             throw new SpecGenerationFailedError(["Spec agent resolution failed."]);
         }
     }
@@ -34,7 +37,16 @@ export async function executeSpecCommand(input) {
         }
         throw error;
     }
-    const environment = loadEnvironmentConfig({ root });
+    const preflight = await prepareConfiguredOperatorReadiness({
+        root,
+        resolvedAgentIds,
+        includeEnvironment: false,
+    });
+    if (preflight.issues.length > 0) {
+        throw new SpecPreflightError(preflight.issues, preflight.preProviderIssueCount);
+    }
+    const competitors = preflight.agents;
+    const environment = loadOperatorEnvironment({ root });
     const effectiveMaxParallel = resolveEffectiveMaxParallel({
         competitorCount: competitors.length,
         requestedMaxParallel,
@@ -65,6 +77,16 @@ export async function executeSpecCommand(input) {
         specsFilePath,
         record,
     });
+    await emitSwarmSessionAcknowledgement({
+        operator: "spec",
+        sessionId,
+        status: "running",
+    });
+    const mutators = createSpecRecordMutators({
+        root,
+        specsFilePath,
+        sessionId,
+    });
     let currentAgents = [...initialAgents];
     onStatus?.("Generating specification…");
     renderer?.begin({
@@ -90,14 +112,15 @@ export async function executeSpecCommand(input) {
             adapter: {
                 ...baseAdapter,
                 onPreparationFailure: async (result) => {
-                    currentAgents = await persistSpecAgentFailure({
-                        root,
-                        specsFilePath,
-                        sessionId,
+                    const updatedRecord = await mutators.recordAgentSnapshot({
                         agentId: result.agentId,
+                        status: "failed",
+                        startedAt: new Date().toISOString(),
+                        completedAt: new Date().toISOString(),
                         tokenUsage: result.tokenUsage,
                         error: result.error ?? null,
                     });
+                    currentAgents = [...updatedRecord.agents];
                     const failedAgent = currentAgents.find((agent) => agent.agentId === result.agentId);
                     renderer?.update({
                         agentId: result.agentId,
@@ -110,12 +133,10 @@ export async function executeSpecCommand(input) {
                 },
                 onCandidateRunning: async (prepared, index) => {
                     await baseAdapter.onCandidateRunning?.(prepared, index);
-                    currentAgents = await persistSpecAgentRunning({
-                        root,
-                        specsFilePath,
-                        sessionId,
+                    const updatedRecord = await mutators.recordAgentRunning({
                         agentId: prepared.candidate.id,
                     });
+                    currentAgents = [...updatedRecord.agents];
                     const runningAgent = currentAgents.find((agent) => agent.agentId === prepared.candidate.id);
                     renderer?.update({
                         agentId: prepared.candidate.id,
@@ -124,12 +145,8 @@ export async function executeSpecCommand(input) {
                     });
                 },
                 onCandidateCompleted: async (_prepared, result) => {
-                    currentAgents = await persistSpecAgentCompletion({
-                        root,
-                        specsFilePath,
-                        sessionId,
-                        result,
-                    });
+                    const updatedRecord = await mutators.recordAgentSnapshot(toSpecAgentEntry(result));
+                    currentAgents = [...updatedRecord.agents];
                     const completedAgent = currentAgents.find((agent) => agent.agentId === result.agentId);
                     renderer?.update({
                         agentId: result.agentId,
@@ -145,10 +162,7 @@ export async function executeSpecCommand(input) {
     }
     catch (error) {
         const detail = toErrorMessage(error);
-        await finalizeSpecRecord({
-            root,
-            specsFilePath,
-            sessionId,
+        await mutators.completeSpec({
             status: "failed",
             error: detail,
         });
@@ -161,10 +175,7 @@ export async function executeSpecCommand(input) {
         : mapExecutionResultsToSpecAgents(executionResults, startedAt);
     // Derive session status from agent outcomes.
     const sessionStatus = deriveSpecStatusFromAgents(agentEntries.map((a) => a.status));
-    const latestRecord = await finalizeSpecRecord({
-        root,
-        specsFilePath,
-        sessionId,
+    const latestRecord = await mutators.completeSpec({
         status: sessionStatus,
         agents: agentEntries,
         error: sessionStatus === "failed" ? collectAgentErrors(agentEntries) : undefined,
@@ -195,114 +206,6 @@ function collectAgentErrors(agents) {
         .map((a) => `${a.agentId}: ${a.error}`);
     return errors.length > 0 ? errors.join("; ") : null;
 }
-async function persistSpecAgentRunning(options) {
-    const { root, specsFilePath, sessionId, agentId } = options;
-    const timestamp = new Date().toISOString();
-    const updated = await rewriteSpecRecord({
-        root,
-        specsFilePath,
-        sessionId,
-        mutate: (record) => ({
-            ...record,
-            agents: record.agents.map((agent) => agent.agentId === agentId
-                ? {
-                    ...agent,
-                    status: "running",
-                    ...buildLifecycleStartFields({
-                        existingStartedAt: agent.startedAt,
-                        timestamp,
-                    }),
-                    completedAt: undefined,
-                    error: null,
-                }
-                : agent),
-        }),
-    });
-    return [...updated.agents];
-}
-async function persistSpecAgentCompletion(options) {
-    const { root, specsFilePath, sessionId, result } = options;
-    const completedAt = new Date().toISOString();
-    const updated = await rewriteSpecRecord({
-        root,
-        specsFilePath,
-        sessionId,
-        mutate: (record) => ({
-            ...record,
-            agents: record.agents.map((agent) => {
-                if (agent.agentId !== result.agentId) {
-                    return agent;
-                }
-                const startedAt = buildLifecycleStartFields({
-                    existingStartedAt: agent.startedAt,
-                    timestamp: completedAt,
-                }).startedAt;
-                const completeFields = buildOperationLifecycleCompleteFields({
-                    existing: {
-                        startedAt,
-                        completedAt: agent.completedAt,
-                    },
-                    completedAt,
-                });
-                if (result.status === "succeeded") {
-                    return {
-                        ...agent,
-                        status: "succeeded",
-                        ...completeFields,
-                        outputPath: result.outputPath,
-                        dataPath: result.dataPath,
-                        tokenUsage: result.tokenUsage,
-                        error: null,
-                    };
-                }
-                return {
-                    ...agent,
-                    status: "failed",
-                    ...completeFields,
-                    tokenUsage: result.tokenUsage,
-                    error: result.error ?? null,
-                };
-            }),
-        }),
-    });
-    return [...updated.agents];
-}
-async function persistSpecAgentFailure(options) {
-    const { root, specsFilePath, sessionId, agentId, tokenUsage, error } = options;
-    const completedAt = new Date().toISOString();
-    const updated = await rewriteSpecRecord({
-        root,
-        specsFilePath,
-        sessionId,
-        mutate: (record) => ({
-            ...record,
-            agents: record.agents.map((agent) => {
-                if (agent.agentId !== agentId) {
-                    return agent;
-                }
-                const startedAt = buildLifecycleStartFields({
-                    existingStartedAt: agent.startedAt,
-                    timestamp: completedAt,
-                }).startedAt;
-                const completeFields = buildOperationLifecycleCompleteFields({
-                    existing: {
-                        startedAt,
-                        completedAt: agent.completedAt,
-                    },
-                    completedAt,
-                });
-                return {
-                    ...agent,
-                    status: "failed",
-                    ...completeFields,
-                    ...(tokenUsage ? { tokenUsage } : {}),
-                    error: error ?? null,
-                };
-            }),
-        }),
-    });
-    return [...updated.agents];
-}
 function mapExecutionResultsToSpecAgents(executionResults, startedAt) {
     return executionResults.map((result) => {
         const completedAt = new Date().toISOString();
@@ -317,6 +220,7 @@ function mapExecutionResultsToSpecAgents(executionResults, startedAt) {
                 status: "succeeded",
                 outputPath: result.outputPath,
                 dataPath: result.dataPath,
+                contentHash: result.contentHash,
                 tokenUsage: result.tokenUsage,
             };
         }
@@ -328,3 +232,25 @@ function mapExecutionResultsToSpecAgents(executionResults, startedAt) {
         };
     });
 }
+function toSpecAgentEntry(result) {
+    const completedAt = new Date().toISOString();
+    if (result.status === "succeeded") {
+        return {
+            agentId: result.agentId,
+            status: "succeeded",
+            completedAt,
+            outputPath: result.outputPath,
+            dataPath: result.dataPath,
+            contentHash: result.contentHash,
+            tokenUsage: result.tokenUsage,
+            error: null,
+        };
+    }
+    return {
+        agentId: result.agentId,
+        status: "failed",
+        completedAt,
+        tokenUsage: result.tokenUsage,
+        error: result.error ?? null,
+    };
+}

package/dist/commands/spec/errors.d.ts

@@ -1,4 +1,5 @@
 import { CliError } from "../../cli/errors.js";
+import type { PreflightIssue } from "../../competition/shared/preflight.js";
 export declare class SpecError extends CliError {
     constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
 }
@@ -9,3 +10,7 @@ export declare class SpecAgentNotFoundError extends SpecError {
 export declare class SpecGenerationFailedError extends SpecError {
     constructor(detailLines?: readonly string[]);
 }
+export declare class SpecPreflightError extends SpecError {
+    readonly issues: readonly PreflightIssue[];
+    constructor(issues: readonly PreflightIssue[], preProviderIssueCount: number);
+}

package/dist/commands/spec/errors.js

@@ -1,4 +1,5 @@
 import { CliError } from "../../cli/errors.js";
+import { formatOperatorPreflightIssueLines, resolveOperatorPreflightHintLines, } from "../../preflight/formatting.js";
 export class SpecError extends CliError {
     constructor(headline, detailLines = [], hintLines = []) {
         super(headline, detailLines, hintLines);
@@ -21,3 +22,11 @@ export class SpecGenerationFailedError extends SpecError {
         this.name = "SpecGenerationFailedError";
     }
 }
+export class SpecPreflightError extends SpecError {
+    issues;
+    constructor(issues, preProviderIssueCount) {
+        super("Preflight failed. Aborting specification generation.", formatOperatorPreflightIssueLines(issues), resolveOperatorPreflightHintLines(issues, preProviderIssueCount) ?? []);
+        this.issues = Array.from(issues);
+        this.name = "SpecPreflightError";
+    }
+}

package/dist/commands/verify/agents.d.ts

@@ -4,5 +4,7 @@ export declare function resolveVerificationAgents(options: {
     root: string;
     agentOverrideFlag?: string;
     profileName?: string;
-}): AgentDefinition[];
-export declare function assertVerifierPreflight(agents: readonly AgentDefinition[]): Promise<void>;
+}): {
+    readonly agentIds: readonly string[];
+    readonly competitors: readonly AgentDefinition[];
+};

package/dist/commands/verify/agents.js

@@ -1,29 +1,22 @@
-import { verifyAgentProviders } from "../../agents/runtime/auth.js";
 import { AgentNotFoundError } from "../../configs/agents/errors.js";
 import { resolveStageCompetitors } from "../shared/resolve-stage-competitors.js";
+import { VerifyAgentNotFoundError } from "./errors.js";
 export function resolveVerificationAgents(options) {
     const { agentIds, root, agentOverrideFlag, profileName } = options;
     try {
-        const resolution = resolveStageCompetitors({
+        return resolveStageCompetitors({
             root,
             stageId: "verify",
             cliAgentIds: agentIds,
             cliOverrideFlag: agentOverrideFlag,
             profileName,
+            includeDefinitions: false,
         });
-        return [...resolution.competitors];
     }
     catch (error) {
         if (error instanceof AgentNotFoundError) {
-            throw new Error(`Verifier agent not found: ${error.agentId}`);
+            throw new VerifyAgentNotFoundError(error.agentId);
         }
         throw error;
     }
 }
-export async function assertVerifierPreflight(agents) {
-    const providerIssues = await verifyAgentProviders(agents.map((agent) => ({ id: agent.id, provider: agent.provider })));
-    if (providerIssues.length > 0) {
-        const detail = providerIssues.map((issue) => issue.message).join("; ");
-        throw new Error(`Verifier preflight failed: ${detail}`);
-    }
-}

package/dist/commands/verify/command.js

@@ -1,6 +1,5 @@
 import { teardownSessionAuth } from "../../agents/runtime/registry.js";
 import { createTeardownController } from "../../competition/shared/teardown.js";
-import { loadEnvironmentConfig } from "../../configs/environment/loader.js";
 import { loadVerificationConfig } from "../../configs/verification/loader.js";
 import { buildBlindedAliasMap } from "../../domain/verify/competition/blinding.js";
 import { deriveVerificationStatusFromMethods, maybePersistSelectedSpecPath, } from "../../domain/verify/competition/finalize.js";
@@ -9,11 +8,16 @@ import { executeAndPersistRubricMethods } from "../../domain/verify/competition/
 import { createVerificationRecordMutators } from "../../domain/verify/model/mutators.js";
 import { appendVerificationRecord, flushVerificationRecordBuffer, } from "../../domain/verify/persistence/adapter.js";
 import { buildPersistedExtraContextFields } from "../../extra-context/contract.js";
+import { loadOperatorEnvironment } from "../../preflight/environment.js";
+import { prepareConfiguredOperatorReadiness } from "../../preflight/operator.js";
 import { toErrorMessage } from "../../utils/errors.js";
 import { normalizePathForDisplay, relativeToRoot } from "../../utils/path.js";
-import { resolveWorkspacePath, VORATIQ_VERIFICATION_SESSIONS_DIR, } from "../../workspace/structure.js";
+import { emitSwarmSessionAcknowledgement } from "../../utils/swarm-session-ack.js";
+import { VORATIQ_VERIFICATION_SESSIONS_DIR } from "../../workspace/constants.js";
+import { resolveWorkspacePath } from "../../workspace/path-resolvers.js";
 import { generateSessionId } from "../shared/session-id.js";
-import { assertVerifierPreflight, resolveVerificationAgents, } from "./agents.js";
+import { resolveVerificationAgents } from "./agents.js";
+import { VerifyPreflightError } from "./errors.js";
 import { finalizeActiveVerification, registerActiveVerification, } from "./lifecycle.js";
 import { resolveVerifyRubricMaxParallel } from "./max-parallel.js";
 import { resolveVerifyTarget } from "./targets.js";
@@ -29,14 +33,22 @@ export async function executeVerifyCommand(input) {
         target,
     });
     const verificationConfig = loadVerificationConfig({ root });
-    const verificationAgents = resolveVerificationAgents({
+    const verificationPlan = resolveVerificationAgents({
         agentIds,
         root,
         agentOverrideFlag,
         profileName,
     });
-    await assertVerifierPreflight(verificationAgents);
-    const environment = loadEnvironmentConfig({ root });
+    const preflight = await prepareConfiguredOperatorReadiness({
+        root,
+        resolvedAgentIds: verificationPlan.agentIds,
+        includeEnvironment: false,
+    });
+    if (preflight.issues.length > 0) {
+        throw new VerifyPreflightError(preflight.issues, preflight.preProviderIssueCount);
+    }
+    const verificationAgents = preflight.agents;
+    const environment = loadOperatorEnvironment({ root });
     const verificationId = generateSessionId();
     const createdAt = new Date().toISOString();
     const aliasMap = buildBlindedAliasMap(resolvedTarget);
@@ -59,6 +71,11 @@ export async function executeVerifyCommand(input) {
             methods: [],
         },
     });
+    await emitSwarmSessionAcknowledgement({
+        operator: "verify",
+        sessionId: verificationId,
+        status: "queued",
+    });
     renderer?.begin({
         verificationId,
         createdAt,

package/dist/commands/verify/errors.d.ts

@@ -0,0 +1,12 @@
+import { CliError } from "../../cli/errors.js";
+import type { PreflightIssue } from "../../competition/shared/preflight.js";
+export declare class VerifyError extends CliError {
+    constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
+}
+export declare class VerifyAgentNotFoundError extends VerifyError {
+    constructor(agentId: string);
+}
+export declare class VerifyPreflightError extends VerifyError {
+    readonly issues: readonly PreflightIssue[];
+    constructor(issues: readonly PreflightIssue[], preProviderIssueCount: number);
+}

package/dist/commands/verify/errors.js

@@ -0,0 +1,22 @@
+import { CliError } from "../../cli/errors.js";
+import { formatOperatorPreflightIssueLines, resolveOperatorPreflightHintLines, } from "../../preflight/formatting.js";
+export class VerifyError extends CliError {
+    constructor(headline, detailLines = [], hintLines = []) {
+        super(headline, detailLines, hintLines);
+        this.name = "VerifyError";
+    }
+}
+export class VerifyAgentNotFoundError extends VerifyError {
+    constructor(agentId) {
+        super(`Verifier agent not found: ${agentId}`);
+        this.name = "VerifyAgentNotFoundError";
+    }
+}
+export class VerifyPreflightError extends VerifyError {
+    issues;
+    constructor(issues, preProviderIssueCount) {
+        super("Preflight failed. Aborting verification.", formatOperatorPreflightIssueLines(issues), resolveOperatorPreflightHintLines(issues, preProviderIssueCount) ?? []);
+        this.issues = Array.from(issues);
+        this.name = "VerifyPreflightError";
+    }
+}

package/dist/commands/verify/lifecycle.js

@@ -3,7 +3,7 @@ import { buildOperationLifecycleCompleteFields, buildRecordLifecycleCompleteFiel
 import { writeVerificationArtifact } from "../../domain/verify/competition/artifacts.js";
 import { flushVerificationRecordBuffer, readVerificationRecords, rewriteVerificationRecord, } from "../../domain/verify/persistence/adapter.js";
 import { toErrorMessage } from "../../utils/errors.js";
-import { getVerificationProgrammaticResultPath, getVerificationRubricResultPath, } from "../../workspace/structure.js";
+import { getVerificationProgrammaticResultPath, getVerificationRubricResultPath, } from "../../workspace/artifact-paths.js";
 export const VERIFY_ABORT_DETAIL = "Verification aborted before completion.";
 let activeVerification;
 let terminationInFlight = false;