@proofhound/core 0.1.6

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

@@ -0,0 +1,1753 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizationService = void 0;
+exports.collectPromptVersionIds = collectPromptVersionIds;
+const common_1 = require("@nestjs/common");
+const shared_1 = require("@proofhound/shared");
+const logger_1 = require("@proofhound/logger");
+const access_control_1 = require("../../common/access-control");
+const access_control_service_1 = require("../../common/contracts/access-control.service");
+const workflow_authorization_hook_1 = require("../../common/contracts/workflow-authorization.hook");
+const db_error_1 = require("../../common/errors/db-error");
+const experiment_aggregator_1 = require("../experiment/experiment.aggregator");
+const experiment_repository_1 = require("../experiment/experiment.repository");
+const experiment_service_1 = require("../experiment/experiment.service");
+const prompt_repository_1 = require("../prompt/prompt.repository");
+const run_result_service_1 = require("../run-result/run-result.service");
+const optimization_launcher_1 = require("./optimization.launcher");
+const optimization_workflow_1 = require("./optimization.workflow");
+const optimization_repository_1 = require("./optimization.repository");
+// Logger used internally by the detail-page aggregation helper; a separate binding makes it zero-cost in production after debug is disabled,
+// from the same source as this.logger in the class (both are pino instances).
+const detailHelperLogger = (0, logger_1.createLogger)('optimization.service.detail', { service: 'server' });
+let OptimizationService = class OptimizationService {
+    constructor(repo, launcher, experimentRepo, experimentService, runResults, promptRepo, accessControl, workflowAuth) {
+        this.repo = repo;
+        this.launcher = launcher;
+        this.experimentRepo = experimentRepo;
+        this.experimentService = experimentService;
+        this.runResults = runResults;
+        this.promptRepo = promptRepo;
+        this.accessControl = accessControl;
+        this.workflowAuth = workflowAuth;
+        this.logger = (0, logger_1.createLogger)('optimization.service', { service: 'server' });
+    }
+    async listOptimizations(projectId, actor, query = {}) {
+        await this.getAccessibleProject(projectId, actor);
+        const allRows = await this.repo.listOptimizations(projectId);
+        // On demand, load round experiments + round_steps per optimization:
+        // - experiments populate trend (LiveCard sparkline)
+        // - round_steps allow the list to show the latest round and update time even during analysis/generation/child-experiment startup
+        const allItems = [];
+        for (const row of allRows) {
+            const [rounds, roundSteps] = await Promise.all([
+                this.repo.listRoundExperimentsForOptimization(row.id),
+                this.repo.listRoundStepsForOptimization(row.id),
+            ]);
+            const liveRounds = await this.withLiveRoundMetrics(rounds);
+            const liveProjection = deriveLiveProjection(row, liveRounds, roundSteps);
+            const { values: trend, hasBaseline } = this.deriveListTrend(row, liveRounds);
+            allItems.push(this.toListItem(row, {
+                trend,
+                trendHasBaseline: hasBaseline,
+                currentRound: liveProjection.currentRound,
+                updatedAt: liveProjection.updatedAt,
+            }));
+        }
+        const filtered = this.filterItems(allItems, query);
+        const data = this.sortItems(filtered, query.sort);
+        return { data, total: data.length };
+    }
+    async getOptimization(projectId, optimizationId, actor) {
+        await this.getAccessibleProject(projectId, actor);
+        const row = await this.repo.findOptimizationById(projectId, optimizationId);
+        if (!row) {
+            throw new common_1.NotFoundException(`Optimization ${optimizationId} not found`);
+        }
+        // Fetch concurrently: experiments + LLM run_results + round_steps, then merge and feed into toDetail.
+        const [rounds, llmRows, roundSteps] = await Promise.all([
+            this.repo.listRoundExperimentsForOptimization(optimizationId),
+            this.repo.listOptimizationLlmRunResults(optimizationId),
+            this.repo.listRoundStepsForOptimization(optimizationId),
+        ]);
+        // For running rounds, add a layer of live aggregate between batch aggregation steps (mirroring ExperimentService.withLiveMetrics),
+        // so that the detail page's 5-second refresh of the progress bar / quality metrics advances with run_results in real time, rather than being stuck on the last batch-written snapshot.
+        const liveRounds = await this.withLiveRoundMetrics(rounds);
+        const versionIds = collectPromptVersionIds(row, liveRounds, llmRows);
+        const promptBodyMap = await this.repo.loadPromptVersionsByIds(versionIds);
+        return this.toDetail(row, { rounds: liveRounds, llmRows, roundSteps, promptBodyMap });
+    }
+    // Isomorphic to ExperimentService.withLiveMetrics: only triggered for running rounds; aggregates from ph_runs.run_results in real time
+    // to override processedSamples / failedSamples / metrics, so deriveTrendSeries / deriveRoundDetails /
+    // buildExperimentResult / goalChips all move along. Empty aggregate (no terminal row yet in run_results) → keep the snapshot,
+    // to avoid regressing progress to 0/null. Terminal rounds are untouched and continue to read the snapshot, to avoid a GROUP BY on every GET.
+    async withLiveRoundMetrics(rounds) {
+        if (rounds.length === 0)
+            return rounds;
+        return Promise.all(rounds.map(async (round) => {
+            if (round.status !== 'running' || !round.experimentId)
+                return round;
+            const [aggRows, latency] = await Promise.all([
+                this.runResults.aggregateExperiment(round.experimentId),
+                this.runResults.aggregateExperimentLatency(round.experimentId),
+            ]);
+            const live = (0, experiment_aggregator_1.aggregateExperimentMetrics)(aggRows, latency);
+            // Empty aggregate (no terminal row yet in run_results) → keep the experiments snapshot to avoid regressing progress to 0/null
+            if (live.totalCount === 0)
+                return round;
+            return {
+                ...round,
+                processedSamples: live.totalCount,
+                failedSamples: live.failedCount,
+                metrics: live.metrics,
+            };
+        }));
+    }
+    async createOptimization(projectId, body, actor, source = 'api', 
+    // orgId (SaaS-only; undefined in OSS) is sourced from the resolved ProjectContext — the project's org is the
+    // rate-limit bucket (SPEC 08 §3.7). Threaded into launcher.launch → runWorkflow → snapshot.orgId so the worker
+    // composes an org-scoped limiter key; child-experiment launches inside the workflow inherit it from the snapshot.
+    orgId) {
+        await this.getWritableProject(projectId, actor);
+        const existing = await this.repo.findOptimizationByProjectAndName(projectId, body.name);
+        if (existing) {
+            throw new common_1.ConflictException('optimization_name_taken');
+        }
+        let resolvedPromptId = body.promptId ?? null;
+        let resolvedBaseVersionId = body.baseVersionId ?? null;
+        const requestedPromptLanguage = body.promptLanguage ?? shared_1.DEFAULT_PROMPT_LANGUAGE;
+        let workflowStartAuthorized = false;
+        const assertWorkflowStart = async () => {
+            if (workflowStartAuthorized)
+                return;
+            await this.workflowAuth.assertCanStart((0, access_control_1.toActorContext)(actor), { projectId, orgId, source: 'local' }, 'optimization');
+            workflowStartAuthorized = true;
+        };
+        if (body.startingMode === 'from_experiment' &&
+            body.sourceExperimentId &&
+            (!resolvedPromptId || !resolvedBaseVersionId)) {
+            const sourceExperiment = await this.experimentRepo.findExperimentById(projectId, body.sourceExperimentId);
+            if (!sourceExperiment) {
+                throw new common_1.BadRequestException(`Source experiment ${body.sourceExperimentId} not found`);
+            }
+            resolvedBaseVersionId ??= sourceExperiment.promptVersionId;
+            resolvedPromptId ??= sourceExperiment.promptId;
+        }
+        // SPEC 25 §2: the baseline version for the from_prompt_version start is auto-selected by the system
+        //   Prefer prompts.current_online_version_id; otherwise take the latest version number of this prompt.
+        if (body.startingMode === 'from_prompt_version' && resolvedPromptId && !resolvedBaseVersionId) {
+            resolvedBaseVersionId = await this.repo.findActiveVersionIdForPrompt(resolvedPromptId);
+            if (!resolvedBaseVersionId) {
+                throw new common_1.BadRequestException(`Prompt ${resolvedPromptId} has no usable version for optimization`);
+            }
+        }
+        // SPEC 25 §2.1: for from_dataset_only start, auto-create an empty prompt as the carrier entity;
+        // baseVersionId stays null until workflow.generateFirstVersionStep backfills it.
+        if (body.startingMode === 'from_dataset_only' && !resolvedPromptId) {
+            if (!body.analysisModelId) {
+                throw new common_1.BadRequestException('analysis_model_required_for_dataset_only_starting_mode');
+            }
+            if (resolvedBaseVersionId) {
+                throw new common_1.BadRequestException('base_version_must_be_unset_for_dataset_only_starting_mode');
+            }
+            const dataset = await this.repo.findDatasetForOptimization(projectId, body.datasetId);
+            if (!dataset) {
+                throw new common_1.BadRequestException(`Dataset ${body.datasetId} not found`);
+            }
+            await assertWorkflowStart();
+            resolvedPromptId = await this.createPlaceholderPromptWithRetry({
+                projectId,
+                datasetName: dataset.name,
+                optimizationName: body.name,
+                datasetId: body.datasetId,
+                promptLanguage: requestedPromptLanguage,
+                createdBy: actor.sub,
+            });
+        }
+        const resolvedPromptLanguage = await this.resolvePromptLanguage(body.promptLanguage, resolvedBaseVersionId);
+        await assertWorkflowStart();
+        const insertedId = await this.insertOptimizationOrThrowNameConflict({
+            projectId,
+            name: body.name,
+            description: body.description ?? null,
+            optimizationHint: normalizeOptimizationHint(body.optimizationHint),
+            strategy: body.strategy,
+            strategyConfig: body.strategyConfig ?? {},
+            startingMode: body.startingMode,
+            sourceExperimentId: body.sourceExperimentId ?? null,
+            promptId: resolvedPromptId,
+            baseVersionId: resolvedBaseVersionId,
+            datasetId: body.datasetId,
+            experimentModelId: body.experimentModelId,
+            analysisModelId: body.analysisModelId,
+            promptLanguage: resolvedPromptLanguage,
+            status: 'running',
+            goals: body.goals,
+            fieldWhitelist: body.fieldWhitelist ?? null,
+            runConfig: body.runConfig ?? {},
+            maxRounds: body.loopLimits.maxRounds,
+            createdBy: actor.sub,
+        });
+        let workflowId = null;
+        try {
+            workflowId = await this.launcher.launch(insertedId, orgId);
+        }
+        catch (error) {
+            const reason = `launch_failed: ${error.message}`;
+            const now = new Date();
+            await this.repo.updateOptimization(projectId, insertedId, {
+                status: 'failed',
+                controlState: null,
+                finishedAt: now,
+                summary: { kind: 'failed', reason, finalizedAt: now.toISOString() },
+            });
+            throw error;
+        }
+        const inserted = await this.repo.findOptimizationById(projectId, insertedId);
+        if (!inserted) {
+            throw new common_1.NotFoundException(`Optimization ${insertedId} not found after insert`);
+        }
+        return this.toListItem(inserted);
+    }
+    async resolvePromptLanguage(requested, baseVersionId) {
+        if (requested)
+            return requested;
+        if (!baseVersionId)
+            return shared_1.DEFAULT_PROMPT_LANGUAGE;
+        const stored = await this.repo.findPromptVersionLanguage(baseVersionId);
+        const parsed = shared_1.promptLanguageSchema.safeParse(stored);
+        return parsed.success ? parsed.data : shared_1.DEFAULT_PROMPT_LANGUAGE;
+    }
+    async insertOptimizationOrThrowNameConflict(input) {
+        try {
+            return await this.repo.insertOptimization(input);
+        }
+        catch (error) {
+            if (isOptimizationNameUniqueViolation(error)) {
+                throw new common_1.ConflictException('optimization_name_taken');
+            }
+            throw error;
+        }
+    }
+    // SPEC 25 §2.1: in from_dataset_only mode, create an empty prompt to carry the first version.
+    // Naming rule `<localized-prefix>-${datasetName}-${ISO time down to the minute}`; on prompts_project_name_unique collision,
+    // retry once with an 8-char hash suffix appended; a second collision → throw prompt_name_collision_v1.
+    async createPlaceholderPromptWithRetry(input) {
+        const baseName = buildOptimizationPromptName(input.datasetName, new Date(), input.promptLanguage);
+        try {
+            return await this.promptRepo.createPlaceholderPromptForOptimization({
+                projectId: input.projectId,
+                name: baseName,
+                defaultDatasetId: input.datasetId,
+                createdBy: input.createdBy,
+            });
+        }
+        catch (err) {
+            if (!isPromptNameUniqueViolation(err))
+                throw err;
+            const suffix = `-${shortHash(`${input.optimizationName}|${Date.now()}`)}`;
+            try {
+                return await this.promptRepo.createPlaceholderPromptForOptimization({
+                    projectId: input.projectId,
+                    name: `${baseName}${suffix}`,
+                    defaultDatasetId: input.datasetId,
+                    createdBy: input.createdBy,
+                });
+            }
+            catch (err2) {
+                if (isPromptNameUniqueViolation(err2)) {
+                    throw new common_1.ConflictException('prompt_name_collision_v1');
+                }
+                throw err2;
+            }
+        }
+    }
+    async controlOptimization(projectId, optimizationId, action, actor, source = 'api', 
+    // orgId (SaaS-only; undefined in OSS) sourced from the resolved ProjectContext — the project's org is the
+    // rate-limit bucket (SPEC 08 §3.7). Threaded into launcher.resume on the resume path.
+    orgId) {
+        await this.getWritableProject(projectId, actor);
+        const parsedAction = shared_1.optimizationControlActionSchema.parse(action);
+        const current = await this.repo.findOptimizationById(projectId, optimizationId);
+        if (!current) {
+            throw new common_1.NotFoundException(`Optimization ${optimizationId} not found`);
+        }
+        const patch = this.getControlPatch(parsedAction, current);
+        await this.repo.updateOptimization(projectId, optimizationId, patch);
+        // SPEC 25 §7 dual-path linkage: on stop/cancel, immediately call controlExperiment on the child; do not block the parent control write to DB
+        // resume is not linked here — child experiment resume is handled by the workflow in the isResumeRound branch via controlChildExperimentStep
+        if (parsedAction === 'stop' || parsedAction === 'cancel') {
+            await this.tryLinkChildExperimentControl(optimizationId, parsedAction);
+        }
+        if (parsedAction === 'resume') {
+            await this.workflowAuth.assertCanStart((0, access_control_1.toActorContext)(actor), { projectId, orgId, source: 'local' }, 'optimization');
+            await this.launcher.resume(optimizationId, orgId);
+        }
+        const updated = await this.repo.findOptimizationById(projectId, optimizationId);
+        if (!updated) {
+            throw new common_1.NotFoundException(`Optimization ${optimizationId} not found after update`);
+        }
+        return this.toListItem(updated);
+    }
+    // SPEC 25 §7: stop/cancel on the parent optimization immediately propagates to the active child experiment. Best-effort:
+    //   - no active child experiment (already terminal / not yet created) → no-op
+    //   - service throws Conflict / NotFound → warn and swallow (the workflow poll is the backstop)
+    //   - other errors → warn and swallow (do not throw, to avoid blocking the parent control_state write)
+    async tryLinkChildExperimentControl(optimizationId, action) {
+        const activeChild = await this.repo.findActiveChildExperiment(optimizationId);
+        if (!activeChild)
+            return;
+        try {
+            await this.experimentService.controlExperiment(activeChild.projectId, activeChild.id, action, optimization_workflow_1.SYSTEM_ACTOR_OPTIMIZATION, 'system');
+            this.logger.info({
+                optimizationId,
+                childExperimentId: activeChild.id,
+                roundIndex: activeChild.roundIndex,
+                action,
+            }, 'optimization_child_control_linked_from_service');
+        }
+        catch (error) {
+            const level = error instanceof common_1.ConflictException || error instanceof common_1.NotFoundException ? 'skipped' : 'failed';
+            this.logger.warn({
+                optimizationId,
+                childExperimentId: activeChild.id,
+                action,
+                err: error.message,
+            }, `optimization_child_control_${level}`);
+        }
+    }
+    async deleteOptimization(projectId, optimizationId, actor, source = 'api') {
+        void source;
+        await this.getWritableProject(projectId, actor);
+        const row = await this.repo.findOptimizationById(projectId, optimizationId);
+        if (!row) {
+            throw new common_1.NotFoundException(`Optimization ${optimizationId} not found`);
+        }
+        await this.repo.hardDeleteOptimization(projectId, optimizationId);
+    }
+    // ----------------------------- helpers -----------------------------
+    async getAccessibleProject(projectId, actor) {
+        await this.accessControl.assertCan((0, access_control_1.toActorContext)(actor), { projectId, source: 'local' }, 'project_read');
+        const project = await this.repo.findProjectAccess(actor.sub, projectId, actor.isSuperAdmin);
+        if (!project) {
+            throw new common_1.NotFoundException(`Project ${projectId} not found`);
+        }
+        return project;
+    }
+    async getWritableProject(projectId, actor) {
+        await this.accessControl.assertCan((0, access_control_1.toActorContext)(actor), { projectId, source: 'local' }, 'project_write');
+        return this.getAccessibleProject(projectId, actor);
+    }
+    getControlPatch(action, row) {
+        const status = row.status;
+        const now = new Date();
+        if (action === 'stop') {
+            if (status !== 'running') {
+                throw new common_1.ConflictException('optimization_stop_invalid_status');
+            }
+            // Preemptive terminal-state write: set status='stopped' + control_state='stop' + finished_at in one shot.
+            // The workflow will call finalize once the current LLM step finishes, but repo.finalize has a status='running' guard,
+            // so the second write is skipped — avoiding overwriting the terminal state already written by service, and avoiding finished_at drift.
+            // control_state is preserved; on the next round the workflow reads status as terminal and exits directly.
+            return {
+                status: 'stopped',
+                controlState: 'stop',
+                finishedAt: now,
+                updatedAt: now,
+            };
+        }
+        if (action === 'resume') {
+            if (status !== 'stopped') {
+                throw new common_1.ConflictException('optimization_resume_invalid_status');
+            }
+            return {
+                status: 'running',
+                controlState: 'resume',
+                startedAt: row.startedAt ?? now,
+                finishedAt: null,
+                updatedAt: now,
+            };
+        }
+        if (status === 'success' || status === 'cancelled') {
+            throw new common_1.ConflictException('optimization_cancel_invalid_status');
+        }
+        // cancel is preemptive in the same way (regardless of whether the original status was running or stopped/failed).
+        return {
+            status: 'cancelled',
+            controlState: 'cancel',
+            finishedAt: now,
+            updatedAt: now,
+        };
+    }
+    toListItem(row, options = {}) {
+        return {
+            trend: options.trend ?? null,
+            trendHasBaseline: options.trendHasBaseline ?? false,
+            id: row.id,
+            projectId: row.projectId,
+            name: row.name,
+            description: row.description,
+            strategy: row.strategy,
+            startingMode: row.startingMode,
+            status: row.status,
+            controlState: row.controlState,
+            sourceExperimentId: row.sourceExperimentId,
+            sourceExperimentName: row.sourceExperimentName,
+            promptId: row.promptId,
+            promptName: row.promptName,
+            baseVersionId: row.baseVersionId,
+            baseVersionNumber: row.baseVersionNumber,
+            datasetId: row.datasetId,
+            datasetName: row.datasetName,
+            datasetSamples: row.datasetSamples,
+            experimentModelId: row.experimentModelId,
+            experimentModelName: row.experimentModelName,
+            analysisModelId: row.analysisModelId,
+            analysisModelName: row.analysisModelName,
+            promptLanguage: this.parsePromptLanguage(row.promptLanguage),
+            goals: this.parseGoals(row.goals),
+            fieldWhitelist: this.parseFieldWhitelist(row.fieldWhitelist),
+            runConfig: this.parseRunConfig(row.runConfig),
+            maxRounds: row.maxRounds,
+            currentRound: options.currentRound ?? row.currentRound,
+            bestVersionId: row.bestVersionId,
+            bestVersionNumber: row.bestVersionNumber,
+            bestMetrics: this.parseBestMetrics(row.bestMetrics),
+            summary: this.parseSummary(row.summary),
+            analysisFailureReason: this.parseAnalysisFailureReason(row.analysisFailureReason),
+            dbosWorkflowId: row.dbosWorkflowId,
+            createdBy: row.createdBy,
+            createdByDisplayName: row.createdByDisplayName,
+            createdByUsername: row.createdByUsername,
+            startedAt: row.startedAt?.toISOString() ?? null,
+            finishedAt: row.finishedAt?.toISOString() ?? null,
+            createdAt: row.createdAt.toISOString(),
+            updatedAt: (options.updatedAt ?? row.updatedAt).toISOString(),
+            deletedAt: row.deletedAt?.toISOString() ?? null,
+        };
+    }
+    toDetail(row, aggregation = { rounds: [], llmRows: [], roundSteps: [] }) {
+        const roundSteps = aggregation.roundSteps ?? [];
+        const hasSourceMetrics = row.sourceExperimentMetrics &&
+            typeof row.sourceExperimentMetrics === 'object' &&
+            Object.keys(row.sourceExperimentMetrics).length > 0;
+        // Real data sources: experiments ∪ round_steps ∪ source experiment metrics (baseline). If any is non-empty, take the real-aggregate path.
+        // The presence of round_steps means that as soon as prepareRoundImpl starts (error_analysis=running),
+        // the round is visible on the detail page without waiting for the child experiment to be created;
+        // when baseline metrics exist, even round 0 takes the real-aggregate path so the metrics trend card immediately shows the baseline first point.
+        const realRounds = aggregation.rounds.length > 0 || roundSteps.length > 0 || hasSourceMetrics;
+        this.logger.debug({
+            optimizationId: row.id,
+            status: row.status,
+            roundsLen: aggregation.rounds.length,
+            llmRowsLen: aggregation.llmRows.length,
+            roundStepsLen: roundSteps.length,
+            llmRowsBySource: aggregation.llmRows.reduce((acc, r) => {
+                acc[r.source] = (acc[r.source] ?? 0) + 1;
+                return acc;
+            }, {}),
+            realRounds,
+        }, 'optimization_detail_aggregate_start');
+        const liveProjection = deriveLiveProjection(row, aggregation.rounds, roundSteps);
+        const listTrend = this.deriveListTrend(row, aggregation.rounds);
+        const base = this.toListItem(row, {
+            trend: listTrend.values,
+            trendHasBaseline: listTrend.hasBaseline,
+            currentRound: liveProjection.currentRound,
+            updatedAt: liveProjection.updatedAt,
+        });
+        const ownerHandle = row.createdByUsername ? `@${row.createdByUsername}` : (row.createdByDisplayName ?? '—');
+        const startedAt = row.startedAt;
+        const finishedAt = row.finishedAt;
+        const elapsedMs = startedAt ? Math.max(0, (finishedAt ?? new Date()).getTime() - startedAt.getTime()) : null;
+        const goalScope = this.deriveGoalScope(base.goals);
+        const goalsLines = this.deriveGoalsLines(base.goals);
+        const experimentConfig = this.deriveExperimentConfig(row, base.runConfig);
+        const iterationConfig = this.deriveIterationConfig(row, base.runConfig);
+        const sourceMetrics = row.sourceExperimentMetrics && typeof row.sourceExperimentMetrics === 'object'
+            ? row.sourceExperimentMetrics
+            : null;
+        const derivedBaseline = this.deriveBaseline(row, sourceMetrics, aggregation.promptBodyMap ?? new Map());
+        const derivedBestRoundLabel = row.bestVersionNumber ? `v${row.bestVersionNumber}` : null;
+        if (realRounds) {
+            // Real aggregate
+            const trend = this.deriveTrendSeries(base.goals, aggregation.rounds, sourceMetrics, base.startingMode);
+            const rounds = this.deriveRoundDetails(aggregation.rounds, aggregation.llmRows, roundSteps, aggregation.promptBodyMap ?? new Map(), row.baseVersionId, base.goals, sourceMetrics, base.startingMode);
+            const effectiveBest = this.deriveEffectiveBest(row, aggregation.rounds, base.goals, base.bestMetrics, sourceMetrics, base.startingMode);
+            const goalProgress = this.deriveGoalProgress(base.goals, effectiveBest?.metrics ?? null);
+            const bestVersion = this.deriveBestVersion(row, effectiveBest);
+            const bestRoundLabel = bestVersion ? bestVersion.generatedAtRoundLabel : derivedBestRoundLabel;
+            const baseline = derivedBaseline;
+            return {
+                ...base,
+                optimizationHint: normalizeOptimizationHint(row.optimizationHint),
+                ownerHandle,
+                elapsedMs,
+                experimentConfig,
+                iterationConfig,
+                goalScope,
+                goalsLines,
+                controlStrip: null,
+                trend,
+                trendBaselineRef: null,
+                bestRoundLabel,
+                rounds,
+                baseline,
+                goalProgress,
+                bestVersion,
+            };
+        }
+        // No real data → fall back to the dev mock (dev seed for demo / e2e)
+        const mock = this.extractDevMockTimeline(base.runConfig);
+        this.logger.debug({
+            optimizationId: row.id,
+            reason: 'no_real_rounds',
+            hasDevMock: !!mock,
+            mockRoundsLen: mock?.rounds?.length ?? 0,
+        }, 'optimization_detail_using_dev_mock');
+        const baseline = derivedBaseline && mock?.baselineMetrics
+            ? { ...derivedBaseline, metrics: mock.baselineMetrics }
+            : derivedBaseline;
+        return {
+            ...base,
+            optimizationHint: normalizeOptimizationHint(row.optimizationHint),
+            ownerHandle,
+            elapsedMs,
+            experimentConfig,
+            iterationConfig,
+            goalScope,
+            goalsLines,
+            controlStrip: mock?.controlStrip ?? null,
+            trend: mock?.trend ?? [],
+            trendBaselineRef: mock?.trendBaselineRef ?? null,
+            bestRoundLabel: mock?.bestRoundLabel ?? derivedBestRoundLabel,
+            rounds: mock?.rounds ?? [],
+            baseline,
+            goalProgress: mock?.goalProgress ?? [],
+            bestVersion: mock?.bestVersion ?? null,
+        };
+    }
+    deriveListTrend(row, rounds) {
+        const goals = this.parseGoals(row.goals);
+        const primary = goals[0]?.metric;
+        if (!primary)
+            return { values: null, hasBaseline: false };
+        const baselineMetrics = row.sourceExperimentMetrics && typeof row.sourceExperimentMetrics === 'object'
+            ? row.sourceExperimentMetrics
+            : null;
+        const sortedRounds = rounds.slice().sort((a, b) => a.roundIndex - b.roundIndex);
+        if (row.startingMode === 'from_dataset_only') {
+            const baselineRound = sortedRounds.find((r) => r.roundIndex === 0);
+            const baselineValue = extractMetric(baselineRound?.metrics ?? baselineMetrics, primary);
+            const roundValues = sortedRounds
+                .filter((r) => r.roundIndex > 0)
+                .map((r) => extractMetric(r.metrics, primary))
+                .filter((v) => v !== null);
+            const values = baselineValue !== null ? [baselineValue, ...roundValues] : roundValues;
+            return { values: values.length > 0 ? values : null, hasBaseline: baselineValue !== null };
+        }
+        const baselineValue = baselineMetrics ? extractMetric(baselineMetrics, primary) : null;
+        const hasBaseline = baselineValue !== null;
+        const roundValues = sortedRounds
+            .map((r) => extractMetric(r.metrics, primary))
+            .filter((v) => v !== null);
+        const values = hasBaseline ? [baselineValue, ...roundValues] : roundValues;
+        return { values: values.length > 0 ? values : null, hasBaseline };
+    }
+    deriveTrendSeries(goals, rounds, baselineMetrics = null, startingMode) {
+        const sorted = rounds.slice().sort((a, b) => a.roundIndex - b.roundIndex);
+        const keyCandidates = [
+            { key: 'accuracy', metric: 'accuracy' },
+            { key: 'recall', metric: 'recall' },
+            { key: 'fpr', metric: 'fpr' },
+        ];
+        const series = [];
+        for (const { key, metric } of keyCandidates) {
+            const datasetBaselineRound = startingMode === 'from_dataset_only' ? sorted.find((r) => r.roundIndex === 0) : undefined;
+            const baselineValue = startingMode === 'from_dataset_only'
+                ? extractMetric(datasetBaselineRound?.metrics ?? baselineMetrics, metric)
+                : baselineMetrics
+                    ? extractMetric(baselineMetrics, metric)
+                    : null;
+            const optimizationRounds = startingMode === 'from_dataset_only' ? sorted.filter((r) => r.roundIndex > 0) : sorted;
+            const roundValues = optimizationRounds
+                .map((r) => extractMetric(r.metrics, metric))
+                .filter((v) => v !== null);
+            const hasBaseline = baselineValue !== null;
+            const values = hasBaseline ? [baselineValue, ...roundValues] : roundValues;
+            if (values.length === 0)
+                continue;
+            const matchingGoal = goals.find((g) => g.metric === metric);
+            // bestRoundIndex still points to the best index within the round set (excluding baseline) to preserve prop semantics
+            let bestRoundIndex;
+            if (roundValues.length > 0) {
+                let bestIdx = 0;
+                for (let i = 1; i < roundValues.length; i++) {
+                    if (matchingGoal?.comparator === 'lte'
+                        ? roundValues[i] < roundValues[bestIdx]
+                        : roundValues[i] > roundValues[bestIdx]) {
+                        bestIdx = i;
+                    }
+                }
+                bestRoundIndex = bestIdx;
+            }
+            series.push({
+                key,
+                labelKey: `optimizations.metrics.${key}`,
+                betterIsLower: matchingGoal?.comparator === 'lte',
+                values,
+                target: matchingGoal?.target,
+                bestRoundIndex,
+                hasBaseline,
+            });
+        }
+        return series;
+    }
+    deriveRoundDetails(rounds, llmRows, roundSteps, promptBodyMap, baseVersionId, goals, baselineMetrics, startingMode) {
+        const llmByRound = new Map();
+        for (const llm of llmRows) {
+            const arr = llmByRound.get(llm.roundIndex) ?? [];
+            arr.push(llm);
+            llmByRound.set(llm.roundIndex, arr);
+        }
+        // Index the experiments rows by roundIndex; when missing (analysis/generation stage), use stepsByRound to render the card separately
+        const experimentByRound = new Map();
+        for (const r of rounds)
+            experimentByRound.set(r.roundIndex, r);
+        const stepsByRound = new Map();
+        for (const s of roundSteps) {
+            const arr = stepsByRound.get(s.roundIndex) ?? [];
+            arr.push(s);
+            stepsByRound.set(s.roundIndex, arr);
+        }
+        // Merge the roundIndex set → sort and generate cards one by one
+        const allIndexes = new Set([...rounds.map((r) => r.roundIndex), ...roundSteps.map((s) => s.roundIndex)]);
+        const sortedIndexes = Array.from(allIndexes).sort((a, b) => a - b);
+        // Also maintain a sortedExperiments list (containing only rounds that actually have an experiment row), used solely as the historical-data fallback.
+        // Prefer the new data: prompt_versions.parent_version_id / generate run_result.prompt_version_id,
+        // so the diff aligns with "from which prompt was the current version actually generated".
+        const sortedExperiments = rounds.slice().sort((a, b) => a.roundIndex - b.roundIndex);
+        return sortedIndexes.map((idx) => {
+            const experiment = experimentByRound.get(idx) ?? null;
+            const isDatasetBaseline = startingMode === 'from_dataset_only' && idx === 0;
+            const stepsForRound = stepsByRound.get(idx) ?? [];
+            const stepDtos = mapStepRowsToDtos(stepsForRound);
+            // status derivation: when steps data is present, derive from steps (the experiment row is not visible during the analysis / generation stage);
+            // otherwise fall back to experiment.status.
+            const status = isDatasetBaseline
+                ? deriveDatasetBaselineStatus(stepDtos, experiment?.status)
+                : deriveRoundStatusFromSteps(stepDtos, experiment?.status);
+            const llms = llmByRound.get(idx) ?? [];
+            const analysis = llms.find((r) => r.source === 'optimization_analysis');
+            const generate = llms.find((r) => r.source === 'optimization_generate');
+            this.logger.debug({
+                roundIndex: idx,
+                status,
+                hasAnalysis: !!analysis,
+                hasGenerate: !!generate,
+                hasExperiment: !!experiment,
+                llmRowsForRoundLen: llms.length,
+                stepsForRoundLen: stepDtos.length,
+                analysisStatus: analysis?.status,
+                generateStatus: generate?.status,
+            }, 'optimization_detail_round_derive');
+            const analysisText = analysis ? extractAnalysisSummary(analysis, idx) : undefined;
+            const generateText = isDatasetBaseline ? extractGenerateSummary(generate, idx) : undefined;
+            const errorPatterns = isDatasetBaseline ? undefined : extractErrorPatterns(analysis, idx);
+            const improvementSuggestions = isDatasetBaseline ? undefined : extractImprovementSuggestions(analysis, idx);
+            const prevVersionId = isDatasetBaseline
+                ? null
+                : resolvePromptDiffBaseVersionId(experiment, generate, sortedExperiments, baseVersionId);
+            const promptDiff = experiment
+                ? buildPromptDiff(experiment, generate, prevVersionId, promptBodyMap)
+                : buildPromptDiffWithoutExperiment(generate, idx, prevVersionId, promptBodyMap);
+            const experimentResult = experiment ? buildExperimentResult(experiment, baselineMetrics) : undefined;
+            const goalChips = this.buildRoundGoalChips(goals, experiment);
+            const { autoPatched, patchedVariables } = extractAutoPatchInfo(generate);
+            return {
+                index: idx,
+                status,
+                isBaseline: isDatasetBaseline || experiment?.isBaseline === true ? true : undefined,
+                kindLabel: isDatasetBaseline ? 'dataset baseline' : `Round ${idx}`,
+                startedAt: experiment?.startedAt?.toISOString(),
+                metrics: experiment ? extractRoundMetricCells(experiment.metrics) : [],
+                promptVersionId: experiment?.promptVersionId ?? null,
+                experimentId: experiment?.experimentId ?? null,
+                summaryFallback: generateText ?? analysisText,
+                errorPatterns,
+                improvementSuggestions,
+                promptDiff,
+                experimentResult,
+                steps: stepDtos,
+                goalChips,
+                autoPatched,
+                patchedVariables,
+            };
+        });
+    }
+    deriveGoalProgress(goals, bestMetrics) {
+        return goals.map((goal) => {
+            const current = typeof bestMetrics?.[goal.metric] === 'number' ? bestMetrics[goal.metric] : null;
+            const achieved = current === null
+                ? 'miss'
+                : goal.comparator === 'gte'
+                    ? current >= goal.target
+                        ? 'hit'
+                        : 'miss'
+                    : goal.comparator === 'gt'
+                        ? current > goal.target
+                            ? 'hit'
+                            : 'miss'
+                        : current <= goal.target
+                            ? 'hit'
+                            : 'miss';
+            const comparatorText = goal.comparator === 'gte' ? '≥' : goal.comparator === 'gt' ? '>' : '≤';
+            const percent = current === null ? 0 : Math.min(100, Math.max(0, Math.round((current / Math.max(0.0001, goal.target)) * 100)));
+            return {
+                label: this.formatMetricLabel(goal.metric),
+                targetText: `${comparatorText} ${goal.target}`,
+                currentText: current === null ? '—' : current.toFixed(3),
+                achieved,
+                percent,
+            };
+        });
+    }
+    // The "goal vs current round" chip list shown at the top-right of each round card header.
+    // overall scope reads metrics[goal.metric]; class scope reads from metrics.perClass by label.
+    buildRoundGoalChips(goals, experiment) {
+        if (!experiment)
+            return goals.map((g) => this.makeRoundGoalChip(g, null));
+        const metricsObj = experiment.metrics && typeof experiment.metrics === 'object'
+            ? experiment.metrics
+            : null;
+        if (!metricsObj)
+            return goals.map((g) => this.makeRoundGoalChip(g, null));
+        return goals.map((g) => {
+            let current = null;
+            if (g.scope === 'overall') {
+                current = typeof metricsObj[g.metric] === 'number' ? metricsObj[g.metric] : null;
+            }
+            else {
+                const perClass = Array.isArray(metricsObj['perClass']) ? metricsObj['perClass'] : [];
+                const entry = perClass.find((x) => !!x && typeof x === 'object' && x['label'] === g.scope);
+                current = entry && typeof entry[g.metric] === 'number' ? entry[g.metric] : null;
+            }
+            return this.makeRoundGoalChip(g, current);
+        });
+    }
+    makeRoundGoalChip(goal, current) {
+        const comparator = goal.comparator === 'gte' ? '≥' : goal.comparator === 'gt' ? '>' : '≤';
+        const achieved = current === null
+            ? 'miss'
+            : goal.comparator === 'gte'
+                ? current >= goal.target
+                    ? 'hit'
+                    : 'miss'
+                : goal.comparator === 'gt'
+                    ? current > goal.target
+                        ? 'hit'
+                        : 'miss'
+                    : current <= goal.target
+                        ? 'hit'
+                        : 'miss';
+        const metricLabel = this.formatMetricLabel(goal.metric);
+        const label = goal.scope === 'overall' ? metricLabel : `${goal.scope} ${metricLabel}`;
+        return {
+            label,
+            targetText: `${comparator} ${goal.target}`,
+            currentText: current === null ? '—' : current.toFixed(3),
+            achieved,
+        };
+    }
+    deriveEffectiveBest(row, rounds, goals, bestMetrics, sourceMetrics, startingMode) {
+        const persistedBest = this.derivePersistedBestCandidate(row, rounds, bestMetrics);
+        const baselineBest = this.deriveBaselineBestCandidate(row, rounds, sourceMetrics, startingMode);
+        if (!baselineBest)
+            return persistedBest;
+        if (!persistedBest)
+            return baselineBest;
+        return this.isBetterBestMetrics(baselineBest.metrics, persistedBest.metrics, goals) ? baselineBest : persistedBest;
+    }
+    derivePersistedBestCandidate(row, rounds, bestMetrics) {
+        if (!row.bestVersionId || !bestMetrics)
+            return null;
+        const bestRound = rounds.find((r) => r.promptVersionId === row.bestVersionId);
+        return {
+            metrics: bestMetrics,
+            promptVersionId: row.bestVersionId,
+            promptVersionNumber: row.bestVersionNumber,
+            generatedAtRoundLabel: row.bestVersionNumber ? `v${row.bestVersionNumber}` : '—',
+            generatedAtRoundIndex: bestRound?.roundIndex ?? null,
+            experimentId: bestRound?.experimentId ?? null,
+            experimentName: bestRound?.experimentName ?? null,
+            isBaseline: false,
+        };
+    }
+    deriveBaselineBestCandidate(row, rounds, sourceMetrics, startingMode) {
+        const baselineRound = rounds.find((r) => r.isBaseline === true || (startingMode === 'from_dataset_only' && r.roundIndex === 0));
+        const metrics = this.parseBestMetrics(baselineRound?.metrics ?? sourceMetrics);
+        if (!metrics)
+            return null;
+        return {
+            metrics,
+            promptVersionId: baselineRound?.promptVersionId ?? row.sourceExperimentPromptVersionId ?? row.baseVersionId,
+            promptVersionNumber: baselineRound?.promptVersionNumber ?? row.sourceExperimentPromptVersionNumber ?? row.baseVersionNumber,
+            generatedAtRoundLabel: 'baseline',
+            generatedAtRoundIndex: 0,
+            experimentId: baselineRound?.experimentId ?? row.sourceExperimentId,
+            experimentName: baselineRound?.experimentName ?? row.sourceExperimentName,
+            isBaseline: true,
+        };
+    }
+    isBetterBestMetrics(candidate, current, goals) {
+        if (goals.length === 0)
+            return false;
+        const candidateUnmet = this.unmetGoalCount(candidate, goals);
+        const currentUnmet = this.unmetGoalCount(current, goals);
+        if (candidateUnmet !== currentUnmet)
+            return candidateUnmet < currentUnmet;
+        return this.directionalGoalScore(candidate, goals) > this.directionalGoalScore(current, goals);
+    }
+    unmetGoalCount(metrics, goals) {
+        let count = 0;
+        for (const goal of goals) {
+            const value = this.readBestMetric(metrics, goal);
+            const hit = value !== null &&
+                (goal.comparator === 'gte'
+                    ? value >= goal.target
+                    : goal.comparator === 'gt'
+                        ? value > goal.target
+                        : value <= goal.target);
+            if (!hit)
+                count += 1;
+        }
+        return count;
+    }
+    directionalGoalScore(metrics, goals) {
+        let score = 0;
+        for (const goal of goals) {
+            const value = this.readBestMetric(metrics, goal);
+            score += value === null ? Number.NEGATIVE_INFINITY : goal.comparator === 'lte' ? -value : value;
+        }
+        return score;
+    }
+    readBestMetric(metrics, goal) {
+        const value = metrics[goal.metric];
+        return typeof value === 'number' && Number.isFinite(value) ? value : null;
+    }
+    deriveBestVersion(row, best) {
+        if (!best)
+            return null;
+        const metricCells = Object.entries(best.metrics).map(([k, v]) => ({ label: this.formatMetricLabel(k), value: v }));
+        return {
+            promptRef: row.promptName ?? '—',
+            promptVersion: best.promptVersionNumber ? `v${best.promptVersionNumber}` : '—',
+            generatedAtRoundLabel: best.generatedAtRoundLabel,
+            generatedAtRoundIndex: best.generatedAtRoundIndex,
+            metrics: metricCells,
+            experimentRef: best.experimentName ?? '—',
+            promptVersionId: best.promptVersionId,
+            experimentId: best.experimentId,
+        };
+    }
+    extractDevMockTimeline(runConfig) {
+        const raw = runConfig['devMockTimeline'];
+        if (raw === undefined || raw === null)
+            return null;
+        const parsed = shared_1.optimizationDevMockTimelineSchema.safeParse(raw);
+        return parsed.success ? parsed.data : null;
+    }
+    deriveGoalScope(goals) {
+        const classes = Array.from(new Set(goals.map((g) => g.scope).filter((scope) => scope && scope !== 'overall')));
+        if (classes.length === 0)
+            return { kind: 'overall' };
+        return { kind: 'class', classes };
+    }
+    deriveGoalsLines(goals) {
+        return goals.map((goal) => {
+            const tone = goal.scope === 'overall' ? 'overall' : 'class';
+            const label = goal.scope === 'overall'
+                ? this.formatMetricLabel(goal.metric)
+                : `${this.formatMetricLabel(goal.metric)} · ${goal.scope}`;
+            const comparatorText = goal.comparator === 'gte' ? '≥' : goal.comparator === 'gt' ? '>' : '≤';
+            const targetText = `${comparatorText} ${goal.target}`;
+            return { label, targetText, tone };
+        });
+    }
+    formatMetricLabel(metric) {
+        if (!metric)
+            return metric;
+        if (metric === 'fpr')
+            return 'FPR';
+        if (metric === 'f1')
+            return 'F1';
+        return metric.charAt(0).toUpperCase() + metric.slice(1);
+    }
+    deriveExperimentConfig(row, runConfig) {
+        if (!row.datasetName || !row.experimentModelName)
+            return null;
+        const promptVersion = row.baseVersionNumber ? `v${row.baseVersionNumber}` : '—';
+        const baselineExperiment = row.sourceExperimentName ?? '—';
+        return {
+            datasetName: row.datasetName,
+            promptName: row.promptName ?? '—',
+            promptVersion,
+            modelName: row.experimentModelName,
+            baselineExperiment,
+            temperature: typeof runConfig.temperature === 'number' ? runConfig.temperature : 0,
+            concurrency: typeof runConfig.concurrency === 'number' ? runConfig.concurrency : 0,
+            rpm: typeof runConfig.rpmLimit === 'number' ? runConfig.rpmLimit : 0,
+            tpm: typeof runConfig.tpmLimit === 'number' ? runConfig.tpmLimit : 0,
+        };
+    }
+    deriveIterationConfig(row, runConfig) {
+        if (!row.analysisModelName)
+            return null;
+        const noImprovement = runConfig['stopAfterNoImprovementRounds'];
+        const regressionRaw = runConfig['regressionThreshold'];
+        return {
+            analysisModel: row.analysisModelName,
+            strategy: row.strategy,
+            maxRounds: row.maxRounds,
+            noImprovementStop: typeof noImprovement === 'number' ? noImprovement : 0,
+            regressionThreshold: typeof regressionRaw === 'number' ? regressionRaw : 0,
+        };
+    }
+    deriveBaseline(row, sourceMetrics, promptBodyMap) {
+        if (!row.sourceExperimentName)
+            return null;
+        const promptVersionId = row.baseVersionId ?? row.sourceExperimentPromptVersionId;
+        const promptVersion = row.baseVersionNumber ?? row.sourceExperimentPromptVersionNumber;
+        const prompt = promptVersionId ? promptBodyMap.get(promptVersionId) : undefined;
+        const promptPreview = prompt
+            ? (0, shared_1.composeFullPrompt)(prompt.body ?? '', (0, shared_1.outputSchemaToJsonSchema)(prompt.outputSchema), {
+                language: this.parsePromptLanguage(prompt.promptLanguage),
+            })
+            : null;
+        const baselineExperiment = buildBaselineExperimentRow(row);
+        return {
+            promptVersion: promptVersion ? `v${promptVersion}` : '—',
+            baselineExperiment: row.sourceExperimentName,
+            metrics: extractRoundMetricCells(sourceMetrics),
+            promptPreview,
+            ...(baselineExperiment ? { experimentResult: buildExperimentResult(baselineExperiment, null) } : {}),
+        };
+    }
+    parseGoals(value) {
+        const parse = shared_1.optimizationGoalSchema.array().safeParse(value ?? []);
+        if (!parse.success) {
+            const legacy = this.parseLegacyGoals(value);
+            if (legacy)
+                return legacy;
+            throw new common_1.BadRequestException('optimization_goals_invalid');
+        }
+        return parse.data;
+    }
+    parseLegacyGoals(value) {
+        const entries = Array.isArray(value) ? value : [value];
+        const goals = entries.map((entry) => this.parseLegacyGoal(entry));
+        return goals.every((goal) => goal !== null) ? goals : null;
+    }
+    parseLegacyGoal(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return null;
+        const legacy = value;
+        const metric = legacy['primary_metric'] ?? legacy['metric'];
+        const target = legacy['target'] ?? legacy['value'];
+        const comparator = legacy['comparator'] ?? legacy['op'] ?? 'gte';
+        const scope = legacy['scope'] ?? 'overall';
+        const parse = shared_1.optimizationGoalSchema.safeParse({ metric, comparator, target, scope });
+        return parse.success ? parse.data : null;
+    }
+    parseFieldWhitelist(value) {
+        if (value === null || value === undefined)
+            return null;
+        const parse = shared_1.optimizationFieldWhitelistSchema.safeParse(value);
+        return parse.success ? parse.data : null;
+    }
+    parseRunConfig(value) {
+        const parse = shared_1.optimizationRunConfigSchema.safeParse(value ?? {});
+        return parse.success ? parse.data : {};
+    }
+    parsePromptLanguage(value) {
+        const parse = shared_1.promptLanguageSchema.safeParse(value);
+        return parse.success ? parse.data : shared_1.DEFAULT_PROMPT_LANGUAGE;
+    }
+    parseBestMetrics(value) {
+        if (value === null || value === undefined)
+            return null;
+        if (typeof value !== 'object')
+            return null;
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (typeof entry === 'number' && Number.isFinite(entry))
+                result[key] = entry;
+        }
+        return result;
+    }
+    parseSummary(value) {
+        if (value === null || value === undefined)
+            return null;
+        const parse = shared_1.optimizationSummarySchema.safeParse(value);
+        if (!parse.success)
+            return null;
+        // reason may contain upstream API payload; truncate to 500 chars to prevent leakage
+        const reason = parse.data.reason.length > 500 ? `${parse.data.reason.slice(0, 500)}…` : parse.data.reason;
+        return { ...parse.data, reason };
+    }
+    parseAnalysisFailureReason(value) {
+        if (!value)
+            return null;
+        return value.length > 500 ? `${value.slice(0, 500)}…` : value;
+    }
+    filterItems(items, query) {
+        const search = query.search?.trim().toLowerCase();
+        return items.filter((item) => {
+            if (query.status && item.status !== query.status)
+                return false;
+            if (!search)
+                return true;
+            return [
+                item.name,
+                item.description ?? '',
+                item.datasetName,
+                item.experimentModelName,
+                item.analysisModelName,
+                item.sourceExperimentName ?? '',
+                item.promptName ?? '',
+                item.createdByDisplayName ?? '',
+                item.createdByUsername ?? '',
+            ]
+                .join(' ')
+                .toLowerCase()
+                .includes(search);
+        });
+    }
+    sortItems(items, sort) {
+        return [...items].sort((a, b) => {
+            if (sort === 'bestMetric') {
+                const av = this.bestMetricScalar(a.bestMetrics);
+                const bv = this.bestMetricScalar(b.bestMetrics);
+                return bv - av;
+            }
+            if (sort === 'round') {
+                return b.currentRound / Math.max(1, b.maxRounds) - a.currentRound / Math.max(1, a.maxRounds);
+            }
+            return b.updatedAt.localeCompare(a.updatedAt);
+        });
+    }
+    bestMetricScalar(metrics) {
+        if (!metrics)
+            return -1;
+        const values = Object.values(metrics).filter((value) => Number.isFinite(value));
+        return values.length === 0 ? -1 : Math.max(...values);
+    }
+};
+exports.OptimizationService = OptimizationService;
+exports.OptimizationService = OptimizationService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [optimization_repository_1.OptimizationRepository,
+        optimization_launcher_1.OptimizationLauncher,
+        experiment_repository_1.ExperimentRepository,
+        experiment_service_1.ExperimentService,
+        run_result_service_1.RunResultService,
+        prompt_repository_1.PromptRepository,
+        access_control_service_1.AccessControlService,
+        workflow_authorization_hook_1.WorkflowAuthorizationHook])
+], OptimizationService);
+// ---------------- module helpers ----------------
+function deriveLiveProjection(row, rounds, roundSteps) {
+    let currentRound = row.currentRound;
+    let updatedAt = row.updatedAt;
+    const baselineRoundIndexes = new Set();
+    const progressRoundIndexes = [];
+    for (const round of rounds) {
+        if (isBaselineProgressRound(round)) {
+            baselineRoundIndexes.add(round.roundIndex);
+        }
+        else if (isProgressRoundIndex(round.roundIndex)) {
+            progressRoundIndexes.push(round.roundIndex);
+        }
+        updatedAt = latestDate(updatedAt, round.updatedAt, round.finishedAt, round.startedAt);
+    }
+    for (const step of roundSteps) {
+        if (!isProgressRoundIndex(step.roundIndex)) {
+            baselineRoundIndexes.add(step.roundIndex);
+        }
+        else {
+            progressRoundIndexes.push(step.roundIndex);
+        }
+        updatedAt = latestDate(updatedAt, step.updatedAt, step.finishedAt, step.startedAt, step.createdAt);
+    }
+    if (baselineRoundIndexes.size > 0 && progressRoundIndexes.length === 0) {
+        currentRound = 0;
+    }
+    else if (baselineRoundIndexes.has(currentRound) && !progressRoundIndexes.some((index) => index >= currentRound)) {
+        currentRound = progressRoundIndexes.length > 0 ? Math.max(...progressRoundIndexes) : 0;
+    }
+    for (const roundIndex of progressRoundIndexes) {
+        currentRound = Math.max(currentRound, roundIndex);
+    }
+    return {
+        currentRound: Math.min(Math.max(0, row.maxRounds), Math.max(0, currentRound)),
+        updatedAt,
+    };
+}
+function isBaselineProgressRound(round) {
+    return round.isBaseline === true || round.roundIndex <= 0;
+}
+function isProgressRoundIndex(roundIndex) {
+    return roundIndex > 0;
+}
+function latestDate(current, ...candidates) {
+    let latest = current;
+    for (const candidate of candidates) {
+        if (candidate && candidate.getTime() > latest.getTime())
+            latest = candidate;
+    }
+    return latest;
+}
+// Map ph_runs.optimization_round_steps rows to DTO, sorted in a fixed order
+// (error_analysis → generate_prompt → experiment); the frontend stepper indexes by this order.
+const STEP_ORDER = ['error_analysis', 'generate_prompt', 'experiment'];
+function mapStepRowsToDtos(rows) {
+    const byKind = new Map();
+    for (const r of rows)
+        byKind.set(r.step, r);
+    const out = [];
+    for (const kind of STEP_ORDER) {
+        const row = byKind.get(kind);
+        if (!row)
+            continue;
+        out.push({
+            step: row.step,
+            status: row.status,
+            errorClass: row.errorClass,
+            errorMessage: row.errorMessage,
+            startedAt: row.startedAt?.toISOString() ?? null,
+            finishedAt: row.finishedAt?.toISOString() ?? null,
+            runResultId: row.runResultId,
+            experimentId: row.experimentId,
+        });
+    }
+    return out;
+}
+// Derive the round card's overall status from steps:
+//   - any step running → running (highest priority, because this round is still in flight)
+//   - any step failed  → failed
+//   - all success      → success
+//   - all skipped      → paused
+//   - none of the above (only pending) → fall back to experiment.status
+function deriveRoundStatusFromSteps(steps, experimentStatus) {
+    if (steps.length === 0) {
+        // When there is no round_steps data, fall back to the original logic: based on the status of the experiments row
+        if (experimentStatus === 'success')
+            return 'success';
+        if (experimentStatus === 'failed')
+            return 'failed';
+        if (experimentStatus === 'stopped' || experimentStatus === 'cancelled')
+            return 'paused';
+        return 'running';
+    }
+    if (steps.some((s) => s.status === 'running'))
+        return 'running';
+    if (steps.some((s) => s.status === 'failed'))
+        return 'failed';
+    if (steps.length > 0 && steps.every((s) => s.status === 'success'))
+        return 'success';
+    if (steps.length > 0 && steps.every((s) => s.status === 'skipped'))
+        return 'paused';
+    return 'running';
+}
+function deriveDatasetBaselineStatus(steps, experimentStatus) {
+    if (steps.some((s) => s.status === 'failed'))
+        return 'failed';
+    if (steps.some((s) => s.status === 'running'))
+        return 'running';
+    if (!experimentStatus)
+        return 'running';
+    if (experimentStatus === 'success')
+        return 'success';
+    if (experimentStatus === 'failed')
+        return 'failed';
+    if (experimentStatus === 'stopped' || experimentStatus === 'cancelled')
+        return 'paused';
+    return 'running';
+}
+function parsePromptLanguageValue(value) {
+    const parse = shared_1.promptLanguageSchema.safeParse(value);
+    return parse.success ? parse.data : shared_1.DEFAULT_PROMPT_LANGUAGE;
+}
+// If the experiment row is not yet created (analysis/generation stage), still try to reconstruct promptDiff from the generate run_result.
+// If promptVersionNumber is unavailable, fall back to a round-N label.
+function buildPromptDiffWithoutExperiment(generate, roundIndex, prevVersionId, promptBodyMap) {
+    if (!generate) {
+        detailHelperLogger.debug({
+            roundIndex,
+            status: 'no_generate',
+            hasGenerate: false,
+            hasNewBody: false,
+            hasPrev: !!prevVersionId,
+            path: 'without_experiment',
+        }, 'optimization_detail_prompt_diff_resolve');
+        return undefined;
+    }
+    const newBody = extractGeneratedPromptBody(generate);
+    if (!newBody) {
+        detailHelperLogger.debug({ roundIndex, status: 'no_new_body', path: 'without_experiment', generateRowStatus: generate.status }, 'optimization_detail_prompt_diff_resolve');
+        return undefined;
+    }
+    const prev = prevVersionId ? promptBodyMap.get(prevVersionId) : undefined;
+    const current = generate.promptVersionId ? promptBodyMap.get(generate.promptVersionId) : undefined;
+    const effectiveNewSchema = extractGeneratedOutputSchema(generate, current?.outputSchema ?? prev?.outputSchema ?? null);
+    // Bridge to standard JSON Schema before handing it to composeFullPrompt, ensuring the diff aligns with the path actually sent to the business LLM.
+    const fromText = (0, shared_1.composeFullPrompt)(prev?.body ?? '', (0, shared_1.outputSchemaToJsonSchema)(prev?.outputSchema), {
+        language: parsePromptLanguageValue(prev?.promptLanguage),
+    });
+    const toText = (0, shared_1.composeFullPrompt)(newBody, (0, shared_1.outputSchemaToJsonSchema)(effectiveNewSchema), {
+        language: parsePromptLanguageValue(current?.promptLanguage ?? prev?.promptLanguage),
+    });
+    const fromLabel = prev?.versionNumber ? `v${prev.versionNumber}` : 'baseline';
+    return {
+        from: fromLabel,
+        to: `Round ${roundIndex}`,
+        fromText,
+        toText,
+        lines: [],
+    };
+}
+function extractMetric(metrics, key) {
+    if (!metrics || typeof metrics !== 'object')
+        return null;
+    const v = metrics[key];
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+function extractAnalysisSummary(row, roundIndex) {
+    const parsedOutputKeys = row.parsedOutput && typeof row.parsedOutput === 'object'
+        ? Object.keys(row.parsedOutput).slice(0, 10)
+        : [];
+    const rawLen = typeof row.rawResponse === 'string' ? row.rawResponse.length : 0;
+    if (row.parsedOutput && typeof row.parsedOutput === 'object') {
+        const obj = row.parsedOutput;
+        if (typeof obj['summary'] === 'string') {
+            detailHelperLogger.debug({ roundIndex, resolvedFrom: 'summary', parsedOutputKeys, rawLen, status: row.status }, 'optimization_detail_analysis_summary_resolve');
+            return obj['summary'];
+        }
+        if (typeof obj['errorAnalysisText'] === 'string') {
+            detailHelperLogger.debug({ roundIndex, resolvedFrom: 'errorAnalysisText', parsedOutputKeys, rawLen, status: row.status }, 'optimization_detail_analysis_summary_resolve');
+            return obj['errorAnalysisText'];
+        }
+    }
+    if (typeof row.rawResponse === 'string' && row.rawResponse.length > 0) {
+        detailHelperLogger.debug({ roundIndex, resolvedFrom: 'raw', parsedOutputKeys, rawLen, status: row.status }, 'optimization_detail_analysis_summary_resolve');
+        return row.rawResponse.slice(0, 400);
+    }
+    detailHelperLogger.debug({ roundIndex, resolvedFrom: 'none', parsedOutputKeys, rawLen, status: row.status }, 'optimization_detail_analysis_summary_resolve');
+    return undefined;
+}
+function extractRoundMetricCells(metrics) {
+    if (!metrics || typeof metrics !== 'object')
+        return [];
+    const out = [];
+    for (const [k, v] of Object.entries(metrics)) {
+        if (typeof v === 'number' && Number.isFinite(v)) {
+            out.push({ label: k, value: v });
+        }
+    }
+    return out;
+}
+function collectPromptVersionIds(row, rounds, llmRows = []) {
+    const ids = [];
+    if (row.baseVersionId)
+        ids.push(row.baseVersionId);
+    if (row.sourceExperimentPromptVersionId)
+        ids.push(row.sourceExperimentPromptVersionId);
+    for (const round of rounds) {
+        if (round.promptVersionId)
+            ids.push(round.promptVersionId);
+        if (round.parentVersionId)
+            ids.push(round.parentVersionId);
+    }
+    for (const llm of llmRows) {
+        if (llm.promptVersionId)
+            ids.push(llm.promptVersionId);
+    }
+    return Array.from(new Set(ids));
+}
+function resolvePromptDiffBaseVersionId(experiment, generate, sortedExperiments, baseVersionId) {
+    if (experiment?.parentVersionId)
+        return experiment.parentVersionId;
+    if (generate?.promptVersionId)
+        return generate.promptVersionId;
+    // Legacy fallback: when parent_version_id / generate prompt_version_id are missing,
+    // fall back to the historical "previous experiment prompt" semantics.
+    const prevExperimentIdx = sortedExperiments.findIndex((r) => r.roundIndex === experiment?.roundIndex);
+    const prevExperiment = prevExperimentIdx > 0 ? (sortedExperiments[prevExperimentIdx - 1] ?? null) : null;
+    return prevExperiment?.promptVersionId ?? baseVersionId;
+}
+function extractErrorPatterns(analysis, roundIndex) {
+    if (!analysis) {
+        detailHelperLogger.debug({ roundIndex, status: 'no_analysis' }, 'optimization_detail_error_patterns_resolve');
+        return undefined;
+    }
+    const parsedOutputKeys = analysis.parsedOutput && typeof analysis.parsedOutput === 'object'
+        ? Object.keys(analysis.parsedOutput).slice(0, 10)
+        : [];
+    if (!analysis.parsedOutput || typeof analysis.parsedOutput !== 'object') {
+        detailHelperLogger.debug({ roundIndex, status: 'no_parsed_output', parsedOutputKeys, analysisRowStatus: analysis.status }, 'optimization_detail_error_patterns_resolve');
+        return undefined;
+    }
+    const obj = analysis.parsedOutput;
+    const raw = obj['errorPatterns'];
+    if (!Array.isArray(raw)) {
+        detailHelperLogger.debug({ roundIndex, status: 'no_array', parsedOutputKeys }, 'optimization_detail_error_patterns_resolve');
+        return undefined;
+    }
+    if (raw.length === 0) {
+        detailHelperLogger.debug({ roundIndex, status: 'empty_array', parsedOutputKeys, rawLen: 0 }, 'optimization_detail_error_patterns_resolve');
+        return undefined;
+    }
+    const parsed = [];
+    let filteredCount = 0;
+    for (const item of raw) {
+        if (!item || typeof item !== 'object') {
+            filteredCount += 1;
+            continue;
+        }
+        const i = item;
+        const label = typeof i['label'] === 'string' ? i['label'] : null;
+        if (!label) {
+            filteredCount += 1;
+            continue;
+        }
+        const count = typeof i['count'] === 'number' && Number.isFinite(i['count']) ? i['count'] : 0;
+        const reason = typeof i['reason'] === 'string' ? i['reason'] : '';
+        parsed.push({ label, count, reason });
+    }
+    if (parsed.length === 0) {
+        detailHelperLogger.debug({ roundIndex, status: 'all_filtered', parsedOutputKeys, rawLen: raw.length, filteredCount }, 'optimization_detail_error_patterns_resolve');
+        return undefined;
+    }
+    detailHelperLogger.debug({
+        roundIndex,
+        status: 'ok',
+        parsedOutputKeys,
+        rawLen: raw.length,
+        keptCount: parsed.length,
+        filteredCount,
+    }, 'optimization_detail_error_patterns_resolve');
+    const total = parsed.reduce((acc, p) => acc + p.count, 0);
+    return parsed.map((p) => ({
+        percent: total > 0 ? Math.round((p.count / total) * 100) : 0,
+        title: p.label,
+        detail: p.reason,
+        count: { hit: p.count, total },
+    }));
+}
+function extractImprovementSuggestions(analysis, roundIndex) {
+    if (!analysis) {
+        detailHelperLogger.debug({ roundIndex, status: 'no_analysis' }, 'optimization_detail_improvement_suggestions_resolve');
+        return undefined;
+    }
+    const parsedOutputKeys = analysis.parsedOutput && typeof analysis.parsedOutput === 'object'
+        ? Object.keys(analysis.parsedOutput).slice(0, 10)
+        : [];
+    if (!analysis.parsedOutput || typeof analysis.parsedOutput !== 'object') {
+        detailHelperLogger.debug({ roundIndex, status: 'no_parsed_output', parsedOutputKeys, analysisRowStatus: analysis.status }, 'optimization_detail_improvement_suggestions_resolve');
+        return undefined;
+    }
+    const obj = analysis.parsedOutput;
+    const raw = obj['suggestedChanges'];
+    if (!Array.isArray(raw)) {
+        detailHelperLogger.debug({ roundIndex, status: 'no_array', parsedOutputKeys }, 'optimization_detail_improvement_suggestions_resolve');
+        return undefined;
+    }
+    if (raw.length === 0) {
+        detailHelperLogger.debug({ roundIndex, status: 'empty_array', parsedOutputKeys }, 'optimization_detail_improvement_suggestions_resolve');
+        return undefined;
+    }
+    const out = [];
+    let missingSection = 0;
+    let missingChange = 0;
+    let nonObject = 0;
+    for (const item of raw) {
+        if (!item || typeof item !== 'object') {
+            nonObject += 1;
+            continue;
+        }
+        const i = item;
+        const section = typeof i['section'] === 'string' ? i['section'] : null;
+        const change = typeof i['change'] === 'string' ? i['change'] : null;
+        if (!section)
+            missingSection += 1;
+        if (!change)
+            missingChange += 1;
+        if (!section || !change)
+            continue;
+        const rationale = typeof i['rationale'] === 'string' ? i['rationale'] : '';
+        const rawPriority = i['priority'];
+        const priority = rawPriority === 'high' || rawPriority === 'medium' || rawPriority === 'low' ? rawPriority : undefined;
+        out.push({
+            section,
+            title: change,
+            detail: rationale || undefined,
+            priority,
+        });
+    }
+    if (out.length === 0) {
+        detailHelperLogger.debug({
+            roundIndex,
+            status: 'all_filtered',
+            parsedOutputKeys,
+            rawLen: raw.length,
+            missingSection,
+            missingChange,
+            nonObject,
+        }, 'optimization_detail_improvement_suggestions_resolve');
+        return undefined;
+    }
+    detailHelperLogger.debug({
+        roundIndex,
+        status: 'ok',
+        parsedOutputKeys,
+        rawLen: raw.length,
+        keptCount: out.length,
+        missingSection,
+        missingChange,
+        nonObject,
+    }, 'optimization_detail_improvement_suggestions_resolve');
+    return out;
+}
+function buildPromptDiff(round, generate, prevVersionId, promptBodyMap) {
+    const roundIndex = round.roundIndex;
+    if (!generate) {
+        detailHelperLogger.debug({ roundIndex, status: 'no_generate', hasGenerate: false, hasNewBody: false, hasPrev: !!prevVersionId }, 'optimization_detail_prompt_diff_resolve');
+        return undefined;
+    }
+    const generateParsedKeys = generate.parsedOutput && typeof generate.parsedOutput === 'object'
+        ? Object.keys(generate.parsedOutput).slice(0, 10)
+        : [];
+    const newBody = extractGeneratedPromptBody(generate);
+    if (!newBody) {
+        detailHelperLogger.debug({
+            roundIndex,
+            status: 'no_new_body',
+            hasGenerate: true,
+            hasNewBody: false,
+            hasPrev: !!prevVersionId,
+            generateRowStatus: generate.status,
+            generateParsedKeys,
+        }, 'optimization_detail_prompt_diff_resolve');
+        return undefined;
+    }
+    const prev = prevVersionId ? promptBodyMap.get(prevVersionId) : undefined;
+    const current = round.promptVersionId ? promptBodyMap.get(round.promptVersionId) : undefined;
+    const effectiveNewSchema = extractGeneratedOutputSchema(generate, current?.outputSchema ?? prev?.outputSchema ?? null);
+    // Bridge to standard JSON Schema before handing it to composeFullPrompt, ensuring the diff aligns with the path actually sent to the business LLM.
+    const fromText = (0, shared_1.composeFullPrompt)(prev?.body ?? '', (0, shared_1.outputSchemaToJsonSchema)(prev?.outputSchema), {
+        language: parsePromptLanguageValue(prev?.promptLanguage),
+    });
+    const toText = (0, shared_1.composeFullPrompt)(newBody, (0, shared_1.outputSchemaToJsonSchema)(effectiveNewSchema), {
+        language: parsePromptLanguageValue(current?.promptLanguage ?? prev?.promptLanguage),
+    });
+    const toLabel = round.promptVersionNumber ? `v${round.promptVersionNumber}` : `Round ${round.roundIndex}`;
+    const fromLabel = prev?.versionNumber ? `v${prev.versionNumber}` : 'baseline';
+    detailHelperLogger.debug({
+        roundIndex,
+        status: prev ? 'ok' : 'no_prev_version',
+        hasGenerate: true,
+        hasNewBody: true,
+        hasPrev: !!prev,
+        generateRowStatus: generate.status,
+        generateParsedKeys,
+        prevVersionId,
+        newBodyLen: newBody.length,
+        fromTextLen: fromText.length,
+        schemaChanged: effectiveNewSchema !== (prev?.outputSchema ?? null),
+    }, 'optimization_detail_prompt_diff_resolve');
+    return {
+        from: fromLabel,
+        to: toLabel,
+        fromText,
+        toText,
+        lines: [],
+    };
+}
+function extractGeneratedPromptBody(generate) {
+    if (!generate || !generate.parsedOutput || typeof generate.parsedOutput !== 'object')
+        return null;
+    const obj = generate.parsedOutput;
+    const body = obj['newPromptBody'];
+    if (typeof body === 'string' && body.length > 0)
+        return body;
+    return null;
+}
+function extractGenerateSummary(generate, roundIndex) {
+    if (!generate || !generate.parsedOutput || typeof generate.parsedOutput !== 'object') {
+        detailHelperLogger.debug({ roundIndex, status: generate ? 'no_parsed_output' : 'no_generate' }, 'optimization_detail_generate_summary_resolve');
+        return undefined;
+    }
+    const obj = generate.parsedOutput;
+    const summary = obj['changeSummary'];
+    if (typeof summary === 'string' && summary.trim().length > 0) {
+        return summary.trim().slice(0, 400);
+    }
+    return undefined;
+}
+// SPEC 25 §11: when generate retries are exhausted and placeholders are still missing, parsedOutput records autoPatched=true + a patchedVariables array.
+// The frontend round card renders a "system patch" chip based on this, alerting the user to manually tweak the placeholder embedding. autoPatched=false / missing field → undefined,
+// keeping the DTO field optional so legacy rounds are not polluted.
+function extractAutoPatchInfo(generate) {
+    if (!generate || !generate.parsedOutput || typeof generate.parsedOutput !== 'object') {
+        return {};
+    }
+    const obj = generate.parsedOutput;
+    if (obj['autoPatched'] !== true)
+        return {};
+    const vars = Array.isArray(obj['patchedVariables'])
+        ? obj['patchedVariables'].filter((v) => typeof v === 'string')
+        : [];
+    return { autoPatched: true, patchedVariables: vars };
+}
+// Extract the outputSchema actually in effect for this round from the generate run_result:
+// prefer parsedOutput.newOutputSchema (written when the LLM provided one and it passed validation); otherwise fall back (baseline / previous version schema).
+// safeValidateNewOutputSchema has already validated this on write; here we only check the "object shape" without re-validating,
+// to avoid having historical rounds' display behavior affected by new validation rules.
+function extractGeneratedOutputSchema(generate, fallbackOldSchema) {
+    if (!generate || !generate.parsedOutput || typeof generate.parsedOutput !== 'object') {
+        return fallbackOldSchema;
+    }
+    const obj = generate.parsedOutput;
+    const candidate = obj['newOutputSchema'];
+    if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
+        return candidate;
+    }
+    return fallbackOldSchema;
+}
+function buildBaselineExperimentRow(row) {
+    if (!row.sourceExperimentId || !row.sourceExperimentName || !row.sourceExperimentStatus)
+        return null;
+    return {
+        experimentId: row.sourceExperimentId,
+        experimentName: row.sourceExperimentName,
+        roundIndex: 0,
+        isBaseline: true,
+        promptVersionId: row.sourceExperimentPromptVersionId ?? row.baseVersionId ?? '',
+        promptVersionNumber: row.sourceExperimentPromptVersionNumber ?? row.baseVersionNumber,
+        parentVersionId: null,
+        status: row.sourceExperimentStatus,
+        metrics: row.sourceExperimentMetrics,
+        failureReason: row.sourceExperimentFailureReason,
+        startedAt: row.sourceExperimentStartedAt,
+        finishedAt: row.sourceExperimentFinishedAt,
+        totalSamples: Math.max(0, row.sourceExperimentTotalSamples ?? row.datasetSamples),
+        processedSamples: Math.max(0, row.sourceExperimentProcessedSamples ?? 0),
+        failedSamples: Math.max(0, row.sourceExperimentFailedSamples ?? 0),
+    };
+}
+function buildExperimentResult(round, baselineMetrics) {
+    if (!round.experimentId)
+        return undefined;
+    const status = round.status === 'success' ? 'success' : round.status === 'failed' ? 'failed' : 'running';
+    const samplesDone = Math.max(0, round.processedSamples);
+    const samplesTotal = Math.max(samplesDone, round.totalSamples);
+    const metricsObj = round.metrics && typeof round.metrics === 'object' ? round.metrics : null;
+    const accuracy = metricsObj && typeof metricsObj['accuracy'] === 'number' ? metricsObj['accuracy'] : null;
+    const correct = accuracy !== null ? Math.round(accuracy * samplesDone) : 0;
+    const wrong = Math.max(0, samplesDone - correct);
+    const elapsed = formatElapsed(round.startedAt, round.finishedAt);
+    const inputTokens = metricsObj && typeof metricsObj['inputTokens'] === 'number' ? metricsObj['inputTokens'] : null;
+    const outputTokens = metricsObj && typeof metricsObj['outputTokens'] === 'number' ? metricsObj['outputTokens'] : null;
+    const costEstimate = metricsObj && typeof metricsObj['costEstimate'] === 'number' ? metricsObj['costEstimate'] : null;
+    const tokenSummary = inputTokens !== null && outputTokens !== null
+        ? `${formatThousands(inputTokens)} → ${formatThousands(outputTokens)} tok`
+        : '—';
+    const costLabel = costEstimate !== null ? `$${costEstimate.toFixed(4)}` : '—';
+    const vsLabel = 'baseline';
+    const overallRow = buildOverallRow(metricsObj, baselineMetrics, vsLabel);
+    const classRows = buildClassRows(metricsObj, baselineMetrics, vsLabel);
+    return {
+        experimentRef: round.experimentName || `Round ${round.roundIndex}`,
+        experimentStatus: status,
+        samplesDone,
+        samplesTotal,
+        correct,
+        wrong,
+        elapsed,
+        tokenSummary,
+        costLabel,
+        overallRow,
+        classRows,
+        vsPrevLabel: vsLabel,
+    };
+}
+function buildOverallRow(metricsObj, baselineMetricsObj, vsLabel) {
+    if (!metricsObj)
+        return null;
+    const accuracy = typeof metricsObj['accuracy'] === 'number' ? metricsObj['accuracy'] : null;
+    const precision = typeof metricsObj['precision'] === 'number' ? metricsObj['precision'] : null;
+    const recall = typeof metricsObj['recall'] === 'number' ? metricsObj['recall'] : null;
+    if (accuracy === null && precision === null && recall === null)
+        return null;
+    const baselineAccuracy = baselineMetricsObj && typeof baselineMetricsObj['accuracy'] === 'number'
+        ? baselineMetricsObj['accuracy']
+        : null;
+    const baselinePrecision = baselineMetricsObj && typeof baselineMetricsObj['precision'] === 'number'
+        ? baselineMetricsObj['precision']
+        : null;
+    const baselineRecall = baselineMetricsObj && typeof baselineMetricsObj['recall'] === 'number'
+        ? baselineMetricsObj['recall']
+        : null;
+    const accuracyComparison = buildMetricComparison(accuracy, baselineAccuracy, vsLabel);
+    const precisionComparison = buildMetricComparison(precision, baselinePrecision, vsLabel);
+    const recallComparison = buildMetricComparison(recall, baselineRecall, vsLabel);
+    const vsDelta = accuracyComparison?.value ?? null;
+    const vsTone = accuracyComparison?.tone ?? 'neutral';
+    const deltas = compactMetricComparisons({
+        accuracy: accuracyComparison,
+        precision: precisionComparison,
+        recall: recallComparison,
+    });
+    return {
+        accuracy: accuracy ?? 0,
+        precision: precision ?? 0,
+        recall: recall ?? 0,
+        vsLabel,
+        vsDelta,
+        vsTone,
+        ...(deltas ? { deltas } : {}),
+    };
+}
+function buildClassRows(metricsObj, baselineMetricsObj, vsLabel) {
+    if (!metricsObj)
+        return [];
+    const perClass = metricsObj['perClass'];
+    if (!Array.isArray(perClass))
+        return [];
+    const baselinePerClass = baselineMetricsObj && Array.isArray(baselineMetricsObj['perClass']) ? baselineMetricsObj['perClass'] : null;
+    const baselineByLabel = new Map();
+    if (baselinePerClass) {
+        for (const item of baselinePerClass) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const it = item;
+            const label = typeof it['label'] === 'string' ? it['label'] : null;
+            if (!label)
+                continue;
+            baselineByLabel.set(label, {
+                precision: typeof it['precision'] === 'number' ? it['precision'] : null,
+                recall: typeof it['recall'] === 'number' ? it['recall'] : null,
+            });
+        }
+    }
+    const out = [];
+    for (const item of perClass) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const it = item;
+        const label = typeof it['label'] === 'string' ? it['label'] : null;
+        if (!label)
+            continue;
+        const accuracy = typeof it['accuracy'] === 'number' ? it['accuracy'] : null;
+        const precision = typeof it['precision'] === 'number' ? it['precision'] : 0;
+        const recall = typeof it['recall'] === 'number' ? it['recall'] : 0;
+        const f1 = typeof it['f1'] === 'number' ? it['f1'] : null;
+        const fpr = typeof it['fpr'] === 'number' ? it['fpr'] : null;
+        const baselineEntry = baselineByLabel.get(label);
+        const baselinePrecision = baselineEntry?.precision ?? null;
+        const baselineRecall = baselineEntry?.recall ?? null;
+        const precisionComparison = buildMetricComparison(precision, baselinePrecision, vsLabel);
+        const recallComparison = buildMetricComparison(recall, baselineRecall, vsLabel);
+        const vsDelta = precisionComparison?.value ?? null;
+        const vsTone = precisionComparison?.tone ?? 'neutral';
+        const deltas = compactMetricComparisons({
+            precision: precisionComparison,
+            recall: recallComparison,
+        });
+        out.push({
+            label,
+            ...(accuracy !== null ? { accuracy } : {}),
+            precision,
+            recall,
+            ...(f1 !== null ? { f1 } : {}),
+            ...(fpr !== null ? { fpr } : {}),
+            vsLabel,
+            vsDelta,
+            vsTone,
+            ...(deltas ? { deltas } : {}),
+        });
+    }
+    return out;
+}
+function buildMetricComparison(current, baseline, vsLabel, betterIsLower = false) {
+    if (current === null || baseline === null)
+        return undefined;
+    const value = current - baseline;
+    const adjusted = betterIsLower ? -value : value;
+    const tone = adjusted > 0.001 ? 'ok' : adjusted < -0.001 ? 'bad' : 'neutral';
+    return { value, vsLabel, tone, ...(betterIsLower ? { betterIsLower } : {}) };
+}
+function compactMetricComparisons(comparisons) {
+    const entries = Object.entries(comparisons).filter((entry) => entry[1] !== undefined);
+    if (entries.length === 0)
+        return undefined;
+    return Object.fromEntries(entries);
+}
+function formatElapsed(startedAt, finishedAt) {
+    if (!startedAt)
+        return '—';
+    const end = finishedAt ?? new Date();
+    const ms = Math.max(0, end.getTime() - startedAt.getTime());
+    const sec = Math.floor(ms / 1000);
+    if (sec < 60)
+        return `${sec}s`;
+    const min = Math.floor(sec / 60);
+    const remSec = sec % 60;
+    if (min < 60)
+        return remSec > 0 ? `${min}m${remSec}s` : `${min}m`;
+    const hr = Math.floor(min / 60);
+    const remMin = min % 60;
+    return remMin > 0 ? `${hr}h${remMin}m` : `${hr}h`;
+}
+function formatThousands(n) {
+    return n.toLocaleString('en-US');
+}
+function normalizeOptimizationHint(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : null;
+}
+// SPEC 25 §2.1: naming rule for the prompt auto-created in from_dataset_only.
+// `<localized-prefix>-${datasetName}-${YYYY-MM-DDTHH:MM}`; the localized prefix (e.g. the Chinese for "Optimization") is hardcoded inside this function
+function buildOptimizationPromptName(datasetName, now, promptLanguage) {
+    // toISOString outputs `YYYY-MM-DDTHH:MM:SS.sssZ`; truncate at the minute
+    const iso = now.toISOString().slice(0, 16);
+    if (promptLanguage === 'en-US')
+        return `Optimization-${datasetName}-${iso}`;
+    return `优化-${datasetName}-${iso}`;
+}
+// Suffix retry with an 8-char hash on prompts_project_name_unique collision — only possible under heavy concurrent creation in the same second
+// for a secondary collision; 8-char base36 hash gives 36^8 ≈ 2.8e12 of space, which is sufficient.
+function shortHash(value) {
+    let h = 0;
+    for (let i = 0; i < value.length; i++) {
+        h = (h * 31 + value.charCodeAt(i)) >>> 0;
+    }
+    return h.toString(36).padStart(8, '0').slice(0, 8);
+}
+// pg unique_violation error detection: Drizzle / pg packages expose code='23505' and the message contains the constraint name.
+function isPromptNameUniqueViolation(err) {
+    return (0, db_error_1.isUniqueViolation)(err, /idx_prompts_project_name_active|prompts_project_name_unique/);
+}
+function isOptimizationNameUniqueViolation(err) {
+    return (0, db_error_1.isUniqueViolation)(err, /idx_optimization_project_name_active/);
+}
+//# sourceMappingURL=optimization.service.js.map