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

package/dist/domain/reduce/competition/output-validation.d.ts

@@ -0,0 +1,4 @@
+export declare const REQUIRED_REDUCTION_SECTION_ORDER: readonly ["Reduction"];
+export declare function validateReductionOutputContract(options: {
+    reductionMarkdown: string;
+}): void;

package/dist/domain/reduce/competition/output-validation.js

@@ -0,0 +1,18 @@
+export const REQUIRED_REDUCTION_SECTION_ORDER = ["Reduction"];
+export function validateReductionOutputContract(options) {
+    const { reductionMarkdown } = options;
+    const normalized = reductionMarkdown.replace(/\r\n/gu, "\n");
+    const trimmed = normalized.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Reduction markdown must not be empty.");
+    }
+    if (!/^## Reduction\s*$/mu.test(normalized)) {
+        throw new Error("Missing required section heading: ## Reduction");
+    }
+    if (!/^\*\*Sources\*\*:\s*.+$/mu.test(normalized)) {
+        throw new Error("Missing required field: **Sources**");
+    }
+    if (!/^\*\*Summary\*\*:\s*.+$/mu.test(normalized)) {
+        throw new Error("Missing required field: **Summary**");
+    }
+}

package/dist/domain/reduce/competition/prompt.d.ts

@@ -0,0 +1,10 @@
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+export interface BuildReducePromptOptions {
+    targetOperator: "spec" | "run" | "reduce" | "verify" | "message";
+    targetId: string;
+    artifactInfoPath: string;
+    repoRootPath: string;
+    workspacePath: string;
+    extraContextFiles?: readonly ResolvedExtraContextFile[];
+}
+export declare function buildReducePrompt(options: BuildReducePromptOptions): string;

package/dist/domain/reduce/competition/prompt.js

@@ -0,0 +1,96 @@
+import { appendExtraContextPromptSection, } from "../../../competition/shared/extra-context.js";
+import { appendConstraints, appendOutputRequirements, buildWorkspaceArtifactRequirements, } from "../../../competition/shared/prompt-helpers.js";
+export function buildReducePrompt(options) {
+    const { targetOperator, targetId, artifactInfoPath, repoRootPath, workspacePath, extraContextFiles = [], } = options;
+    const lines = [
+        "You are the reducer for a completed Voratiq session. Read the available artifacts, synthesize what should be carried forward, and write both a human-readable reduction and a machine-readable reduction artifact.",
+        "",
+        "Inputs:",
+        `- Target operator: ${targetOperator}`,
+        `- Target session id: ${targetId}`,
+        `- Artifact information: \`${artifactInfoPath}\``,
+        "",
+        "Large artifacts and context budget:",
+        "- Do not use subagents.",
+        "- Start from `artifact-information.json` and inspect only the most decision-relevant artifacts.",
+        "- Make claims only when grounded in visible artifacts.",
+        "",
+        "Suggested workflow:",
+        "1) Read `artifact-information.json` first.",
+        "2) Inspect the most relevant staged artifacts one by one.",
+        "3) For each source, identify its strongest useful contributions and its key weaknesses or limitations.",
+        "4) Synthesize only the durable cross-source guidance, risks, and follow-on direction.",
+        "5) Write `reduction.md` and `reduction.json` in the workspace root.",
+        "",
+        "Goal:",
+        "- Produce carry-forward context for a later `spec`, `run`, `reduce`, or `verify` invocation.",
+        "- Focus on synthesis, not ranking or selecting a single best artifact.",
+        "- Optimize for next-step utility, not audit completeness.",
+        "- If something is uncertain, say so explicitly.",
+        "- Prefer the smallest useful reduction that preserves durable guidance.",
+        "",
+        "Output contract (must follow exactly):",
+        "- Produce two artifacts: the full reduction and the machine-readable reduction.",
+        "- The machine-readable artifact must contain only the final synthesized carry-forward result.",
+        "",
+        "## reduction.md",
+        "Write markdown with this shape:",
+        "## Reduction",
+        "**Sources**: <artifact-id>, <artifact-id>",
+        "",
+        "## Source Assessments",
+        "### <artifact-id>",
+        "**Strengths**:",
+        "- <strength>",
+        "- <strength>",
+        "**Weaknesses**:",
+        "- <weakness>",
+        "- <weakness>",
+        "<Repeat one `### <artifact-id>` block for each important source you relied on>",
+        "",
+        "## Synthesis",
+        "**Summary**: <1-3 sentence synthesis>",
+        "**Directives**:",
+        "- <instruction>",
+        "- <instruction>",
+        "**Risks**:",
+        "- <risk>",
+        "- <risk>",
+        "",
+        "## reduction.json",
+        "The machine-readable reduction must match the same synthesis described in `## Synthesis`.",
+        `{"summary":"<summary>","directives":["<directive>"],"risks":["<risk>"]}`,
+        "- `reduction.json` must contain only the final synthesized carry-forward result, not per-source assessments.",
+        "- Keep `summary`, `directives`, and `risks` concise and reusable.",
+        "- Include only the strongest durable guidance; do not restate every source artifact.",
+        "- Prefer 3-6 directives and 2-5 risks unless the evidence is unusually sparse.",
+        "- Merge overlapping findings instead of listing near-duplicates.",
+    ];
+    appendConstraints(lines, {
+        readAccess: repoRootPath,
+        writeAccess: workspacePath,
+    });
+    appendExtraContextPromptSection(lines, extraContextFiles);
+    appendOutputRequirements(lines, buildWorkspaceArtifactRequirements([
+        {
+            instruction: "Save the full reduction",
+            path: "reduction.md",
+        },
+        {
+            instruction: "Save the machine-readable reduction",
+            path: "reduction.json",
+            schema: {
+                leadIn: "with this shape",
+                content: [
+                    '`{"summary":"<summary>","directives":["<directive>"],"risks":["<risk>"]}`',
+                    "- `reduction.json` must contain only the final synthesized carry-forward result, not per-source assessments.",
+                    "- Keep `summary`, `directives`, and `risks` concise and reusable.",
+                    "- Include only the strongest durable guidance; do not restate every source artifact.",
+                    "- Prefer 3-6 directives and 2-5 risks unless the evidence is unusually sparse.",
+                    "- Merge overlapping findings instead of listing near-duplicates.",
+                ],
+            },
+        },
+    ]));
+    return `${lines.join("\n")}\n`;
+}

