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

package/dist/commands/list/normalization.d.ts

@@ -0,0 +1,51 @@
+import type { ListJsonArtifact, ListJsonChanges, ListJsonTargetRef, ListOperator } from "../../contracts/list.js";
+export { formatTargetDisplay, formatTargetTablePreview, TARGET_TABLE_PREVIEW_LENGTH, } from "../../utils/list-target.js";
+import { type ListRecord } from "./records.js";
+export type ListTargetOperator = ListOperator;
+export type ListSessionTarget = {
+    kind: ListTargetOperator;
+    sessionId: string;
+};
+export type ListLaneTarget = {
+    kind: Exclude<ListTargetOperator, "interactive">;
+    sessionId: string;
+    agentId: string;
+};
+export type ListFileTarget = {
+    kind: "file";
+    path: string;
+};
+export type ListTarget = ListSessionTarget | ListLaneTarget | ListFileTarget;
+export type ListOperatorRecord = ListRecord;
+export interface NormalizedListSession {
+    operator: ListOperator;
+    sessionId: string;
+    status: string;
+    createdAt: string;
+    target?: ListTarget;
+    description?: string | null;
+}
+export interface NormalizedListAgent {
+    agentId: string | null;
+    status: string;
+    startedAt?: string;
+    completedAt?: string;
+    verifier?: string;
+    diffStatistics?: string;
+    changes?: ListJsonChanges;
+    outputPath?: string;
+    dataPath?: string;
+    errorLine?: string;
+    artifacts: ListJsonArtifact[];
+}
+export interface NormalizedListDetailSession extends NormalizedListSession {
+    startedAt?: string;
+    completedAt?: string;
+    workspacePath: string;
+    agents: NormalizedListAgent[];
+}
+export declare function normalizeListSession(operator: ListOperator, record: ListOperatorRecord): NormalizedListSession;
+export declare function normalizeListDetailSession(operator: ListOperator, record: ListOperatorRecord): NormalizedListDetailSession;
+export declare function normalizeListTarget(operator: ListOperator, record: ListOperatorRecord): ListTarget | undefined;
+export declare function toListJsonTargetRef(target: ListTarget): ListJsonTargetRef;
+export declare function normalizeDescription(description: string | null | undefined): string | null;

package/dist/commands/list/normalization.js

