@proofhound/core 0.1.6

package/dist/server/modules/optimization/optimization.repository.js

@@ -0,0 +1,849 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizationRepository = void 0;
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const pg_core_1 = require("drizzle-orm/pg-core");
+const db_1 = require("@proofhound/db");
+const database_constants_1 = require("../../../shared/database/database.constants");
+const { optimizationRoundSteps, optimizations, datasetSamples, datasets, experiments, models, projects, prompts, promptVersions, runResults, } = db_1.schema;
+const analysisModels = (0, pg_core_1.alias)(models, 'analysis_models');
+const bestVersions = (0, pg_core_1.alias)(promptVersions, 'best_versions');
+const sourceExperimentPromptVersions = (0, pg_core_1.alias)(promptVersions, 'source_experiment_prompt_versions');
+let OptimizationRepository = class OptimizationRepository {
+    constructor(db) {
+        this.db = db;
+        this.selectFields = {
+            id: optimizations.id,
+            projectId: optimizations.projectId,
+            name: optimizations.name,
+            description: optimizations.description,
+            optimizationHint: optimizations.optimizationHint,
+            strategy: optimizations.strategy,
+            strategyConfig: optimizations.strategyConfig,
+            startingMode: optimizations.startingMode,
+            sourceExperimentId: optimizations.sourceExperimentId,
+            sourceExperimentName: experiments.name,
+            sourceExperimentMetrics: experiments.metrics,
+            sourceExperimentPromptVersionId: experiments.promptVersionId,
+            sourceExperimentPromptVersionNumber: sourceExperimentPromptVersions.versionNumber,
+            sourceExperimentStatus: experiments.status,
+            sourceExperimentFailureReason: experiments.failureReason,
+            sourceExperimentStartedAt: experiments.startedAt,
+            sourceExperimentFinishedAt: experiments.finishedAt,
+            sourceExperimentTotalSamples: experiments.totalSamples,
+            sourceExperimentProcessedSamples: experiments.processedSamples,
+            sourceExperimentFailedSamples: experiments.failedSamples,
+            promptId: optimizations.promptId,
+            promptName: prompts.name,
+            baseVersionId: optimizations.baseVersionId,
+            baseVersionNumber: promptVersions.versionNumber,
+            datasetId: optimizations.datasetId,
+            datasetName: datasets.name,
+            datasetSamples: datasets.sampleCount,
+            experimentModelId: optimizations.experimentModelId,
+            experimentModelName: models.name,
+            analysisModelId: optimizations.analysisModelId,
+            analysisModelName: analysisModels.name,
+            promptLanguage: optimizations.promptLanguage,
+            status: optimizations.status,
+            controlState: optimizations.controlState,
+            dbosWorkflowId: optimizations.dbosWorkflowId,
+            goals: optimizations.goals,
+            fieldWhitelist: optimizations.fieldWhitelist,
+            runConfig: optimizations.runConfig,
+            maxRounds: optimizations.maxRounds,
+            currentRound: optimizations.currentRound,
+            bestVersionId: optimizations.bestVersionId,
+            bestVersionNumber: bestVersions.versionNumber,
+            bestMetrics: optimizations.bestMetrics,
+            summary: optimizations.summary,
+            analysisFailureReason: optimizations.analysisFailureReason,
+            createdBy: optimizations.createdBy,
+            createdByDisplayName: (0, drizzle_orm_1.sql) `NULL`,
+            createdByUsername: (0, drizzle_orm_1.sql) `NULL`,
+            startedAt: optimizations.startedAt,
+            finishedAt: optimizations.finishedAt,
+            createdAt: optimizations.createdAt,
+            updatedAt: optimizations.updatedAt,
+            deletedAt: optimizations.deletedAt,
+        };
+    }
+    async findProjectAccess(_actorUserId, projectId, _isSuperAdmin) {
+        const rows = await this.db
+            .select({ id: projects.id })
+            .from(projects)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(projects.id, projectId), (0, drizzle_orm_1.isNull)(projects.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async listOptimizations(projectId) {
+        return this.runSelect((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.projectId, projectId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt))).orderBy((0, drizzle_orm_1.desc)(optimizations.updatedAt), (0, drizzle_orm_1.desc)(optimizations.createdAt));
+    }
+    async findOptimizationById(projectId, optimizationId) {
+        const rows = await this.runSelect((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.projectId, projectId), (0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt))).limit(1);
+        return rows[0] ?? null;
+    }
+    async findOptimizationByProjectAndName(projectId, name) {
+        const rows = await this.db
+            .select({ id: optimizations.id })
+            .from(optimizations)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.projectId, projectId), (0, drizzle_orm_1.eq)(optimizations.name, name), (0, drizzle_orm_1.isNull)(optimizations.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async insertOptimization(values) {
+        const [row] = await this.db
+            .insert(optimizations)
+            .values({
+            projectId: values.projectId,
+            name: values.name,
+            description: values.description,
+            optimizationHint: values.optimizationHint,
+            strategy: values.strategy,
+            strategyConfig: values.strategyConfig,
+            startingMode: values.startingMode,
+            sourceExperimentId: values.sourceExperimentId,
+            promptId: values.promptId,
+            baseVersionId: values.baseVersionId,
+            datasetId: values.datasetId,
+            experimentModelId: values.experimentModelId,
+            analysisModelId: values.analysisModelId,
+            promptLanguage: values.promptLanguage,
+            status: values.status,
+            goals: values.goals,
+            fieldWhitelist: values.fieldWhitelist,
+            runConfig: values.runConfig,
+            maxRounds: values.maxRounds,
+            createdBy: values.createdBy,
+        })
+            .returning({ id: optimizations.id });
+        if (!row)
+            throw new Error('optimization_insert_failed');
+        return row.id;
+    }
+    async updateOptimization(projectId, optimizationId, values) {
+        await this.db
+            .update(optimizations)
+            .set({ ...values, updatedAt: values.updatedAt ?? new Date() })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.eq)(optimizations.projectId, projectId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt)));
+    }
+    async hardDeleteOptimization(projectId, optimizationId) {
+        await this.db.transaction(async (tx) => {
+            await tx
+                .update(experiments)
+                .set({ optimizationId: null, roundIndex: null, updatedAt: new Date() })
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.projectId, projectId), (0, drizzle_orm_1.eq)(experiments.optimizationId, optimizationId)));
+            await tx
+                .delete(optimizations)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.projectId, projectId), (0, drizzle_orm_1.eq)(optimizations.id, optimizationId)));
+        });
+    }
+    /**
+     * from_dataset_only start: before creating the optimization, the service reads the dataset's name to auto-generate the prompt name.
+     * Returns only (id, name); other fields are not needed. Returns null when not found (deleted / cross-project).
+     * See SPEC 25 §2.1.
+     */
+    async findDatasetForOptimization(projectId, datasetId) {
+        const rows = await this.db
+            .select({ id: datasets.id, name: datasets.name })
+            .from(datasets)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(datasets.projectId, projectId), (0, drizzle_orm_1.eq)(datasets.id, datasetId), (0, drizzle_orm_1.isNull)(datasets.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async findActiveExperimentByProjectAndName(projectId, name) {
+        const rows = await this.db
+            .select({ id: experiments.id })
+            .from(experiments)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.projectId, projectId), (0, drizzle_orm_1.eq)(experiments.name, name), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    /**
+     * Called by the workflow after the first version is generated in from_dataset_only mode, writing the generated version id into base_version_id.
+     * Guarded by `WHERE base_version_id IS NULL` so DBOS step replay does not overwrite an existing value.
+     * See SPEC 25 §2.1.
+     */
+    async updateBaseVersionId(optimizationId, baseVersionId) {
+        await this.db
+            .update(optimizations)
+            .set({ baseVersionId, updatedAt: new Date() })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.isNull)(optimizations.baseVersionId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt)));
+    }
+    // ---------- Workflow-side ----------
+    async setDbosWorkflowId(optimizationId, workflowId) {
+        await this.db
+            .update(optimizations)
+            .set({ dbosWorkflowId: workflowId, updatedAt: new Date() })
+            .where((0, drizzle_orm_1.eq)(optimizations.id, optimizationId));
+    }
+    async findActiveRunningWithWorkflow() {
+        const rows = await this.db
+            .select({
+            optimizationId: optimizations.id,
+            projectId: optimizations.projectId,
+            dbosWorkflowId: optimizations.dbosWorkflowId,
+        })
+            .from(optimizations)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.status, 'running'), (0, drizzle_orm_1.isNull)(optimizations.finishedAt), (0, drizzle_orm_1.isNull)(optimizations.deletedAt), (0, drizzle_orm_1.isNotNull)(optimizations.dbosWorkflowId)));
+        return rows.filter((r) => r.dbosWorkflowId !== null);
+    }
+    async markStarted(optimizationId) {
+        // Only populate when startedAt is not yet set, to avoid resume overwriting the original startedAt
+        // started_at uses the DB's now() to avoid drizzle raw sql template skipping column type serialization, which would cause a postgres-js Bind failure
+        await this.db
+            .update(optimizations)
+            .set({
+            status: 'running',
+            startedAt: (0, drizzle_orm_1.sql) `COALESCE(${optimizations.startedAt}, now())`,
+            finishedAt: null,
+            updatedAt: new Date(),
+        })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt)));
+    }
+    async clearResume(optimizationId) {
+        await this.db
+            .update(optimizations)
+            .set({ controlState: null, status: 'running', updatedAt: new Date() })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.eq)(optimizations.controlState, 'resume')));
+    }
+    async readControlState(optimizationId) {
+        const rows = await this.db
+            .select({ controlState: optimizations.controlState })
+            .from(optimizations)
+            .where((0, drizzle_orm_1.eq)(optimizations.id, optimizationId))
+            .limit(1);
+        return rows[0]?.controlState ?? null;
+    }
+    // Used at the top of the workflow main loop + inside poll: fetches status + control_state at once.
+    // Cooperates with service.controlOptimization's preemptive terminal-state write — when the workflow sees status no longer running,
+    // it exits immediately, no more finalize, no more starting child experiments.
+    async findStatusAndControl(optimizationId) {
+        const rows = await this.db
+            .select({ status: optimizations.status, controlState: optimizations.controlState })
+            .from(optimizations)
+            .where((0, drizzle_orm_1.eq)(optimizations.id, optimizationId))
+            .limit(1);
+        const row = rows[0];
+        if (!row)
+            return null;
+        return { status: row.status, controlState: row.controlState };
+    }
+    async updateBest(optimizationId, bestVersionId, bestMetrics) {
+        await this.db
+            .update(optimizations)
+            .set({ bestVersionId, bestMetrics, updatedAt: new Date() })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt)));
+    }
+    async updateCurrentRound(optimizationId, round) {
+        await this.db
+            .update(optimizations)
+            .set({ currentRound: round, updatedAt: new Date() })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt)));
+    }
+    async attachSourceExperimentIfEmpty(optimizationId, experimentId) {
+        await this.db
+            .update(optimizations)
+            .set({ sourceExperimentId: experimentId, updatedAt: new Date() })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.isNull)(optimizations.sourceExperimentId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt)));
+    }
+    async freezePromptVersionIfNeeded(promptVersionId) {
+        await this.db
+            .update(promptVersions)
+            .set({ isFrozen: true, frozenAt: (0, drizzle_orm_1.sql) `COALESCE(${promptVersions.frozenAt}, now())` })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(promptVersions.id, promptVersionId), (0, drizzle_orm_1.eq)(promptVersions.isFrozen, false)));
+    }
+    async createPromptBaselineExperimentRow(input) {
+        const [row] = await this.db
+            .insert(experiments)
+            .values({
+            id: input.id,
+            projectId: input.projectId,
+            name: input.name,
+            promptVersionId: input.promptVersionId,
+            datasetId: input.datasetId,
+            modelId: input.modelId,
+            status: 'running',
+            startedAt: new Date(),
+            runConfig: input.runConfig ?? {},
+            totalSamples: input.totalSamples,
+            createdBy: input.createdBy,
+        })
+            .onConflictDoNothing({ target: experiments.id })
+            .returning({ id: experiments.id });
+        return row?.id ?? input.id;
+    }
+    async setExperimentDbosWorkflowId(experimentId, workflowId) {
+        await this.db
+            .update(experiments)
+            .set({ dbosWorkflowId: workflowId, updatedAt: new Date() })
+            .where((0, drizzle_orm_1.eq)(experiments.id, experimentId));
+    }
+    async findExperimentStatus(experimentId) {
+        const rows = await this.db
+            .select({
+            id: experiments.id,
+            projectId: experiments.projectId,
+            status: experiments.status,
+            controlState: experiments.controlState,
+            metrics: experiments.metrics,
+        })
+            .from(experiments)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.id, experimentId), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    // Idempotency guard: only allow transitioning from status='running' to a terminal state. Returns whether the write actually happened.
+    // After service performs a preemptive terminal write (writing status in one shot on stop/cancel), the workflow's own finalize
+    // is skipped because the WHERE clause does not match — avoiding overwriting the terminal state set by service and avoiding finished_at drift.
+    async finalize(optimizationId, status, options = {}) {
+        const now = new Date();
+        const rows = await this.db
+            .update(optimizations)
+            .set({
+            status,
+            controlState: null,
+            finishedAt: now,
+            updatedAt: now,
+            summary: options.summary ?? (0, drizzle_orm_1.sql) `${optimizations.summary}`,
+            analysisFailureReason: options.analysisFailureReason !== undefined
+                ? options.analysisFailureReason
+                : (0, drizzle_orm_1.sql) `${optimizations.analysisFailureReason}`,
+        })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt), (0, drizzle_orm_1.eq)(optimizations.status, 'running')))
+            .returning({ id: optimizations.id });
+        return rows.length > 0;
+    }
+    async loadWorkflowContext(optimizationId) {
+        const baseVersionAlias = (0, pg_core_1.alias)(promptVersions, 'base_version');
+        const rows = await this.db
+            .select({
+            id: optimizations.id,
+            projectId: optimizations.projectId,
+            name: optimizations.name,
+            description: optimizations.description,
+            optimizationHint: optimizations.optimizationHint,
+            strategy: optimizations.strategy,
+            strategyConfig: optimizations.strategyConfig,
+            startingMode: optimizations.startingMode,
+            sourceExperimentId: optimizations.sourceExperimentId,
+            promptId: optimizations.promptId,
+            baseVersionId: optimizations.baseVersionId,
+            baseVersionBody: baseVersionAlias.body,
+            baseVersionVariables: baseVersionAlias.variables,
+            baseVersionOutputSchema: baseVersionAlias.outputSchema,
+            baseVersionJudgmentRules: baseVersionAlias.judgmentRules,
+            baseVersionPromptLanguage: baseVersionAlias.promptLanguage,
+            baseVersionNumber: baseVersionAlias.versionNumber,
+            datasetId: optimizations.datasetId,
+            datasetSampleCount: datasets.sampleCount,
+            experimentModelId: optimizations.experimentModelId,
+            analysisModelId: optimizations.analysisModelId,
+            promptLanguage: optimizations.promptLanguage,
+            goals: optimizations.goals,
+            fieldWhitelist: optimizations.fieldWhitelist,
+            runConfig: optimizations.runConfig,
+            maxRounds: optimizations.maxRounds,
+            currentRound: optimizations.currentRound,
+            bestVersionId: optimizations.bestVersionId,
+            bestMetrics: optimizations.bestMetrics,
+            status: optimizations.status,
+            controlState: optimizations.controlState,
+            startedAt: optimizations.startedAt,
+            finishedAt: optimizations.finishedAt,
+            createdBy: optimizations.createdBy,
+        })
+            .from(optimizations)
+            .innerJoin(datasets, (0, drizzle_orm_1.eq)(datasets.id, optimizations.datasetId))
+            .leftJoin(baseVersionAlias, (0, drizzle_orm_1.eq)(baseVersionAlias.id, optimizations.baseVersionId))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.isNull)(optimizations.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async findExperimentByRound(optimizationId, roundIndex) {
+        const rows = await this.db
+            .select({
+            id: experiments.id,
+            roundIndex: experiments.roundIndex,
+            status: experiments.status,
+            metrics: experiments.metrics,
+            promptVersionId: experiments.promptVersionId,
+            parentVersionId: promptVersions.parentVersionId,
+            failureReason: experiments.failureReason,
+            finishedAt: experiments.finishedAt,
+        })
+            .from(experiments)
+            .leftJoin(promptVersions, (0, drizzle_orm_1.eq)(promptVersions.id, experiments.promptVersionId))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.optimizationId, optimizationId), (0, drizzle_orm_1.eq)(experiments.roundIndex, roundIndex), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+            .limit(1);
+        const row = rows[0];
+        if (!row || row.roundIndex === null)
+            return null;
+        return { ...row, roundIndex: row.roundIndex };
+    }
+    async findAnalysisExperimentForPromptVersion(input) {
+        if (input.sourceExperimentId) {
+            const sourceRows = await this.db
+                .select({
+                id: experiments.id,
+                roundIndex: experiments.roundIndex,
+                metrics: experiments.metrics,
+                promptVersionId: experiments.promptVersionId,
+            })
+                .from(experiments)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.id, input.sourceExperimentId), (0, drizzle_orm_1.eq)(experiments.promptVersionId, input.promptVersionId), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+                .limit(1);
+            if (sourceRows[0]) {
+                return { ...sourceRows[0], roundIndex: null };
+            }
+        }
+        const childRows = await this.db
+            .select({
+            id: experiments.id,
+            roundIndex: experiments.roundIndex,
+            metrics: experiments.metrics,
+            promptVersionId: experiments.promptVersionId,
+        })
+            .from(experiments)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.optimizationId, input.optimizationId), (0, drizzle_orm_1.eq)(experiments.promptVersionId, input.promptVersionId), (0, drizzle_orm_1.isNotNull)(experiments.roundIndex), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+            .orderBy((0, drizzle_orm_1.desc)(experiments.roundIndex), (0, drizzle_orm_1.desc)(experiments.createdAt))
+            .limit(1);
+        const child = childRows[0];
+        if (!child || child.roundIndex === null)
+            return null;
+        return child;
+    }
+    async findPreviousComparableExperiment(input) {
+        if (input.currentRoundIndex === null)
+            return null;
+        if (input.currentRoundIndex <= 1) {
+            if (!input.sourceExperimentId)
+                return null;
+            const rows = await this.db
+                .select({
+                id: experiments.id,
+                roundIndex: experiments.roundIndex,
+                metrics: experiments.metrics,
+                promptVersionId: experiments.promptVersionId,
+            })
+                .from(experiments)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.id, input.sourceExperimentId), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+                .limit(1);
+            return rows[0] ? { ...rows[0], roundIndex: null } : null;
+        }
+        const prev = await this.findExperimentByRound(input.optimizationId, input.currentRoundIndex - 1);
+        if (!prev)
+            return null;
+        return {
+            id: prev.id,
+            roundIndex: input.currentRoundIndex - 1,
+            metrics: prev.metrics,
+            promptVersionId: prev.promptVersionId,
+        };
+    }
+    async createChildExperimentRow(input) {
+        const [row] = await this.db
+            .insert(experiments)
+            .values({
+            id: input.id,
+            projectId: input.projectId,
+            name: input.name,
+            promptVersionId: input.promptVersionId,
+            datasetId: input.datasetId,
+            modelId: input.modelId,
+            optimizationId: input.optimizationId,
+            roundIndex: input.roundIndex,
+            status: 'running',
+            startedAt: new Date(),
+            runConfig: input.runConfig ?? {},
+            totalSamples: input.totalSamples,
+            createdBy: input.createdBy,
+        })
+            .onConflictDoNothing({ target: experiments.id })
+            .returning({ id: experiments.id });
+        return row?.id ?? input.id;
+    }
+    async markChildExperimentFailed(experimentId, failureReason) {
+        const now = new Date();
+        await this.db
+            .update(experiments)
+            .set({
+            status: 'failed',
+            failureKind: 'internal',
+            failureReason,
+            finishedAt: now,
+            updatedAt: now,
+        })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.id, experimentId), (0, drizzle_orm_1.isNull)(experiments.deletedAt)));
+    }
+    async findExistingOptimizationRunResult(optimizationId, roundIndex, source, options = {}) {
+        const conditions = [
+            (0, drizzle_orm_1.eq)(runResults.sourceId, optimizationId),
+            (0, drizzle_orm_1.eq)(runResults.source, source),
+            (0, drizzle_orm_1.eq)(runResults.roundIndex, roundIndex),
+        ];
+        if (options.statusFilter)
+            conditions.push((0, drizzle_orm_1.eq)(runResults.status, options.statusFilter));
+        const rows = await this.db
+            .select({
+            id: runResults.id,
+            parsedOutput: runResults.parsedOutput,
+            rawResponse: runResults.rawResponse,
+            status: runResults.status,
+        })
+            .from(runResults)
+            .where((0, drizzle_orm_1.and)(...conditions))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    // Look up the child experiment that is still running (or stopped but not terminal) within the current optimization (the row with the largest round_index).
+    // Use case: service.controlOptimization locates the target when immediately propagating stop/cancel to the child experiment.
+    // The baseline experiment in from_prompt_version has no optimization_id + round_index back-pointer,
+    // but source_experiment_id points to it; if a regular round is not present, fall back to locating this baseline experiment.
+    // Exclude terminal states (success/failed/cancelled); only return running/stopped that genuinely need linkage.
+    async findActiveChildExperiment(optimizationId) {
+        const rows = await this.db
+            .select({
+            id: experiments.id,
+            status: experiments.status,
+            roundIndex: experiments.roundIndex,
+            projectId: experiments.projectId,
+        })
+            .from(experiments)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.optimizationId, optimizationId), (0, drizzle_orm_1.isNotNull)(experiments.roundIndex), (0, drizzle_orm_1.isNull)(experiments.deletedAt), (0, drizzle_orm_1.sql) `${experiments.status} NOT IN ('success','failed','cancelled')`))
+            .orderBy((0, drizzle_orm_1.desc)(experiments.roundIndex))
+            .limit(1);
+        const row = rows[0];
+        if (row && row.roundIndex !== null) {
+            return { id: row.id, status: row.status, roundIndex: row.roundIndex, projectId: row.projectId };
+        }
+        const baselineRows = await this.db
+            .select({
+            id: experiments.id,
+            status: experiments.status,
+            roundIndex: experiments.roundIndex,
+            projectId: experiments.projectId,
+        })
+            .from(optimizations)
+            .innerJoin(experiments, (0, drizzle_orm_1.eq)(experiments.id, optimizations.sourceExperimentId))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.eq)(optimizations.startingMode, 'from_prompt_version'), (0, drizzle_orm_1.isNull)(optimizations.deletedAt), (0, drizzle_orm_1.isNull)(experiments.deletedAt), (0, drizzle_orm_1.sql) `${experiments.status} NOT IN ('success','failed','cancelled')`))
+            .limit(1);
+        const baseline = baselineRows[0];
+        if (!baseline)
+            return null;
+        return {
+            id: baseline.id,
+            status: baseline.status,
+            roundIndex: baseline.roundIndex,
+            projectId: baseline.projectId,
+        };
+    }
+    async loadDatasetSamples(datasetId) {
+        const rows = await this.db
+            .select({ id: datasetSamples.id, data: datasetSamples.data })
+            .from(datasetSamples)
+            .where((0, drizzle_orm_1.eq)(datasetSamples.datasetId, datasetId))
+            .orderBy((0, drizzle_orm_1.asc)(datasetSamples.createdAt), (0, drizzle_orm_1.asc)(datasetSamples.id));
+        return rows.map((r) => ({
+            id: r.id,
+            data: (r.data ?? {}),
+        }));
+    }
+    async findPreviousRoundRunResults(input) {
+        if (input.currentRoundNumber <= 1) {
+            // Round 1: return the source experiment's run_results; if there is no source experiment, return null
+            if (!input.sourceExperimentId)
+                return null;
+            return this.loadRunResultsByExperiment(input.sourceExperimentId);
+        }
+        // Round N≥2: the N-1 round experiment
+        const prev = await this.findExperimentByRound(input.optimizationId, input.currentRoundNumber - 1);
+        if (!prev)
+            return null;
+        return this.loadRunResultsByExperiment(prev.id);
+    }
+    async loadRunResultsByExperiment(experimentId) {
+        const rows = await this.db
+            .select({
+            id: runResults.id,
+            sampleId: runResults.sampleId,
+            parsedOutput: runResults.parsedOutput,
+            decisionOutput: runResults.decisionOutput,
+            isCorrect: runResults.isCorrect,
+            errorMessage: runResults.errorMessage,
+            rawResponse: runResults.rawResponse,
+        })
+            .from(runResults)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(runResults.source, 'experiment'), (0, drizzle_orm_1.eq)(runResults.sourceId, experimentId)));
+        return rows;
+    }
+    async listRoundExperimentsForOptimization(optimizationId) {
+        const rows = await this.db
+            .select({
+            experimentId: experiments.id,
+            experimentName: experiments.name,
+            roundIndex: experiments.roundIndex,
+            promptVersionId: experiments.promptVersionId,
+            promptVersionNumber: promptVersions.versionNumber,
+            parentVersionId: promptVersions.parentVersionId,
+            status: experiments.status,
+            metrics: experiments.metrics,
+            failureReason: experiments.failureReason,
+            startedAt: experiments.startedAt,
+            finishedAt: experiments.finishedAt,
+            totalSamples: experiments.totalSamples,
+            processedSamples: experiments.processedSamples,
+            failedSamples: experiments.failedSamples,
+            updatedAt: experiments.updatedAt,
+        })
+            .from(experiments)
+            .leftJoin(promptVersions, (0, drizzle_orm_1.eq)(promptVersions.id, experiments.promptVersionId))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.optimizationId, optimizationId), (0, drizzle_orm_1.isNotNull)(experiments.roundIndex), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+            .orderBy((0, drizzle_orm_1.asc)(experiments.roundIndex));
+        const childRounds = rows
+            .filter((r) => r.roundIndex !== null)
+            .map((r) => ({ ...r, roundIndex: r.roundIndex }));
+        const [sourceBaseline] = await this.db
+            .select({
+            experimentId: experiments.id,
+            experimentName: experiments.name,
+            promptVersionId: experiments.promptVersionId,
+            promptVersionNumber: promptVersions.versionNumber,
+            parentVersionId: promptVersions.parentVersionId,
+            status: experiments.status,
+            metrics: experiments.metrics,
+            failureReason: experiments.failureReason,
+            startedAt: experiments.startedAt,
+            finishedAt: experiments.finishedAt,
+            totalSamples: experiments.totalSamples,
+            processedSamples: experiments.processedSamples,
+            failedSamples: experiments.failedSamples,
+            updatedAt: experiments.updatedAt,
+        })
+            .from(optimizations)
+            .innerJoin(experiments, (0, drizzle_orm_1.eq)(experiments.id, optimizations.sourceExperimentId))
+            .leftJoin(promptVersions, (0, drizzle_orm_1.eq)(promptVersions.id, experiments.promptVersionId))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(optimizations.id, optimizationId), (0, drizzle_orm_1.eq)(optimizations.startingMode, 'from_dataset_only'), (0, drizzle_orm_1.isNull)(optimizations.deletedAt), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+            .limit(1);
+        if (!sourceBaseline || childRounds.some((r) => r.roundIndex === 0)) {
+            return childRounds;
+        }
+        return [
+            {
+                ...sourceBaseline,
+                roundIndex: 0,
+                isBaseline: true,
+            },
+            ...childRounds,
+        ].sort((a, b) => a.roundIndex - b.roundIndex);
+    }
+    async loadPromptVersionsByIds(versionIds) {
+        const result = new Map();
+        const unique = Array.from(new Set(versionIds.filter((id) => Boolean(id))));
+        if (unique.length === 0)
+            return result;
+        const rows = await this.db
+            .select({
+            id: promptVersions.id,
+            body: promptVersions.body,
+            versionNumber: promptVersions.versionNumber,
+            outputSchema: promptVersions.outputSchema,
+            promptLanguage: promptVersions.promptLanguage,
+        })
+            .from(promptVersions)
+            .where((0, drizzle_orm_1.inArray)(promptVersions.id, unique));
+        for (const row of rows) {
+            result.set(row.id, {
+                body: row.body,
+                versionNumber: row.versionNumber,
+                outputSchema: row.outputSchema,
+                promptLanguage: row.promptLanguage,
+            });
+        }
+        return result;
+    }
+    // Picks the baseline version for from_prompt_version optimization (SPEC 25 §2).
+    // Prefer prompts.current_online_version_id; otherwise take the version of this prompt with the largest versionNumber.
+    async findActiveVersionIdForPrompt(promptId) {
+        const [promptRow] = await this.db
+            .select({ currentOnlineVersionId: prompts.currentOnlineVersionId })
+            .from(prompts)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(prompts.id, promptId), (0, drizzle_orm_1.isNull)(prompts.deletedAt)))
+            .limit(1);
+        if (!promptRow)
+            return null;
+        if (promptRow.currentOnlineVersionId)
+            return promptRow.currentOnlineVersionId;
+        const [latestVersion] = await this.db
+            .select({ id: promptVersions.id })
+            .from(promptVersions)
+            .where((0, drizzle_orm_1.eq)(promptVersions.promptId, promptId))
+            .orderBy((0, drizzle_orm_1.desc)(promptVersions.versionNumber))
+            .limit(1);
+        return latestVersion?.id ?? null;
+    }
+    async findPromptVersionLanguage(versionId) {
+        const [row] = await this.db
+            .select({ promptLanguage: promptVersions.promptLanguage })
+            .from(promptVersions)
+            .where((0, drizzle_orm_1.eq)(promptVersions.id, versionId))
+            .limit(1);
+        return row?.promptLanguage ?? null;
+    }
+    async listOptimizationLlmRunResults(optimizationId) {
+        const rows = await this.db
+            .select({
+            runResultId: runResults.id,
+            roundIndex: runResults.roundIndex,
+            source: runResults.source,
+            promptVersionId: runResults.promptVersionId,
+            parsedOutput: runResults.parsedOutput,
+            rawResponse: runResults.rawResponse,
+            errorMessage: runResults.errorMessage,
+            status: runResults.status,
+            inputTokens: runResults.inputTokens,
+            outputTokens: runResults.outputTokens,
+            costEstimate: runResults.costEstimate,
+            createdAt: runResults.createdAt,
+        })
+            .from(runResults)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(runResults.sourceId, optimizationId), (0, drizzle_orm_1.inArray)(runResults.source, ['optimization_analysis', 'optimization_generate']), (0, drizzle_orm_1.isNotNull)(runResults.roundIndex)));
+        return rows
+            .filter((r) => r.roundIndex !== null)
+            .map((r) => ({ ...r, roundIndex: r.roundIndex }));
+    }
+    // Cross-round history aggregation (SPEC 25 §11.3) — returns the completed rounds where round_index < beforeRoundIndex,
+    // each row carrying this round's metrics / parentVersionId (from prompt_versions) / parsedOutput of optimization_generate /
+    // is_best (anchored on optimizations.best_version_id). This method is read-only and can be wrapped by @DBOS.step.
+    async loadRoundHistory(optimizationId, beforeRoundIndex) {
+        const rows = await this.db
+            .select({
+            roundIndex: experiments.roundIndex,
+            metrics: experiments.metrics,
+            promptVersionId: experiments.promptVersionId,
+            parentVersionId: promptVersions.parentVersionId,
+            generateParsedOutput: runResults.parsedOutput,
+            bestVersionId: optimizations.bestVersionId,
+        })
+            .from(experiments)
+            .leftJoin(promptVersions, (0, drizzle_orm_1.eq)(promptVersions.id, experiments.promptVersionId))
+            .leftJoin(runResults, (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(runResults.sourceId, experiments.optimizationId), (0, drizzle_orm_1.eq)(runResults.roundIndex, experiments.roundIndex), (0, drizzle_orm_1.eq)(runResults.source, 'optimization_generate'), (0, drizzle_orm_1.eq)(runResults.status, 'success')))
+            .leftJoin(optimizations, (0, drizzle_orm_1.eq)(optimizations.id, experiments.optimizationId))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(experiments.optimizationId, optimizationId), (0, drizzle_orm_1.isNotNull)(experiments.roundIndex), (0, drizzle_orm_1.sql) `${experiments.roundIndex} < ${beforeRoundIndex}`, (0, drizzle_orm_1.eq)(experiments.status, 'success'), (0, drizzle_orm_1.isNull)(experiments.deletedAt)))
+            .orderBy((0, drizzle_orm_1.asc)(experiments.roundIndex));
+        return rows
+            .filter((r) => r.roundIndex !== null)
+            .map((r) => ({
+            roundIndex: r.roundIndex,
+            metrics: r.metrics,
+            promptVersionId: r.promptVersionId,
+            parentVersionId: r.parentVersionId ?? null,
+            generateParsedOutput: r.generateParsedOutput ?? null,
+            isBest: r.bestVersionId !== null && r.bestVersionId === r.promptVersionId,
+        }));
+    }
+    // Upsert idempotency core: at most one row per (optimizationId, roundIndex, step); DBOS step
+    // retries that call multiple times do not duplicate rows. Fields not explicitly provided fall back via COALESCE(EXCLUDED.x, x),
+    // preventing previously written finishedAt / runResultId / experimentId from being overwritten with null.
+    async upsertRoundStep(input) {
+        await this.db
+            .insert(optimizationRoundSteps)
+            .values({
+            optimizationId: input.optimizationId,
+            roundIndex: input.roundIndex,
+            step: input.step,
+            status: input.status,
+            errorClass: input.errorClass ?? null,
+            errorMessage: input.errorMessage ?? null,
+            runResultId: input.runResultId ?? null,
+            experimentId: input.experimentId ?? null,
+            startedAt: input.startedAt ?? null,
+            finishedAt: input.finishedAt ?? null,
+            attempt: input.attempt ?? 0,
+            dbosWorkflowId: input.dbosWorkflowId ?? null,
+        })
+            .onConflictDoUpdate({
+            target: [optimizationRoundSteps.optimizationId, optimizationRoundSteps.roundIndex, optimizationRoundSteps.step],
+            set: {
+                status: (0, drizzle_orm_1.sql) `EXCLUDED.status`,
+                // Partial-update fallback: only override when this call explicitly provides the field; otherwise keep the old value.
+                errorClass: input.errorClass !== undefined ? (0, drizzle_orm_1.sql) `EXCLUDED.error_class` : (0, drizzle_orm_1.sql) `${optimizationRoundSteps.errorClass}`,
+                errorMessage: input.errorMessage !== undefined
+                    ? (0, drizzle_orm_1.sql) `EXCLUDED.error_message`
+                    : (0, drizzle_orm_1.sql) `${optimizationRoundSteps.errorMessage}`,
+                runResultId: input.runResultId !== undefined ? (0, drizzle_orm_1.sql) `EXCLUDED.run_result_id` : (0, drizzle_orm_1.sql) `${optimizationRoundSteps.runResultId}`,
+                experimentId: input.experimentId !== undefined
+                    ? (0, drizzle_orm_1.sql) `EXCLUDED.experiment_id`
+                    : (0, drizzle_orm_1.sql) `${optimizationRoundSteps.experimentId}`,
+                startedAt: input.startedAt !== undefined ? (0, drizzle_orm_1.sql) `EXCLUDED.started_at` : (0, drizzle_orm_1.sql) `${optimizationRoundSteps.startedAt}`,
+                finishedAt: input.finishedAt !== undefined ? (0, drizzle_orm_1.sql) `EXCLUDED.finished_at` : (0, drizzle_orm_1.sql) `${optimizationRoundSteps.finishedAt}`,
+                attempt: input.attempt !== undefined ? (0, drizzle_orm_1.sql) `EXCLUDED.attempt` : (0, drizzle_orm_1.sql) `${optimizationRoundSteps.attempt}`,
+                dbosWorkflowId: input.dbosWorkflowId !== undefined
+                    ? (0, drizzle_orm_1.sql) `EXCLUDED.dbos_workflow_id`
+                    : (0, drizzle_orm_1.sql) `${optimizationRoundSteps.dbosWorkflowId}`,
+                updatedAt: new Date(),
+            },
+        });
+    }
+    async listRoundStepsForOptimization(optimizationId) {
+        const rows = await this.db
+            .select({
+            optimizationId: optimizationRoundSteps.optimizationId,
+            roundIndex: optimizationRoundSteps.roundIndex,
+            step: optimizationRoundSteps.step,
+            status: optimizationRoundSteps.status,
+            errorClass: optimizationRoundSteps.errorClass,
+            errorMessage: optimizationRoundSteps.errorMessage,
+            runResultId: optimizationRoundSteps.runResultId,
+            experimentId: optimizationRoundSteps.experimentId,
+            startedAt: optimizationRoundSteps.startedAt,
+            finishedAt: optimizationRoundSteps.finishedAt,
+            attempt: optimizationRoundSteps.attempt,
+            dbosWorkflowId: optimizationRoundSteps.dbosWorkflowId,
+            createdAt: optimizationRoundSteps.createdAt,
+            updatedAt: optimizationRoundSteps.updatedAt,
+        })
+            .from(optimizationRoundSteps)
+            .where((0, drizzle_orm_1.eq)(optimizationRoundSteps.optimizationId, optimizationId))
+            .orderBy((0, drizzle_orm_1.asc)(optimizationRoundSteps.roundIndex), (0, drizzle_orm_1.asc)(optimizationRoundSteps.step));
+        return rows.map((r) => ({
+            ...r,
+            step: r.step,
+            status: r.status,
+        }));
+    }
+    runSelect(predicate) {
+        return this.db
+            .select(this.selectFields)
+            .from(optimizations)
+            .innerJoin(datasets, (0, drizzle_orm_1.eq)(datasets.id, optimizations.datasetId))
+            .innerJoin(models, (0, drizzle_orm_1.eq)(models.id, optimizations.experimentModelId))
+            .innerJoin(analysisModels, (0, drizzle_orm_1.eq)(analysisModels.id, optimizations.analysisModelId))
+            .leftJoin(experiments, (0, drizzle_orm_1.eq)(experiments.id, optimizations.sourceExperimentId))
+            .leftJoin(sourceExperimentPromptVersions, (0, drizzle_orm_1.eq)(sourceExperimentPromptVersions.id, experiments.promptVersionId))
+            .leftJoin(prompts, (0, drizzle_orm_1.eq)(prompts.id, optimizations.promptId))
+            .leftJoin(promptVersions, (0, drizzle_orm_1.eq)(promptVersions.id, optimizations.baseVersionId))
+            .leftJoin(bestVersions, (0, drizzle_orm_1.eq)(bestVersions.id, optimizations.bestVersionId))
+            .where(predicate);
+    }
+};
+exports.OptimizationRepository = OptimizationRepository;
+exports.OptimizationRepository = OptimizationRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(database_constants_1.DATABASE_CLIENT)),
+    __metadata("design:paramtypes", [Object])
+], OptimizationRepository);
+//# sourceMappingURL=optimization.repository.js.map