package/dist/domain/reduce/competition/reduction.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const reductionArtifactSchema: z.ZodObject<{
+    summary: z.ZodString;
+    directives: z.ZodArray<z.ZodString>;
+    risks: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ReductionArtifact = z.infer<typeof reductionArtifactSchema>;
+export declare function parseReductionArtifact(rawReduction: string): ReductionArtifact;
+export declare function readReductionArtifact(reductionPath: string): Promise<ReductionArtifact>;

package/dist/domain/reduce/competition/reduction.js

@@ -0,0 +1,32 @@
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+export const reductionArtifactSchema = z.object({
+    summary: z.string().trim().min(1),
+    directives: z.array(z.string().trim().min(1)).min(1),
+    risks: z.array(z.string().trim().min(1)),
+});
+export function parseReductionArtifact(rawReduction) {
+    let parsed;
+    try {
+        parsed = JSON.parse(rawReduction);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "invalid JSON syntax";
+        throw new Error(`Invalid JSON: ${reason}`);
+    }
+    const validation = reductionArtifactSchema.safeParse(parsed);
+    if (!validation.success) {
+        const detail = validation.error.issues
+            .map((issue) => {
+            const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+            return `${path}: ${issue.message}`;
+        })
+            .join("; ");
+        throw new Error(`Schema validation failed: ${detail}`);
+    }
+    return validation.data;
+}
+export async function readReductionArtifact(reductionPath) {
+    const rawReduction = await readFile(reductionPath, "utf8");
+    return parseReductionArtifact(rawReduction);
+}

package/dist/domain/reduce/model/types.d.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { type ReductionStatus, reductionStatusSchema, TERMINAL_REDUCTION_STATUSES } from "../../../status/index.js";
+export type { ReductionStatus };
+export { reductionStatusSchema, TERMINAL_REDUCTION_STATUSES };
+export declare const reductionTargetTypeSchema: z.ZodEnum<{
+    message: "message";
+    reduce: "reduce";
+    spec: "spec";
+    run: "run";
+    verify: "verify";
+}>;
+export type ReductionTargetType = z.infer<typeof reductionTargetTypeSchema>;
+export declare const reductionTargetSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        spec: "spec";
+        run: "run";
+        verify: "verify";
+    }>;
+    id: z.ZodString;
+}, z.core.$strict>;
+export type ReductionTarget = z.infer<typeof reductionTargetSchema>;
+export declare const reductionRecordReducerSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    outputPath: z.ZodString;
+    dataPath: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cached: z.ZodOptional<z.ZodNumber>;
+        thoughts: z.ZodOptional<z.ZodNumber>;
+        tool: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const reductionRecordSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    target: z.ZodObject<{
+        type: z.ZodEnum<{
+            message: "message";
+            reduce: "reduce";
+            spec: "spec";
+            run: "run";
+            verify: "verify";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    extraContextMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        stagedPath: z.ZodString;
+        sourcePath: z.ZodString;
+    }, z.core.$strip>>>;
+    reducers: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            aborted: "aborted";
+        }>;
+        outputPath: z.ZodString;
+        dataPath: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+            total_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            cached: z.ZodOptional<z.ZodNumber>;
+            thoughts: z.ZodOptional<z.ZodNumber>;
+            tool: z.ZodOptional<z.ZodNumber>;
+            total: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ReductionRecord = z.infer<typeof reductionRecordSchema>;
+export type ReductionIndexEntry = Pick<ReductionRecord, "sessionId" | "createdAt" | "status">;