@@ -0,0 +1,309 @@
+import { buildRunRecordEnhanced } from "../../domain/run/model/enhanced.js";
+import { extractStat } from "../../utils/diff.js";
+import { getInteractiveSessionDirectoryPath, getMessageSessionDirectoryPath, getReductionSessionDirectoryPath, getRunDirectoryPath, getSpecSessionDirectoryPath, getVerificationSessionDirectoryPath, } from "../../workspace/session-paths.js";
+export { formatTargetDisplay, formatTargetTablePreview, TARGET_TABLE_PREVIEW_LENGTH, } from "../../utils/list-target.js";
+import { getListRecordId } from "./records.js";
+const FILES_CHANGED_PATTERN = /(\d+)\s+file/u;
+const INSERTIONS_PATTERN = /(\d+)\s+insertion/u;
+const DELETIONS_PATTERN = /(\d+)\s+deletion/u;
+export function normalizeListSession(operator, record) {
+    return {
+        operator,
+        sessionId: getListRecordId(operator, record),
+        status: getRecordStatus(record),
+        createdAt: getRecordCreatedAt(record),
+        target: normalizeListTarget(operator, record),
+        ...(operator === "spec"
+            ? {
+                description: normalizeDescription(record.description),
+            }
+            : {}),
+    };
+}
+export function normalizeListDetailSession(operator, record) {
+    const session = normalizeListSession(operator, record);
+    if (operator === "run") {
+        const runRecord = record;
+        const enhancedRunRecord = buildRunRecordEnhanced(runRecord);
+        return {
+            ...session,
+            startedAt: runRecord.startedAt,
+            completedAt: runRecord.completedAt,
+            workspacePath: getRunDirectoryPath(runRecord.runId),
+            agents: enhancedRunRecord.agents.map((agent) => ({
+                agentId: agent.agentId,
+                status: agent.status,
+                startedAt: agent.startedAt,
+                completedAt: agent.completedAt,
+                diffStatistics: agent.diffStatistics,
+                changes: parseDiffStatistics(agent.diffStatistics),
+                outputPath: agent.assets.diffPath,
+                errorLine: agent.error ?? undefined,
+                artifacts: agent.assets.diffPath
+                    ? [
+                        {
+                            kind: "diff",
+                            role: "output",
+                            path: agent.assets.diffPath,
+                        },
+                    ]
+                    : [],
+            })),
+        };
+    }
+    if (operator === "spec") {
+        const specRecord = record;
+        return {
+            ...session,
+            startedAt: specRecord.startedAt,
+            completedAt: specRecord.completedAt,
+            workspacePath: getSpecSessionDirectoryPath(specRecord.sessionId),
+            agents: specRecord.agents.map((agent) => ({
+                agentId: agent.agentId,
+                status: agent.status,
+                startedAt: agent.startedAt,
+                completedAt: agent.completedAt,
+                outputPath: agent.outputPath,
+                dataPath: agent.dataPath,
+                errorLine: agent.error ?? undefined,
+                artifacts: [
+                    ...(agent.outputPath
+                        ? [
+                            {
+                                kind: "spec",
+                                role: "output",
+                                path: agent.outputPath,
+                            },
+                        ]
+                        : []),
+                    ...(agent.dataPath
+                        ? [
+                            {
+                                kind: "spec",
+                                role: "data",
+                                path: agent.dataPath,
+                            },
+                        ]
+                        : []),
+                ],
+            })),
+        };
+    }
+    if (operator === "reduce") {
+        const reductionRecord = record;
+        return {
+            ...session,
+            startedAt: reductionRecord.startedAt,
+            completedAt: reductionRecord.completedAt,
+            workspacePath: getReductionSessionDirectoryPath(reductionRecord.sessionId),
+            agents: reductionRecord.reducers.map((reducer) => ({
+                agentId: reducer.agentId,
+                status: reducer.status,
+                startedAt: reducer.startedAt,
+                completedAt: reducer.completedAt,
+                outputPath: reducer.outputPath,
+                dataPath: reducer.dataPath,
+                errorLine: reducer.error ?? undefined,
+                artifacts: [
+                    ...(reducer.outputPath
+                        ? [
+                            {
+                                kind: "reduction",
+                                role: "output",
+                                path: reducer.outputPath,
+                            },
+                        ]
+                        : []),
+                    ...(reducer.dataPath
+                        ? [
+                            {
+                                kind: "reduction",
+                                role: "data",
+                                path: reducer.dataPath,
+                            },
+                        ]
+                        : []),
+                ],
+            })),
+        };
+    }
+    if (operator === "message") {
+        const messageRecord = record;
+        return {
+            ...session,
+            startedAt: messageRecord.startedAt,
+            completedAt: messageRecord.completedAt,
+            workspacePath: getMessageSessionDirectoryPath(messageRecord.sessionId),
+            agents: messageRecord.recipients.map((recipient) => ({
+                agentId: recipient.agentId,
+                status: recipient.status,
+                startedAt: recipient.startedAt,
+                completedAt: recipient.completedAt,
+                outputPath: recipient.outputPath,
+                errorLine: recipient.error ?? undefined,
+                artifacts: recipient.outputPath
+                    ? [
+                        {
+                            kind: "response",
+                            role: "output",
+                            path: recipient.outputPath,
+                        },
+                    ]
+                    : [],
+            })),
+        };
+    }
+    if (operator === "interactive") {
+        const interactiveRecord = record;
+        return {
+            ...session,
+            startedAt: interactiveRecord.startedAt,
+            completedAt: interactiveRecord.completedAt,
+            workspacePath: getInteractiveSessionDirectoryPath(interactiveRecord.sessionId),
+            agents: [
+                {
+                    agentId: interactiveRecord.agentId,
+                    status: interactiveRecord.status,
+                    startedAt: interactiveRecord.startedAt,
+                    completedAt: interactiveRecord.completedAt,
+                    outputPath: interactiveRecord.chat?.captured
+                        ? interactiveRecord.chat.artifactPath
+                        : undefined,
+                    artifacts: interactiveRecord.chat?.captured &&
+                        interactiveRecord.chat.artifactPath
+                        ? [
+                            {
+                                kind: "chat",
+                                role: "output",
+                                path: interactiveRecord.chat.artifactPath,
+                            },
+                        ]
+                        : [],
+                },
+            ],
+        };
+    }
+    const verificationRecord = record;
+    return {
+        ...session,
+        startedAt: verificationRecord.startedAt,
+        completedAt: verificationRecord.completedAt,
+        workspacePath: getVerificationSessionDirectoryPath(verificationRecord.sessionId),
+        agents: verificationRecord.methods.map(normalizeVerificationMethod),
+    };
+}
+export function normalizeListTarget(operator, record) {
+    if (operator === "spec" || operator === "interactive") {
+        return undefined;
+    }
+    if (operator === "message") {
+        return normalizeMessageTarget(record);
+    }
+    if (operator === "run") {
+        return normalizeRunTarget(record);
+    }
+    if (operator === "reduce") {
+        const reductionRecord = record;
+        return {
+            kind: reductionRecord.target.type,
+            sessionId: reductionRecord.target.id,
+        };
+    }
+    const verificationRecord = record;
+    return {
+        kind: verificationRecord.target.kind,
+        sessionId: verificationRecord.target.sessionId,
+    };
+}
+export function toListJsonTargetRef(target) {
+    return target.kind === "file"
+        ? target
+        : {
+            kind: target.kind,
+            sessionId: target.sessionId,
+            ...("agentId" in target && target.agentId
+                ? { agentId: target.agentId }
+                : {}),
+        };
+}
+export function normalizeDescription(description) {
+    if (typeof description !== "string") {
+        return null;
+    }
+    const normalized = description.replace(/\s+/gu, " ").trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function normalizeRunTarget(record) {
+    if (record.spec.target?.kind === "spec") {
+        return {
+            kind: "spec",
+            sessionId: record.spec.target.sessionId,
+        };
+    }
+    return {
+        kind: "file",
+        path: record.spec.path,
+    };
+}
+function normalizeMessageTarget(record) {
+    if (!record.target) {
+        return undefined;
+    }
+    if (record.target.agentId) {
+        return {
+            kind: record.target.kind,
+            sessionId: record.target.sessionId,
+            agentId: record.target.agentId,
+        };
+    }
+    return {
+        kind: record.target.kind,
+        sessionId: record.target.sessionId,
+    };
+}
+function normalizeVerificationMethod(method) {
+    return {
+        agentId: method.verifierId ?? null,
+        verifier: method.method === "programmatic"
+            ? "programmatic"
+            : (method.template ?? "rubric"),
+        status: method.status,
+        startedAt: method.startedAt,
+        completedAt: method.completedAt,
+        outputPath: method.artifactPath,
+        errorLine: method.error ?? undefined,
+        artifacts: method.artifactPath
+            ? [
+                {
+                    kind: "verification-result",
+                    role: "output",
+                    path: method.artifactPath,
+                },
+            ]
+            : [],
+    };
+}
+function parseDiffStatistics(value) {
+    if (!value) {
+        return undefined;
+    }
+    const filesChanged = extractStat(FILES_CHANGED_PATTERN, value);
+    const insertions = extractStat(INSERTIONS_PATTERN, value);
+    const deletions = extractStat(DELETIONS_PATTERN, value);
+    if (filesChanged === undefined &&
+        insertions === undefined &&
+        deletions === undefined) {
+        return undefined;
+    }
+    return {
+        ...(filesChanged !== undefined ? { filesChanged } : {}),
+        ...(insertions !== undefined ? { insertions } : {}),
+        ...(deletions !== undefined ? { deletions } : {}),
+    };
+}
+function getRecordStatus(record) {
+    return record.status;
+}
+function getRecordCreatedAt(record) {
+    return record.createdAt;
+}

package/dist/commands/list/records.d.ts

@@ -0,0 +1,9 @@
+import type { ListOperator } from "../../contracts/list.js";
+import type { InteractiveSessionRecord } from "../../domain/interactive/model/types.js";
+import type { MessageRecord } from "../../domain/message/model/types.js";
+import type { ReductionRecord } from "../../domain/reduce/model/types.js";
+import type { RunRecord } from "../../domain/run/model/types.js";
+import type { SpecRecord } from "../../domain/spec/model/types.js";
+import type { VerificationRecord } from "../../domain/verify/model/types.js";
+export type ListRecord = InteractiveSessionRecord | RunRecord | SpecRecord | MessageRecord | ReductionRecord | VerificationRecord;
+export declare function getListRecordId(operator: ListOperator, record: ListRecord): string;

package/dist/commands/list/records.js

@@ -0,0 +1,6 @@
+export function getListRecordId(operator, record) {
+    if (operator === "run") {
+        return record.runId;
+    }
+    return record.sessionId;
+}

package/dist/commands/message/command.d.ts

@@ -1,6 +1,6 @@
 import type { ResolvedExtraContextFile } from "../../competition/shared/extra-context.js";
 import { type MessageCompetitionExecution } from "../../domain/message/competition/adapter.js";
-import { type MessageRecipientEntry, type MessageRecord } from "../../domain/message/model/types.js";
+import { type MessageRecipientEntry, type MessageRecord, type MessageTarget } from "../../domain/message/model/types.js";
 import type { MessageProgressRenderer } from "../../render/transcripts/message.js";
 export interface ExecuteMessageCommandInput {
     root: string;
@@ -11,7 +11,7 @@ export interface ExecuteMessageCommandInput {
     profileName?: string;
     maxParallel?: number;
     extraContextFiles?: readonly ResolvedExtraContextFile[];
-    sourceInteractiveSessionId?: string;
+    target?: MessageTarget;
     renderer?: MessageProgressRenderer;
 }
 export interface ExecuteMessageCommandResult {

package/dist/commands/message/command.js

@@ -1,25 +1,26 @@
-import { verifyAgentProviders } from "../../agents/runtime/auth.js";
 import { executeCompetitionWithAdapter } from "../../competition/command-adapter.js";
 import { createTeardownController } from "../../competition/shared/teardown.js";
 import { AgentNotFoundError } from "../../configs/agents/errors.js";
-import { loadEnvironmentConfig } from "../../configs/environment/loader.js";
 import { createMessageCompetitionAdapter, } from "../../domain/message/competition/adapter.js";
 import { createMessageRecordMutators } from "../../domain/message/model/mutators.js";
 import { deriveMessageStatusFromRecipients, } from "../../domain/message/model/types.js";
 import { appendMessageRecord, flushMessageRecordBuffer, } from "../../domain/message/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 { VORATIQ_MESSAGE_DIR, VORATIQ_REDUCTION_DIR, VORATIQ_RUN_DIR, VORATIQ_SPEC_DIR, VORATIQ_VERIFICATION_DIR, } from "../../workspace/structure.js";
+import { emitSwarmSessionAcknowledgement } from "../../utils/swarm-session-ack.js";
+import { VORATIQ_MESSAGE_DIR, VORATIQ_REDUCTION_DIR, VORATIQ_RUN_DIR, VORATIQ_SPEC_DIR, VORATIQ_VERIFICATION_DIR, } from "../../workspace/constants.js";
 import { resolveEffectiveMaxParallel } from "../shared/max-parallel.js";
 import { resolveStageCompetitors } from "../shared/resolve-stage-competitors.js";
 import { generateSessionId } from "../shared/session-id.js";
-import { MessageAgentNotFoundError, MessageGenerationFailedError, MessageInvocationContextError, } from "./errors.js";
+import { MessageAgentNotFoundError, MessageGenerationFailedError, MessageInvocationContextError, MessagePreflightError, } from "./errors.js";
 import { finalizeActiveMessage, registerActiveMessage } from "./lifecycle.js";
 export async function executeMessageCommand(input) {
     assertMessageInvocationContext();
-    const { root, messagesFilePath, prompt, agentIds, agentOverrideFlag, profileName, maxParallel: requestedMaxParallel, extraContextFiles = [], sourceInteractiveSessionId, renderer, } = input;
-    let competitors;
+    const { root, messagesFilePath, prompt, agentIds, agentOverrideFlag, profileName, maxParallel: requestedMaxParallel, extraContextFiles = [], target, renderer, } = input;
+    let resolvedAgentIds;
     try {
         const resolution = resolveStageCompetitors({
             root,
@@ -27,8 +28,9 @@ export async function executeMessageCommand(input) {
             cliAgentIds: agentIds,
             cliOverrideFlag: agentOverrideFlag,
             profileName,
+            includeDefinitions: false,
         });
-        competitors = resolution.competitors;
+        resolvedAgentIds = resolution.agentIds;
     }
     catch (error) {
         if (error instanceof AgentNotFoundError) {
@@ -36,12 +38,21 @@ export async function executeMessageCommand(input) {
         }
         throw error;
     }
-    await assertMessagePreflight(competitors);
-    const environment = loadEnvironmentConfig({ root });
+    const preflight = await prepareConfiguredOperatorReadiness({
+        root,
+        resolvedAgentIds,
+        includeEnvironment: false,
+    });
+    if (preflight.issues.length > 0) {
+        throw new MessagePreflightError(preflight.issues, preflight.preProviderIssueCount);
+    }
+    const competitors = preflight.agents;
+    const environment = loadOperatorEnvironment({ root });
     const baseRevisionSha = await getHeadRevision(root);
     const messageId = generateSessionId();
     const createdAt = new Date().toISOString();
     const startedAt = createdAt;
+    const persistedTarget = resolveMessageTarget({ target });
     const effectiveMaxParallel = resolveEffectiveMaxParallel({
         competitorCount: competitors.length,
         requestedMaxParallel,
@@ -62,9 +73,14 @@ export async function executeMessageCommand(input) {
             prompt,
             recipients: initialRecipients,
             ...buildPersistedExtraContextFields(extraContextFiles),
-            ...(sourceInteractiveSessionId ? { sourceInteractiveSessionId } : {}),
+            ...(persistedTarget ? { target: persistedTarget } : {}),
         },
     });
+    await emitSwarmSessionAcknowledgement({
+        operator: "message",
+        sessionId: messageId,
+        status: "running",
+    });
     renderer?.begin({
         messageId,
         createdAt,
@@ -187,12 +203,6 @@ function toRecipientEntry(execution) {
         error: execution.error ?? null,
     };
 }
-async function assertMessagePreflight(agents) {
-    const providerIssues = await verifyAgentProviders(agents.map((agent) => ({ id: agent.id, provider: agent.provider })));
-    if (providerIssues.length > 0) {
-        throw new MessageGenerationFailedError(providerIssues.map((issue) => `${issue.agentId}: ${issue.message}`));
-    }
-}
 function assertMessageInvocationContext() {
     const cwd = process.cwd().replace(/\\/gu, "/");
     const batchDomains = [
@@ -213,3 +223,6 @@ function collectRecipientErrors(recipients) {
         .map((recipient) => `${recipient.agentId}: ${recipient.error}`);
     return details.length > 0 ? details.join("; ") : undefined;
 }
+function resolveMessageTarget(options) {
+    return options.target;
+}

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

@@ -1,9 +1,18 @@
-export declare class MessageAgentNotFoundError extends Error {
+import { CliError } from "../../cli/errors.js";
+import type { PreflightIssue } from "../../competition/shared/preflight.js";
+export declare class MessageError extends CliError {
+    constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
+}
+export declare class MessageAgentNotFoundError extends MessageError {
     constructor(agentId: string);
 }
-export declare class MessageGenerationFailedError extends Error {
+export declare class MessageGenerationFailedError extends MessageError {
     constructor(details: readonly string[]);
 }
-export declare class MessageInvocationContextError extends Error {
+export declare class MessagePreflightError extends MessageError {
+    readonly issues: readonly PreflightIssue[];
+    constructor(issues: readonly PreflightIssue[], preProviderIssueCount: number);
+}
+export declare class MessageInvocationContextError extends MessageError {
     constructor();
 }

package/dist/commands/message/errors.js

@@ -1,10 +1,18 @@
-export class MessageAgentNotFoundError extends Error {
+import { CliError } from "../../cli/errors.js";
+import { formatOperatorPreflightIssueLines, resolveOperatorPreflightHintLines, } from "../../preflight/formatting.js";
+export class MessageError extends CliError {
+    constructor(headline, detailLines = [], hintLines = []) {
+        super(headline, detailLines, hintLines);
+        this.name = "MessageError";
+    }
+}
+export class MessageAgentNotFoundError extends MessageError {
     constructor(agentId) {
         super(`Message agent not found: ${agentId}`);
         this.name = "MessageAgentNotFoundError";
     }
 }
-export class MessageGenerationFailedError extends Error {
+export class MessageGenerationFailedError extends MessageError {
     constructor(details) {
         super(details.length > 0
             ? `Message execution failed: ${details.join("; ")}`
@@ -12,7 +20,15 @@ export class MessageGenerationFailedError extends Error {
         this.name = "MessageGenerationFailedError";
     }
 }
-export class MessageInvocationContextError extends Error {
+export class MessagePreflightError extends MessageError {
+    issues;
+    constructor(issues, preProviderIssueCount) {
+        super("Preflight failed. Aborting message.", formatOperatorPreflightIssueLines(issues), resolveOperatorPreflightHintLines(issues, preProviderIssueCount) ?? []);
+        this.issues = Array.from(issues);
+        this.name = "MessagePreflightError";
+    }
+}
+export class MessageInvocationContextError extends MessageError {
     constructor() {
         super("`message` cannot be invoked from inside a batch agent workspace.");
         this.name = "MessageInvocationContextError";

package/dist/commands/prune/command.js

@@ -7,8 +7,11 @@ import { toErrorMessage } from "../../utils/errors.js";
 import { pathExists } from "../../utils/fs.js";
 import { getGitStderr, runGitCommand } from "../../utils/git.js";
 import { normalizePathForDisplay, resolveDisplayPath, resolvePath, } from "../../utils/path.js";
+import { buildAgentArtifactPaths, getAgentWorkspaceDirectoryPath, } from "../../workspace/artifact-paths.js";
+import { VORATIQ_RUN_SESSIONS_DIR } from "../../workspace/constants.js";
+import { resolveWorkspacePath } from "../../workspace/path-resolvers.js";
 import { deriveAgentBranches, removeRunDirectory, removeWorkspaceEntry, } from "../../workspace/prune.js";
-import { buildAgentArtifactPaths, getAgentDirectoryPath, getAgentWorkspaceDirectoryPath, getRunDirectoryPath, resolveWorkspacePath, VORATIQ_RUN_SESSIONS_DIR, } from "../../workspace/structure.js";
+import { getAgentDirectoryPath, getRunDirectoryPath, } from "../../workspace/session-paths.js";
 import { fetchRunSafely } from "../fetch.js";
 import { PruneBranchDeletionError, PruneRunDeletedError, RunMetadataMissingError, } from "./errors.js";
 export async function executePruneCommand(input) {

package/dist/commands/reduce/command.js

@@ -1,9 +1,9 @@
-import { verifyAgentProviders } from "../../agents/runtime/auth.js";
 import { executeCompetitionWithAdapter } from "../../competition/command-adapter.js";
 import { AgentNotFoundError } from "../../configs/agents/errors.js";
-import { loadEnvironmentConfig } from "../../configs/environment/loader.js";
 import { createReduceCompetitionAdapter, } from "../../domain/reduce/competition/adapter.js";
 import { flushReductionRecordBuffer, readReductionRecords, } from "../../domain/reduce/persistence/adapter.js";
+import { loadOperatorEnvironment } from "../../preflight/environment.js";
+import { prepareConfiguredOperatorReadiness } from "../../preflight/operator.js";
 import { toErrorMessage } from "../../utils/errors.js";
 import { resolveEffectiveMaxParallel } from "../shared/max-parallel.js";
 import { resolveReductionCompetitors } from "../shared/resolve-reduction-competitors.js";
@@ -21,14 +21,22 @@ export async function executeReduceCommand(input) {
         verificationsFilePath,
         target,
     });
-    const reducers = resolveReduceAgents({
+    const reducerPlan = resolveReduceAgentPlan({
         root,
         agentIds,
         agentOverrideFlag,
         profileName,
     });
-    await assertReducePreflight(reducers);
-    const environment = loadEnvironmentConfig({ root });
+    const preflight = await prepareConfiguredOperatorReadiness({
+        root,
+        resolvedAgentIds: reducerPlan.agentIds,
+        includeEnvironment: false,
+    });
+    if (preflight.issues.length > 0) {
+        throw new ReducePreflightError(preflight.issues, preflight.preProviderIssueCount);
+    }
+    const reducers = preflight.agents;
+    const environment = loadOperatorEnvironment({ root });
     const reductionId = generateSessionId();
     const createdAt = new Date().toISOString();
     const effectiveMaxParallel = resolveEffectiveMaxParallel({
@@ -106,16 +114,16 @@ export async function executeReduceCommand(input) {
         reductions: reductionResults,
     };
 }
-function resolveReduceAgents(options) {
+function resolveReduceAgentPlan(options) {
     const { agentIds, root, agentOverrideFlag, profileName } = options;
     try {
-        const resolution = resolveReductionCompetitors({
+        return resolveReductionCompetitors({
             root,
             cliAgentIds: agentIds,
             cliOverrideFlag: agentOverrideFlag,
             profileName,
+            includeDefinitions: false,
         });
-        return [...resolution.competitors];
     }
     catch (error) {
         if (error instanceof AgentNotFoundError) {
@@ -124,15 +132,6 @@ function resolveReduceAgents(options) {
         throw error;
     }
 }
-async function assertReducePreflight(agents) {
-    const providerIssues = await verifyAgentProviders(agents.map((agent) => ({
-        id: agent.id,
-        provider: agent.provider,
-    })));
-    if (providerIssues.length > 0) {
-        throw new ReducePreflightError(providerIssues, []);
-    }
-}
 async function readReductionSessionRecord(options) {
     const { root, reductionsFilePath, reductionId } = options;
     const records = await readReductionRecords({

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

@@ -1,5 +1,5 @@
 import { CliError } from "../../cli/errors.js";
-import { type PreflightIssue } from "../../competition/shared/preflight.js";
+import type { PreflightIssue } from "../../competition/shared/preflight.js";
 export type ReducePreflightIssue = PreflightIssue;
 export declare class ReduceError extends CliError {
     constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
@@ -10,7 +10,7 @@ export declare class ReduceAgentNotFoundError extends ReduceError {
 }
 export declare class ReducePreflightError extends ReduceError {
     readonly issues: readonly ReducePreflightIssue[];
-    constructor(issues: readonly ReducePreflightIssue[], hintLines?: readonly string[]);
+    constructor(issues: readonly ReducePreflightIssue[], preProviderIssueCount?: number);
 }
 export declare class ReduceGenerationFailedError extends ReduceError {
     constructor(detailLines?: readonly string[]);