niceeval 0.13.3 → 0.13.4-canary.39

package/dist/experiment/host/operations.cjs

@@ -0,0 +1,678 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.catalog = catalog;
+exports.check = check;
+exports.resolveProjectCurrentTarget = resolveProjectCurrentTarget;
+exports.listInvocationStatus = listInvocationStatus;
+exports.showInvocationStatus = showInvocationStatus;
+exports.planInvocation = planInvocation;
+exports.runInvocation = runInvocation;
+exports.planRename = planRename;
+exports.applyRename = applyRename;
+exports.accept = accept;
+const node_path_1 = require("node:path");
+const effect_1 = require("effect");
+const index_ts_1 = require("../../record/host/index.cjs");
+const root_ts_1 = require("../../record/platform/root.cjs");
+const accept_ts_1 = require("../../runner/accept.cjs");
+const sink_ts_1 = require("../../runner/feedback/sink.cjs");
+const json_ts_1 = require("../../runner/feedback/json.cjs");
+const discover_ts_1 = require("../../runner/discover.cjs");
+const eval_selection_ts_1 = require("../../runner/eval-selection.cjs");
+const fingerprint_ts_1 = require("../../runner/fingerprint.cjs");
+const record_ts_1 = require("../../runner/record.cjs");
+const reuse_readback_ts_1 = require("../../runner/reuse-readback.cjs");
+const run_ts_1 = require("../../runner/run.cjs");
+const lock_ts_1 = require("../../runner/lock.cjs");
+const project_current_ts_1 = require("../../runner/project-current.cjs");
+const json_ts_2 = require("../../runner/reporters/json.cjs");
+const session_ts_1 = require("../../runner/session.cjs");
+const sandbox_selection_ts_1 = require("../../runner/sandbox-selection.cjs");
+const timeout_ts_1 = require("../../runner/timeout.cjs");
+const rename_experiment_ts_1 = require("../../runner/rename-experiment.cjs");
+const aggregate_ts_1 = require("../../shared/aggregate.cjs");
+const types_ts_1 = require("./types.cjs");
+const presentation_ts_1 = require("./presentation.cjs");
+function operationError(operation, cause) {
+    if (cause instanceof types_ts_1.ExperimentHostError)
+        return cause;
+    const code = typeof cause === "object" && cause !== null && typeof Reflect.get(cause, "code") === "string"
+        ? String(Reflect.get(cause, "code"))
+        : "experiment-host-operation-failed";
+    return new types_ts_1.ExperimentHostError({
+        operation,
+        code,
+        message: closedFailureMessage(cause),
+    });
+}
+/** Preserve one actionable message while closing private Runner error shapes. */
+function closedFailureMessage(cause) {
+    if (cause instanceof Error && cause.message.length > 0)
+        return cause.message;
+    if (typeof cause === "object" && cause !== null) {
+        const direct = Reflect.get(cause, "message");
+        if (typeof direct === "string" && direct.length > 0)
+            return direct;
+        const issue = Reflect.get(cause, "issue");
+        if (typeof issue === "object" && issue !== null) {
+            const nested = Reflect.get(issue, "message");
+            if (typeof nested === "string" && nested.length > 0)
+                return nested;
+        }
+    }
+    return String(cause);
+}
+function closeOperation(operation, effect) {
+    return effect.pipe(effect_1.Effect.mapError((cause) => operationError(operation, cause)));
+}
+const invocationPlans = new WeakMap();
+function freezeArray(values) {
+    return Object.freeze([...values]);
+}
+function selectionProblem(input, selected) {
+    if (input.experimentSelector !== undefined && selected.selections.length === 0) {
+        return Object.freeze({
+            status: "experiment-no-match",
+            selector: input.experimentSelector,
+            candidates: freezeArray([...selected.experimentIds].sort()),
+        });
+    }
+    const selectorEvalIds = freezeArray(new Set(selected.selections.flatMap((entry) => entry.selectorEvalIds)));
+    for (const selector of input.evalSelectors ?? []) {
+        if (selectorEvalIds.some((id) => (0, aggregate_ts_1.evalPrefixPredicate)([selector])(id)))
+            continue;
+        return Object.freeze({
+            status: "eval-no-match",
+            selector,
+            experimentIds: freezeArray(selected.selections.map(({ experiment }) => experiment.id)),
+            candidates: freezeArray([...selectorEvalIds].sort()),
+        });
+    }
+    if (selected.selections.every((entry) => entry.selectedEvalIds.length === 0)) {
+        return Object.freeze({
+            status: "empty-selection",
+            experimentIds: freezeArray(selected.selections.map(({ experiment }) => experiment.id)),
+            candidates: freezeArray([...selected.experimentIds].sort()),
+        });
+    }
+    return undefined;
+}
+function closeSelection(input) {
+    return effect_1.Effect.gen(function* () {
+        const discovered = yield* (0, discover_ts_1.discoverEvals)(input.cwd);
+        const evals = input.tag === undefined
+            ? discovered
+            : discovered.filter((definition) => definition.tags?.includes(input.tag));
+        const experiments = yield* (0, discover_ts_1.discoverExperiments)(input.cwd);
+        const experimentIds = freezeArray(experiments.map((experiment) => experiment.id));
+        const selectedIds = input.experimentSelector === undefined
+            ? undefined
+            : new Set((0, aggregate_ts_1.matchExperimentSelector)(experimentIds, input.experimentSelector));
+        const selections = experiments
+            .filter((experiment) => selectedIds === undefined || selectedIds.has(experiment.id))
+            .map((experiment) => {
+            const selection = (0, eval_selection_ts_1.resolveExperimentEvals)({
+                experimentId: experiment.id,
+                selector: experiment.evals,
+                cliPatterns: input.evalSelectors ?? [],
+                evals,
+            });
+            return Object.freeze({
+                experiment,
+                selectedEvalIds: freezeArray(selection.selectedEvalIds),
+                selectorEvalIds: freezeArray(selection.selectorEvals.map((definition) => definition.id)),
+            });
+        });
+        return Object.freeze({
+            evals: freezeArray(evals),
+            experimentIds,
+            selections: freezeArray(selections),
+        });
+    });
+}
+function summaryOfExperiment(experiment, evalIds) {
+    return Object.freeze({
+        id: experiment.id,
+        ...(experiment.description === undefined ? {} : { description: experiment.description }),
+        agent: experiment.agent.name,
+        ...(experiment.model === undefined ? {} : { model: experiment.model }),
+        attempts: experiment.attempts ?? 1,
+        evalIds: freezeArray(evalIds),
+        labels: Object.freeze({ ...(experiment.labels ?? {}) }),
+        hasSetup: typeof experiment.setup === "function",
+        hasTeardown: typeof experiment.teardown === "function",
+        ...(experiment.sharedState === undefined ? {} : { sharedStateKey: experiment.sharedState.key }),
+    });
+}
+function catalog(input) {
+    return closeOperation("catalog", closeSelection(input).pipe(effect_1.Effect.map((selected) => Object.freeze({
+        status: "listed",
+        evals: freezeArray(selected.evals.map((definition) => Object.freeze({
+            id: definition.id,
+            ...(definition.description === undefined ? {} : { description: definition.description }),
+            tags: freezeArray(definition.tags ?? []),
+            evaluationKind: definition.evaluationKind,
+        }))),
+        experimentIds: selected.experimentIds,
+        experiments: freezeArray(selected.selections.map(({ experiment, selectedEvalIds }) => summaryOfExperiment(experiment, selectedEvalIds))),
+    }))));
+}
+function agentRunFromExperiment(experiment, selectedEvalIds, overrides) {
+    return Object.freeze({
+        agent: experiment.agent,
+        model: experiment.model,
+        reasoningEffort: experiment.reasoningEffort,
+        flags: experiment.flags ?? {},
+        plugins: experiment.plugins,
+        attempts: overrides.attempts ?? experiment.attempts ?? 1,
+        earlyExit: overrides.earlyExit ?? experiment.earlyExit ?? false,
+        sandbox: experiment.sandbox,
+        sandboxReuse: experiment.sandboxReuse,
+        ...(experiment.sharedState === undefined ? {} : { sharedState: experiment.sharedState }),
+        judge: experiment.judge,
+        ...(0, timeout_ts_1.resolveRunTimeout)(overrides.timeoutMs, experiment.timeoutMs),
+        budget: overrides.budget ?? experiment.budget,
+        selectedEvalIds: freezeArray(selectedEvalIds),
+        experimentId: experiment.id,
+        experimentBaseDir: experiment.baseDir,
+        experimentSourcePath: experiment.sourcePath,
+        description: experiment.description,
+        labels: experiment.labels,
+        maxConcurrency: experiment.maxConcurrency,
+        setup: experiment.setup,
+        teardown: experiment.teardown,
+        classifyFailure: experiment.classifyFailure,
+    });
+}
+function prepareRuns(input) {
+    return closeSelection(input).pipe(effect_1.Effect.map((selected) => {
+        const problem = selectionProblem(input, selected);
+        if (problem !== undefined)
+            return { status: "problem", selected, problem };
+        const overrides = input.overrides ?? {};
+        return {
+            status: "ready",
+            selected,
+            runs: freezeArray(selected.selections.map(({ experiment, selectedEvalIds }) => agentRunFromExperiment(experiment, selectedEvalIds, overrides))),
+        };
+    }));
+}
+function check(input) {
+    return closeOperation("check", effect_1.Effect.gen(function* () {
+        const prepared = yield* prepareRuns(input);
+        if (prepared.status === "problem")
+            return prepared.problem;
+        const pairs = yield* (0, sandbox_selection_ts_1.linkRunSandboxes)(prepared.selected.evals, prepared.runs);
+        return Object.freeze({
+            status: "linked",
+            experimentIds: freezeArray(prepared.runs.map((run) => run.experimentId)),
+            evalIds: freezeArray(new Set(prepared.runs.flatMap((run) => run.selectedEvalIds))),
+            pairCount: pairs.length,
+        });
+    }));
+}
+/**
+ * Report-facing project-current resolution. Discovery, selection, identity
+ * planning, and the resulting watch set close here so a CLI never reaches
+ * into Runner to reconstruct the same target.
+ */
+function resolveProjectCurrentTarget(input) {
+    return closeOperation("resolve-project-current", effect_1.Effect.gen(function* () {
+        const loaded = yield* (0, project_current_ts_1.loadProjectCurrent)(input.cwd, {
+            config: input.config,
+            ...(input.experimentSelectors === undefined ? {} : { experiments: input.experimentSelectors }),
+            ...(input.freshImport === undefined ? {} : { freshImport: input.freshImport }),
+        });
+        const experimentIds = input.experimentSelectors === undefined
+            ? undefined
+            : freezeArray(new Set(loaded.currentSlots.map((slot) => slot.experimentId)));
+        const selection = Object.freeze({
+            policy: "project-current",
+            currentSlots: loaded.currentSlots,
+            ...(experimentIds === undefined ? {} : { experimentIds }),
+        });
+        return Object.freeze({
+            selection,
+            currentSlots: loaded.currentSlots,
+            watchInputs: freezeArray(loaded.watchInputs),
+        });
+    }));
+}
+/** Session data is intentionally presented as a closed, transient document. */
+function listInvocationStatus(input) {
+    return closeOperation("invocation-status-list", (0, session_ts_1.listSessions)((0, node_path_1.resolve)(input.cwd, ".niceeval"), {
+        ...(input.all === true ? { all: true } : {}),
+        ...(input.experimentSelector === undefined ? {} : { selector: input.experimentSelector }),
+    }));
+}
+function showInvocationStatus(input) {
+    return closeOperation("invocation-status-show", (0, session_ts_1.showSession)((0, node_path_1.resolve)(input.cwd, ".niceeval"), input.invocationSelector));
+}
+function recordRoot(input) {
+    return (0, root_ts_1.makeRecordRoot)((0, node_path_1.resolve)(input.cwd, input.recordRoot ?? ".niceeval/record"));
+}
+/** Only the four explicit mutation/plan entry points may trigger migration. */
+function ensureAutomaticMigration(input) {
+    return effect_1.Effect.gen(function* () {
+        const root = (0, root_ts_1.makeRecordRoot)((0, node_path_1.resolve)(input.cwd, input.recordRoot ?? ".niceeval/record"));
+        if (effect_1.Either.isLeft(root))
+            return yield* effect_1.Effect.fail(root.left);
+        return yield* index_ts_1.recordHost.ensureAutomaticMigration({ root: root.right });
+    });
+}
+function comparisonOf(slot) {
+    return freezeArray(slot.comparisons.map((comparison) => Object.freeze({ ...comparison })));
+}
+function jsonSnapshot(value) {
+    try {
+        return freezeJson(JSON.parse(JSON.stringify(value)));
+    }
+    catch {
+        return undefined;
+    }
+}
+function freezeJson(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(freezeJson));
+    if (typeof value === "object" && value !== null) {
+        return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, freezeJson(entry)])));
+    }
+    return value;
+}
+function dryPlan(slots, readbacks, lockedPairs, evalGroups) {
+    const projected = slots.map((slot) => {
+        const evalGroup = evalGroups.get(slot.evalId);
+        const target = Object.freeze({
+            runId: slot.runId,
+            slotId: slot.slotId,
+            experimentId: slot.experimentId,
+            evalId: slot.evalId,
+            ...(evalGroup === undefined ? {} : { evalGroupId: evalGroup.id, evalGroupIndex: evalGroup.index }),
+            attempt: slot.attempt,
+        });
+        if (slot.state === "reuse") {
+            return Object.freeze({
+                state: "reuse",
+                target,
+                source: Object.freeze({
+                    attemptId: slot.source.attemptId,
+                    originRunId: slot.source.origin.runId,
+                    originSlotId: slot.source.origin.slotId,
+                    sourceRunId: slot.source.sourceBarrier.runId,
+                }),
+                comparisons: comparisonOf(slot),
+            });
+        }
+        return Object.freeze({
+            state: "gap",
+            target,
+            reason: slot.reason,
+            scope: slot.scope,
+            issues: freezeArray(slot.issues.map((issue) => jsonSnapshot(issue) ?? Object.freeze({}))),
+            comparisons: comparisonOf(slot),
+        });
+    });
+    return Object.freeze({
+        policy: Object.freeze({ name: "project-target", version: 1 }),
+        slots: freezeArray(projected),
+        readbacks: freezeArray(readbacks),
+        lockedPairs: freezeArray(lockedPairs),
+    });
+}
+function planInvocation(input) {
+    return closeOperation("invocation-plan", effect_1.Effect.gen(function* () {
+        // Invocation planning is the explicit `exp` / `exp --dry` boundary. Do
+        // not move this to catalog, check, debug, teardown, or session reads: those
+        // operations must remain migration-free observations.
+        const automaticMigration = yield* ensureAutomaticMigration(input);
+        const prepared = yield* prepareRuns(input);
+        if (prepared.status === "problem") {
+            return Object.freeze({ ...prepared.problem, automaticMigration });
+        }
+        const root = recordRoot(input);
+        if (effect_1.Either.isLeft(root))
+            return yield* effect_1.Effect.fail(root.left);
+        const config = Object.freeze({
+            ...input.config,
+            ...(input.config.reporters === undefined
+                ? {}
+                : { reporters: [...input.config.reporters] }),
+        });
+        const overrides = Object.freeze({ ...(input.overrides ?? {}) });
+        const target = yield* (0, fingerprint_ts_1.planProjectTarget)(prepared.selected.evals, prepared.runs, config.timeoutMs, {
+            configJudge: config.judge,
+            ...(overrides.keepSandbox === undefined ? {} : { keepSandbox: overrides.keepSandbox }),
+        });
+        const maxConcurrency = overrides.maxConcurrency
+            ?? config.maxConcurrency
+            ?? (0, sandbox_selection_ts_1.recommendedConcurrencyForPreparedPairs)([...target.preparedPairsByKey.values()]);
+        const maxBuildConcurrency = overrides.maxBuildConcurrency
+            ?? config.maxBuildConcurrency
+            ?? 2;
+        if (!Number.isInteger(maxConcurrency) || maxConcurrency <= 0) {
+            return yield* effect_1.Effect.fail(new Error(`maxConcurrency must be a positive integer, got ${maxConcurrency}.`));
+        }
+        if (!Number.isInteger(maxBuildConcurrency) || maxBuildConcurrency <= 0) {
+            return yield* effect_1.Effect.fail(new Error(`maxBuildConcurrency must be a positive integer, got ${maxBuildConcurrency}.`));
+        }
+        const uniqueEvalIds = new Set(prepared.runs.flatMap((run) => run.selectedEvalIds));
+        const totalAttempts = prepared.runs.reduce((sum, run) => sum + run.selectedEvalIds.length * run.attempts, 0);
+        const experimentConcurrency = Object.freeze(Object.fromEntries(prepared.runs.flatMap((run) => run.experimentId !== undefined && run.maxConcurrency !== undefined
+            ? [[run.experimentId, run.maxConcurrency]]
+            : [])));
+        const shape = Object.freeze({
+            experiments: prepared.runs.length,
+            evals: uniqueEvalIds.size,
+            configurations: prepared.runs.length,
+            totalAttempts,
+            attempts: Math.max(1, ...prepared.runs.map((run) => run.attempts)),
+            maxConcurrency,
+            maxBuildConcurrency,
+            experimentConcurrency,
+        });
+        const reuse = yield* (0, record_ts_1.prepareRunnerRecordReuse)({
+            evals: prepared.selected.evals,
+            runs: prepared.runs,
+            config: { timeoutMs: config.timeoutMs },
+            plannedFingerprints: target.plannedFingerprints,
+            plannedConfigHashes: target.plannedConfigHashes,
+            ...(overrides.rerun === undefined ? {} : { rerun: overrides.rerun }),
+            ...(overrides.keepSandbox === undefined ? {} : { keepSandbox: overrides.keepSandbox }),
+        });
+        const previewStartedAt = input.preview === true ? yield* effect_1.Clock.currentTimeMillis : undefined;
+        const preview = previewStartedAt !== undefined
+            ? yield* effect_1.Effect.scoped((0, record_ts_1.withRunnerCurrentReusePreview)({
+                recordRoot: root.right,
+                startedAt: previewStartedAt,
+                evals: prepared.selected.evals,
+                runs: prepared.runs,
+                reuse,
+                use: ({ reusePlan, readReadbacks }) => effect_1.Effect.gen(function* () {
+                    const readbacks = yield* readReadbacks();
+                    const now = yield* effect_1.Clock.currentTimeMillis;
+                    const pairs = new Map(reusePlan.slots.map((slot) => [
+                        JSON.stringify([slot.experimentId, slot.evalId]),
+                        [slot.experimentId, slot.evalId],
+                    ]));
+                    const locked = yield* effect_1.Effect.all([...pairs].map(([key, [experimentId, evalId]]) => (0, lock_ts_1.readCaseLockEffect)((0, node_path_1.resolve)(input.cwd, input.coordinationRoot ?? ".niceeval"), experimentId, evalId).pipe(effect_1.Effect.catchAll(() => effect_1.Effect.succeed(undefined)), effect_1.Effect.map((record) => record !== undefined && !(0, lock_ts_1.isCaseLockExpired)(record, now) ? key : undefined))), { concurrency: "unbounded" });
+                    return dryPlan(reusePlan.slots, readbacks.map(reuse_readback_ts_1.projectCurrentReuseReadback), locked.filter((key) => key !== undefined), new Map(prepared.selected.evals.flatMap((definition) => definition.evalGroup === undefined
+                        ? []
+                        : [[definition.id, {
+                                    id: definition.evalGroup.id,
+                                    index: definition.evalGroup.evalIds.indexOf(definition.id),
+                                }]])));
+                }),
+            }))
+            : undefined;
+        const plan = Object.freeze({});
+        invocationPlans.set(plan, {
+            evals: prepared.selected.evals,
+            runs: prepared.runs,
+            config,
+            recordRoot: root.right,
+            coordinationRoot: (0, node_path_1.resolve)(input.cwd, input.coordinationRoot ?? ".niceeval"),
+            overrides,
+            shape,
+            consumed: false,
+        });
+        const occurrenceAudits = new Map();
+        for (const pair of target.preparedPairsByKey.values()) {
+            for (const occurrence of pair.plugin.occurrences) {
+                const audit = jsonSnapshot(occurrence.audit);
+                if (audit !== undefined)
+                    occurrenceAudits.set(JSON.stringify(audit), audit);
+            }
+        }
+        return Object.freeze({
+            status: "ready",
+            automaticMigration,
+            plan,
+            shape,
+            experimentIds: freezeArray(prepared.runs.map((run) => run.experimentId)),
+            evalIds: freezeArray(uniqueEvalIds),
+            pluginAudit: Object.freeze({ occurrences: freezeArray(occurrenceAudits.values()) }),
+            ...(preview === undefined ? {} : { dry: preview }),
+        });
+    }));
+}
+function multiplexFeedbackSink(feedback, session, isFeedbackStarted) {
+    const forward = (method, ...args) => {
+        if (!isFeedbackStarted() || feedback === undefined)
+            return;
+        method(feedback, ...args);
+    };
+    return {
+        activity: (detail) => forward((sink, value) => sink.activity(value), detail),
+        diagnostic: (input) => forward((sink, value) => sink.diagnostic(value), input),
+        interrupted: () => forward((sink) => sink.interrupted()),
+        reporterError: (input) => forward((sink, value) => sink.reporterError(value), input),
+        failure: (input) => forward((sink, value) => sink.failure(value), input),
+        budgetExhausted: (input) => forward((sink, value) => sink.budgetExhausted(value), input),
+        kept: (input) => forward((sink, value) => sink.kept(value), input),
+        experimentHook: (input) => {
+            session?.onInvocationEvent({ type: "experiment-hook", ...input });
+            forward((sink, value) => sink.experimentHook(value), input);
+        },
+        precheck: (input) => forward((sink, value) => sink.precheck(value), input),
+        lockWait: (input) => {
+            session?.onInvocationEvent({ type: "lock-wait", ...input });
+            forward((sink, value) => sink.lockWait(value), input);
+        },
+        runActivity: (input) => forward((sink, value) => sink.runActivity(value), input),
+        experimentProgress: (input) => forward((sink, value) => sink.experimentProgress(value), input),
+        lifecycle: (event) => {
+            if (event.type === "attempt:start" || event.type === "attempt:complete" || event.type === "attempt:early-exit") {
+                session?.onInvocationEvent(event);
+            }
+            forward((sink, value) => sink.lifecycle(value), event);
+        },
+    };
+}
+function summaryOf(summary) {
+    return Object.freeze({
+        total: summary.passed + summary.failed + summary.skipped + summary.errored,
+        passed: summary.passed,
+        failed: summary.failed,
+        skipped: summary.skipped,
+        errored: summary.errored,
+        durationMs: summary.durationMs,
+        ...(summary.usage?.inputTokens === undefined ? {} : { inputTokens: summary.usage.inputTokens }),
+        ...(summary.usage?.outputTokens === undefined ? {} : { outputTokens: summary.usage.outputTokens }),
+        ...(summary.estimatedCostUSD === undefined ? {} : { estimatedCostUSD: summary.estimatedCostUSD }),
+    });
+}
+function runInvocation(input) {
+    return effect_1.Effect.scoped(closeOperation("invocation-run", effect_1.Effect.gen(function* () {
+        const state = invocationPlans.get(input.plan);
+        if (state === undefined || state.consumed) {
+            return yield* effect_1.Effect.fail(new Error("Experiment Host invocation plan is forged, copied, or already consumed."));
+        }
+        state.consumed = true;
+        let completedSummary;
+        const reporters = [
+            ...(input.junitPath === undefined ? [] : [{
+                    reporter: (0, json_ts_2.JUnit)(input.junitPath),
+                    name: "junit",
+                    required: true,
+                    target: input.junitPath,
+                }]),
+            ...(state.config.reporters ?? []).map((reporter, index) => ({
+                reporter,
+                name: `config-reporter-${index}`,
+                required: false,
+            })),
+            {
+                name: "experiment-host-summary",
+                required: false,
+                reporter: { onInvocationComplete(summary) { completedSummary = summary; } },
+            },
+        ];
+        // Session indexing is a Host-owned, project-local observation.  Runner only
+        // receives the private tracker mechanism; this enclosing Scope closes its
+        // heartbeat worker on success, typed failure, or interruption.
+        const session = new session_ts_1.SessionTracker(state.coordinationRoot);
+        let sessionClosed = false;
+        let feedbackStarted = false;
+        let feedbackFinished = false;
+        yield* effect_1.Effect.addFinalizer(() => sessionClosed
+            ? effect_1.Effect.void
+            : session.close({ status: "incomplete" }).pipe(effect_1.Effect.ignore));
+        yield* effect_1.Effect.addFinalizer(() => !feedbackStarted || feedbackFinished || input.feedback === undefined
+            ? effect_1.Effect.void
+            : effect_1.Effect.tryPromise({
+                try: () => input.feedback.coordinator.stopDynamic(),
+                catch: () => undefined,
+            }).pipe(effect_1.Effect.ignore));
+        const feedback = input.feedback?.coordinator;
+        const sink = multiplexFeedbackSink(feedback, session, () => feedbackStarted);
+        const receipt = yield* effect_1.Effect.acquireUseRelease(effect_1.Effect.sync(() => (0, sink_ts_1.activateFeedbackSink)(sink)), () => (0, run_ts_1.runEvals)({
+            config: state.config,
+            evals: state.evals,
+            agentRuns: state.runs,
+            reporters,
+            maxConcurrency: state.shape.maxConcurrency,
+            maxBuildConcurrency: state.shape.maxBuildConcurrency,
+            coordinationRoot: state.coordinationRoot,
+            recordRoot: state.recordRoot,
+            ...(state.overrides.keepSandbox === undefined ? {} : { keepSandbox: state.overrides.keepSandbox }),
+            ...(state.overrides.rerun === undefined ? {} : { rerun: state.overrides.rerun }),
+            session,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            onCurrentRecordReusePlan: (current) => effect_1.Effect.sync(() => {
+                if (feedback === undefined)
+                    return;
+                feedback.start({
+                    shape: Object.freeze({
+                        evals: state.shape.evals,
+                        configs: state.shape.configurations,
+                        totalAttempts: state.shape.totalAttempts,
+                        maxConcurrency: state.shape.maxConcurrency,
+                        runIds: current.runIds,
+                    }),
+                    ...(Object.keys(state.shape.experimentConcurrency).length === 0
+                        ? {}
+                        : { experimentConcurrency: state.shape.experimentConcurrency }),
+                    reused: current.reused,
+                    ...(current.reusedFailures.length === 0
+                        ? {}
+                        : { reusedFailures: current.reusedFailures }),
+                });
+                feedbackStarted = true;
+            }),
+        }), (deactivate) => effect_1.Effect.sync(deactivate));
+        const summary = completedSummary;
+        if (summary === undefined) {
+            return yield* effect_1.Effect.fail(new Error("Runner completed without an invocation summary."));
+        }
+        if (feedback !== undefined && !feedbackStarted) {
+            return yield* effect_1.Effect.fail(new Error("Runner completed without starting Experiment feedback."));
+        }
+        const completion = feedback === undefined
+            ? undefined
+            : (0, presentation_ts_1.assembleInvocationCompletion)(feedback.state);
+        yield* session.close({
+            status: completion?.status ?? (receipt.completion === "completed"
+                ? "complete"
+                : receipt.completion === "interrupted"
+                    ? "interrupted"
+                    : "incomplete"),
+            ...(completion === undefined ? {} : { completion }),
+            receipt,
+            ...(receipt.completedAt === undefined ? {} : { completedAt: receipt.completedAt }),
+        });
+        sessionClosed = true;
+        if (feedback !== undefined && completion !== undefined) {
+            yield* effect_1.Effect.tryPromise({
+                try: () => feedback.finish({ summary, completion, receipt }),
+                catch: (cause) => cause,
+            });
+            feedbackFinished = true;
+        }
+        const foldedStats = completion === undefined ? undefined : (0, presentation_ts_1.foldInvocationEvalStats)(summary);
+        return Object.freeze({
+            status: "finished",
+            receipt: Object.freeze({
+                invocationId: receipt.invocationId,
+                runIds: freezeArray(receipt.runIds),
+                startedAt: receipt.startedAt,
+                ...(receipt.completedAt === undefined ? {} : { completedAt: receipt.completedAt }),
+                completion: receipt.completion,
+            }),
+            summary: summaryOf(summary),
+            ...(completion === undefined ? {} : {
+                completion,
+                exitCode: (0, json_ts_1.computeExitCode)({
+                    ...summary,
+                    failed: foldedStats.failed,
+                    errored: foldedStats.errored,
+                }, completion),
+            }),
+        });
+    })));
+}
+function freezeRenamePlan(plan) {
+    return Object.freeze({
+        status: "plan",
+        oldId: plan.oldId,
+        newId: plan.newId,
+        migrations: freezeArray(plan.migrations.map((entry) => Object.freeze({ ...entry }))),
+        excluded: freezeArray(plan.excluded.map((entry) => Object.freeze({ ...entry }))),
+        ...(plan.blocked === undefined ? {} : { blocked: Object.freeze({
+                ...plan.blocked,
+                ...(plan.blocked.conflictingEvals === undefined
+                    ? {}
+                    : { conflictingEvals: freezeArray(plan.blocked.conflictingEvals) }),
+            }) }),
+    });
+}
+function planRename(input) {
+    return closeOperation("rename-plan", ensureAutomaticMigration(input).pipe(effect_1.Effect.zipRight((0, rename_experiment_ts_1.planExperimentRename)(input)), effect_1.Effect.map(freezeRenamePlan)));
+}
+function applyRename(input) {
+    return closeOperation("rename-apply", effect_1.Effect.gen(function* () {
+        yield* ensureAutomaticMigration(input);
+        const outcome = yield* effect_1.Effect.either((0, rename_experiment_ts_1.renameExperiment)(input));
+        if (effect_1.Either.isLeft(outcome)) {
+            if (!(outcome.left instanceof rename_experiment_ts_1.ExperimentRenameError))
+                return yield* effect_1.Effect.fail(outcome.left);
+            return Object.freeze({
+                status: "rejected",
+                oldId: input.oldId,
+                newId: input.newId,
+                reason: outcome.left.reason,
+                ...(outcome.left.plan?.blocked?.evalId === undefined ? {} : { evalId: outcome.left.plan.blocked.evalId }),
+                ...(outcome.left.plan?.blocked?.conflictingEvals === undefined
+                    ? {}
+                    : { conflictingEvals: freezeArray(outcome.left.plan.blocked.conflictingEvals) }),
+                ...(outcome.left.message === "" ? {} : { detail: outcome.left.message }),
+            });
+        }
+        const done = outcome.right;
+        return Object.freeze({
+            status: "done",
+            invocationId: done.invocationId,
+            runId: done.runId,
+            snapshotPath: done.snapshotPath,
+            oldId: done.oldId,
+            newId: done.newId,
+            migrated: freezeArray(done.migrated.map((entry) => Object.freeze({
+                evalId: entry.evalId,
+                sourceLocator: entry.sourceLocator,
+                locator: entry.locator,
+                fingerprint: entry.fingerprint,
+                verdict: entry.verdict,
+            }))),
+        });
+    }));
+}
+function accept(input) {
+    return closeOperation("accept", ensureAutomaticMigration(input).pipe(effect_1.Effect.zipRight((0, accept_ts_1.acceptLocators)(input)), effect_1.Effect.map((receipts) => freezeArray(receipts.map((receipt) => Object.freeze({
+        invocationId: receipt.invocationId,
+        runId: receipt.runId,
+        slotId: receipt.slotId,
+        locator: receipt.locator,
+        sourceLocator: receipt.sourceLocator,
+        fingerprint: receipt.fingerprint,
+    }))))));
+}
+//# sourceMappingURL=operations.cjs.map