package/dist/domain/reduce/model/types.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { agentIdSchema } from "../../../configs/agents/types.js";
+import { extractedTokenUsageSchema } from "../../../domain/run/model/types.js";
+import { extraContextMetadataEntrySchema, persistedExtraContextPathSchema, } from "../../../persistence/extra-context.js";
+import { repoRelativeRecordPathSchema } from "../../../persistence/record-path-schema.js";
+import { reductionStatusSchema, TERMINAL_REDUCTION_STATUSES, } from "../../../status/index.js";
+import { validateOperationLifecycleTimestamps, validateRecordLifecycleTimestamps, } from "../../shared/lifecycle.js";
+export { reductionStatusSchema, TERMINAL_REDUCTION_STATUSES };
+export const reductionTargetTypeSchema = z.enum([
+    "spec",
+    "run",
+    "reduce",
+    "verify",
+    "message",
+]);
+export const reductionTargetSchema = z
+    .object({
+    type: reductionTargetTypeSchema,
+    id: z.string(),
+})
+    .strict();
+export const reductionRecordReducerSchema = z
+    .object({
+    agentId: agentIdSchema,
+    status: reductionStatusSchema,
+    outputPath: repoRelativeRecordPathSchema,
+    dataPath: repoRelativeRecordPathSchema.optional(),
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    tokenUsage: extractedTokenUsageSchema.optional(),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((reducer, ctx) => {
+    validateOperationLifecycleTimestamps({
+        status: reducer.status,
+        startedAt: reducer.startedAt,
+        completedAt: reducer.completedAt,
+    }, ctx, {
+        queued: ["queued"],
+        running: ["running"],
+        terminal: TERMINAL_REDUCTION_STATUSES,
+    });
+});
+export const reductionRecordSchema = z
+    .object({
+    sessionId: z.string(),
+    target: reductionTargetSchema,
+    createdAt: z.string(),
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    status: reductionStatusSchema,
+    extraContext: z.array(persistedExtraContextPathSchema).optional(),
+    extraContextMetadata: z.array(extraContextMetadataEntrySchema).optional(),
+    reducers: z
+        .array(reductionRecordReducerSchema)
+        .min(1)
+        .superRefine((reducers, ctx) => {
+        const seen = new Set();
+        for (const reducer of reducers) {
+            if (seen.has(reducer.agentId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `Duplicate reducer agent id: ${reducer.agentId}`,
+                });
+                return;
+            }
+            seen.add(reducer.agentId);
+        }
+    }),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((record, ctx) => {
+    // Enforce the canonical queued/running/terminal timestamp contract.
+    validateRecordLifecycleTimestamps({
+        status: record.status,
+        createdAt: record.createdAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    }, ctx, {
+        queued: ["queued"],
+        running: ["running"],
+        terminal: TERMINAL_REDUCTION_STATUSES,
+    });
+});

package/dist/domain/reduce/persistence/adapter.d.ts

@@ -0,0 +1,43 @@
+import type { ReductionRecord } from "../model/types.js";
+export type ReductionRecordPredicate = (record: ReductionRecord) => boolean;
+export interface ReductionRecordWarningMissing {
+    kind: "missing-record";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+}
+export interface ReductionRecordWarningParse {
+    kind: "parse-error";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+    details: string;
+}
+export type ReductionRecordWarning = ReductionRecordWarningMissing | ReductionRecordWarningParse;
+export interface ReadReductionRecordsOptions {
+    root: string;
+    reductionsFilePath: string;
+    limit?: number;
+    predicate?: ReductionRecordPredicate;
+    onWarning?: (warning: ReductionRecordWarning) => void;
+}
+export interface RewriteReductionRecordOptions {
+    root: string;
+    reductionsFilePath: string;
+    sessionId: string;
+    mutate: (record: ReductionRecord) => ReductionRecord;
+    forceFlush?: boolean;
+}
+export interface AppendReductionRecordOptions {
+    root: string;
+    reductionsFilePath: string;
+    record: ReductionRecord;
+}
+export declare function readReductionRecords(options: ReadReductionRecordsOptions): Promise<ReductionRecord[]>;
+export declare function appendReductionRecord(options: AppendReductionRecordOptions): Promise<void>;
+export declare function rewriteReductionRecord(options: RewriteReductionRecordOptions): Promise<ReductionRecord>;
+export declare function flushReductionRecordBuffer(options: {
+    reductionsFilePath: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function flushAllReductionRecordBuffers(): Promise<void>;

package/dist/domain/reduce/persistence/adapter.js

@@ -0,0 +1,126 @@
+import { dirname, join } from "node:path";
+import { mapSessionStoreError, sessionStoreErrorMapper, } from "../../../persistence/error-mapping.js";
+import { SessionRecordParseError } from "../../../persistence/errors.js";
+import { acquireHistoryLock } from "../../../persistence/history-lock.js";
+import { createSessionStore, } from "../../../persistence/session-store.js";
+import { reductionRecordSchema, TERMINAL_REDUCTION_STATUSES, } from "../model/types.js";
+const REDUCTION_INDEX_VERSION = 1;
+const REDUCTION_RECORD_FILENAME = "record.json";
+const REDUCTION_HISTORY_LOCK_FILENAME = "history.lock";
+const reductionPersistence = createSessionStore({
+    recordFilename: REDUCTION_RECORD_FILENAME,
+    indexVersion: REDUCTION_INDEX_VERSION,
+    acquireLock: acquireHistoryLock,
+    parseRecord: ({ path, raw }) => {
+        const parsed = JSON.parse(raw);
+        const result = reductionRecordSchema.safeParse(parsed);
+        if (!result.success) {
+            const issues = result.error.issues
+                .map((issue) => issue.message)
+                .join(", ");
+            throw new SessionRecordParseError(path, issues);
+        }
+        return result.data;
+    },
+    buildIndexEntry: (record) => ({
+        sessionId: record.sessionId,
+        createdAt: record.createdAt,
+        status: record.status,
+    }),
+    getIndexEntryId: (entry) => entry.sessionId,
+    shouldForceFlush: (record) => TERMINAL_REDUCTION_STATUSES.includes(record.status),
+    getRecordId: (record) => record.sessionId,
+    getRecordStatus: (record) => record.status,
+    readIndexEntries: (parsed) => {
+        const payload = parsed;
+        return Array.isArray(payload.sessions) ? payload.sessions : [];
+    },
+});
+export async function readReductionRecords(options) {
+    const { root, reductionsFilePath, limit, predicate, onWarning } = options;
+    const paths = buildReductionPaths(root, reductionsFilePath);
+    try {
+        return await reductionPersistence.readRecords({
+            paths,
+            limit,
+            predicate,
+            onWarning: onWarning
+                ? (warning) => onWarning(mapWarning(warning))
+                : undefined,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function appendReductionRecord(options) {
+    const { root, reductionsFilePath, record } = options;
+    const paths = buildReductionPaths(root, reductionsFilePath);
+    try {
+        await reductionPersistence.appendRecord({ paths, record });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function rewriteReductionRecord(options) {
+    const { root, reductionsFilePath, sessionId, mutate, forceFlush = false, } = options;
+    const paths = buildReductionPaths(root, reductionsFilePath);
+    try {
+        return await reductionPersistence.rewriteRecord({
+            paths,
+            sessionId,
+            mutate,
+            forceFlush,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushReductionRecordBuffer(options) {
+    const { reductionsFilePath, sessionId } = options;
+    const paths = buildReductionPaths("", reductionsFilePath);
+    try {
+        await reductionPersistence.flushRecordBuffer({ paths, sessionId });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushAllReductionRecordBuffers() {
+    try {
+        await reductionPersistence.flushAllRecordBuffers();
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+function buildReductionPaths(root, reductionsFilePath) {
+    const reductionsRoot = dirname(reductionsFilePath);
+    return {
+        root,
+        indexPath: reductionsFilePath,
+        sessionsDir: join(reductionsRoot, "sessions"),
+        lockPath: join(reductionsRoot, REDUCTION_HISTORY_LOCK_FILENAME),
+    };
+}
+function mapWarning(warning) {
+    if (warning.kind === "parse-error") {
+        const parseWarning = warning;
+        return {
+            kind: "parse-error",
+            sessionId: parseWarning.sessionId,
+            recordPath: parseWarning.recordPath,
+            displayPath: parseWarning.displayPath,
+            details: parseWarning.details,
+        };
+    }
+    const missing = warning;
+    return {
+        kind: "missing-record",
+        sessionId: missing.sessionId,
+        recordPath: missing.recordPath,
+        displayPath: missing.displayPath,
+    };
+}

package/dist/domain/run/competition/adapter.d.ts

@@ -0,0 +1,30 @@
+import type { CompetitionCommandAdapter, CompetitionPreparationResult } from "../../../competition/command-adapter.js";
+import type { ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { PreparedAgentExecution } from "../../../domain/run/competition/agents/types.js";
+import type { AgentExecutionResult } from "../../../domain/run/competition/reports.js";
+import type { AgentRecordMutators } from "../../../domain/run/model/mutators.js";
+export interface CreateRunCompetitionAdapterInput {
+    readonly baseRevisionSha: string;
+    readonly runId: string;
+    readonly root: string;
+    readonly specContent: string;
+    readonly extraContextFiles?: readonly ResolvedExtraContextFile[];
+    readonly mutators: AgentRecordMutators;
+    readonly environment: EnvironmentConfig;
+}
+interface RunCompetitionAdapterDependencies {
+    readonly prepareCandidates: (options: {
+        agents: readonly AgentDefinition[];
+        baseRevisionSha: string;
+        runId: string;
+        root: string;
+        specContent: string;
+        extraContextFiles: readonly ResolvedExtraContextFile[];
+        environment: EnvironmentConfig;
+    }) => Promise<CompetitionPreparationResult<PreparedAgentExecution, AgentExecutionResult>>;
+    readonly executePrepared: (execution: PreparedAgentExecution) => Promise<AgentExecutionResult>;
+}
+export declare function createRunCompetitionAdapter(input: CreateRunCompetitionAdapterInput, dependencies?: Partial<RunCompetitionAdapterDependencies>): CompetitionCommandAdapter<AgentDefinition, PreparedAgentExecution, AgentExecutionResult>;
+export {};

package/dist/domain/run/competition/adapter.js

@@ -0,0 +1,39 @@
+import { prepareAgents } from "../../../domain/run/competition/agent-preparation.js";
+import { runPreparedAgent } from "../../../domain/run/competition/agents/lifecycle.js";
+export function createRunCompetitionAdapter(input, dependencies = {}) {
+    const { baseRevisionSha, runId, root, specContent, extraContextFiles = [], mutators, environment, } = input;
+    const prepareCandidates = dependencies.prepareCandidates ??
+        (async (options) => await prepareAgents(options));
+    const executePrepared = dependencies.executePrepared ??
+        (async (execution) => await runPreparedAgent(execution));
+    return {
+        queueCandidate: async (candidate) => {
+            await mutators.recordAgentQueued(candidate);
+        },
+        prepareCandidates: async (agents) => await prepareCandidates({
+            agents,
+            baseRevisionSha,
+            runId,
+            root,
+            specContent,
+            extraContextFiles,
+            environment,
+        }),
+        onPreparationFailure: async (failure) => {
+            await mutators.recordAgentSnapshot(failure.record);
+        },
+        onCandidatePrepared: (execution) => {
+            execution.progress = {
+                onRunning: mutators.recordAgentSnapshot,
+                onCompleted: async (result) => {
+                    await mutators.recordAgentSnapshot(result.record);
+                },
+            };
+        },
+        executeCandidate: async (execution) => await executePrepared(execution),
+        sortResults: compareExecutionsByAgentId,
+    };
+}
+function compareExecutionsByAgentId(left, right) {
+    return left.record.agentId.localeCompare(right.record.agentId);
+}

package/dist/domain/run/competition/agent-execution.d.ts

@@ -0,0 +1,20 @@
+import type { ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { AgentExecutionPhaseResult } from "../../../domain/run/competition/phases.js";
+import type { AgentRecordMutators } from "../../../domain/run/model/mutators.js";
+export interface AgentExecutionInput {
+    readonly agents: readonly AgentDefinition[];
+    readonly baseRevisionSha: string;
+    readonly runId: string;
+    readonly root: string;
+    readonly specContent: string;
+    readonly extraContextFiles: readonly ResolvedExtraContextFile[];
+    readonly effectiveMaxParallel: number;
+    readonly mutators: AgentRecordMutators;
+    readonly environment: EnvironmentConfig;
+}
+/**
+ * Execute all agents and aggregate results.
+ */
+export declare function executeAgents(input: AgentExecutionInput): Promise<AgentExecutionPhaseResult>;