@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/autoresearch/runs.ts

@@ -0,0 +1,708 @@
+/**
+ * Durable autoresearch run storage: session-scoped JSONL run records plus
+ * baseline/best-metric math, ported from the deleted extension's
+ * `storage.ts` + `state.ts` without SQLite.
+ *
+ * Everything lives under the session autoresearch root
+ * (`<cwd>/.gjc/_session-{id}/autoresearch/`): `runs.jsonl` holds one JSON
+ * object per run and `experiment.json` holds the metric/session configuration.
+ * The legacy global store (a per-project SQLite DB keyed outside the session)
+ * is intentionally dead — no code path here resolves or writes it.
+ *
+ * Flagged runs MUST be excluded from baseline and best-metric computation;
+ * metric direction (lower-is-better vs higher-is-better) is respected.
+ */
+import * as crypto from "node:crypto";
+import * as path from "node:path";
+import { sessionAutoresearchDir } from "../gjc-runtime/session-layout";
+import { resolveGjcSessionForWrite } from "../gjc-runtime/session-resolution";
+import {
+	appendJsonl,
+	type StateWriterOptions,
+	withWorkflowStateLock,
+	writeTextAtomic,
+} from "../gjc-runtime/state-writer";
+import { dedupeStrings, inferMetricUnitFromName, isBetter, normalizePathSpec } from "./harness";
+import type { ASIData, ExperimentStatus, MetricDef, MetricDirection, NumericMetricMap } from "./types";
+
+export type { ASIData, ExperimentStatus, MetricDirection, NumericMetricMap };
+
+export interface AutoresearchExperimentConfig {
+	name: string;
+	goal: string | null;
+	primaryMetric: string;
+	metricUnit: string;
+	direction: MetricDirection;
+	preferredCommand: string | null;
+	branch: string | null;
+	baselineCommit: string | null;
+	currentSegment: number;
+	maxIterations: number | null;
+	scopePaths: string[];
+	offLimits: string[];
+	constraints: string[];
+	secondaryMetrics: string[];
+	notes: string;
+	createdAt: number;
+	closedAt: number | null;
+}
+
+export interface AutoresearchRunRecord {
+	runId: string;
+	runNumber: number;
+	segment: number;
+	command: string;
+	startedAt: number;
+	completedAt: number | null;
+	durationMs: number | null;
+	exitCode: number | null;
+	timedOut: boolean;
+	status: ExperimentStatus | null;
+	description: string | null;
+	metric: number | null;
+	metrics: NumericMetricMap;
+	asi: ASIData | null;
+	commitHash: string | null;
+	confidence: number | null;
+	preRunDirtyPaths: string[];
+	modifiedPaths: string[];
+	scopeDeviations: string[];
+	justification: string | null;
+	flagged: boolean;
+	flaggedReason: string | null;
+	loggedAt: number | null;
+	abandonedAt: number | null;
+}
+
+export interface AutoresearchRunsPaths {
+	dir: string;
+	runsPath: string;
+	configPath: string;
+}
+
+export function autoresearchRunsPaths(cwd: string, sessionId?: string | null): AutoresearchRunsPaths {
+	const resolvedSessionId =
+		sessionId?.trim() || resolveGjcSessionForWrite(cwd, { envSessionId: process.env.GJC_SESSION_ID }).gjcSessionId;
+	const dir = sessionAutoresearchDir(cwd, resolvedSessionId);
+	return {
+		dir,
+		runsPath: path.join(dir, "runs.jsonl"),
+		configPath: path.join(dir, "experiment.json"),
+	};
+}
+
+function auditFor(
+	cwd: string,
+	sessionId: string,
+	verb: string,
+	category: "state" | "ledger" = "state",
+): StateWriterOptions {
+	return {
+		cwd,
+		audit: {
+			category,
+			verb,
+			owner: "gjc-runtime",
+			skill: "autoresearch",
+			sessionId,
+		},
+	};
+}
+
+const DENIED_KEY_NAMES = new Set(["__proto__", "constructor", "prototype"]);
+
+function sanitizeMetrics(value: unknown): NumericMetricMap {
+	if (typeof value !== "object" || value === null) return {};
+	const out: NumericMetricMap = {};
+	for (const [key, entryValue] of Object.entries(value as Record<string, unknown>)) {
+		if (DENIED_KEY_NAMES.has(key)) continue;
+		if (typeof entryValue === "number" && Number.isFinite(entryValue)) out[key] = entryValue;
+	}
+	return out;
+}
+
+function normalizeRunRecord(value: unknown): AutoresearchRunRecord | null {
+	if (typeof value !== "object" || value === null) return null;
+	const record = value as Record<string, unknown>;
+	if (typeof record.runId !== "string" || record.runId === "") return null;
+	const status = record.status as AutoresearchRunRecord["status"];
+	if (
+		status !== null &&
+		status !== undefined &&
+		status !== "keep" &&
+		status !== "discard" &&
+		status !== "crash" &&
+		status !== "checks_failed"
+	) {
+		return null;
+	}
+	return {
+		runId: record.runId,
+		runNumber: typeof record.runNumber === "number" ? record.runNumber : 0,
+		segment: typeof record.segment === "number" ? record.segment : 0,
+		command: typeof record.command === "string" ? record.command : "",
+		startedAt: typeof record.startedAt === "number" ? record.startedAt : 0,
+		completedAt: typeof record.completedAt === "number" ? record.completedAt : null,
+		durationMs: typeof record.durationMs === "number" ? record.durationMs : null,
+		exitCode: typeof record.exitCode === "number" ? record.exitCode : null,
+		timedOut: record.timedOut === true,
+		status: status ?? null,
+		description: typeof record.description === "string" ? record.description : null,
+		metric: typeof record.metric === "number" && Number.isFinite(record.metric) ? record.metric : null,
+		metrics: sanitizeMetrics(record.metrics),
+		asi: typeof record.asi === "object" && record.asi !== null ? (record.asi as ASIData) : null,
+		commitHash: typeof record.commitHash === "string" ? record.commitHash : null,
+		confidence:
+			typeof record.confidence === "number" && Number.isFinite(record.confidence) ? record.confidence : null,
+		preRunDirtyPaths: toStringArray(record.preRunDirtyPaths),
+		modifiedPaths: toStringArray(record.modifiedPaths),
+		scopeDeviations: toStringArray(record.scopeDeviations),
+		justification: typeof record.justification === "string" ? record.justification : null,
+		flagged: record.flagged === true,
+		flaggedReason: typeof record.flaggedReason === "string" ? record.flaggedReason : null,
+		loggedAt: typeof record.loggedAt === "number" ? record.loggedAt : null,
+		abandonedAt: typeof record.abandonedAt === "number" ? record.abandonedAt : null,
+	};
+}
+
+function toStringArray(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item): item is string => typeof item === "string");
+}
+
+export function createAutoresearchExperimentConfig(input: {
+	name: string;
+	goal?: string | null;
+	primaryMetric: string;
+	metricUnit?: string;
+	direction?: MetricDirection;
+	preferredCommand?: string | null;
+	branch?: string | null;
+	baselineCommit?: string | null;
+	maxIterations?: number | null;
+	scopePaths?: string[];
+	offLimits?: string[];
+	constraints?: string[];
+	secondaryMetrics?: string[];
+	notes?: string;
+	createdAt?: number;
+}): AutoresearchExperimentConfig {
+	return {
+		name: input.name,
+		goal: input.goal ?? null,
+		primaryMetric: input.primaryMetric,
+		metricUnit: input.metricUnit ?? "",
+		direction: input.direction ?? "lower",
+		preferredCommand: input.preferredCommand ?? null,
+		branch: input.branch ?? null,
+		baselineCommit: input.baselineCommit ?? null,
+		currentSegment: 0,
+		maxIterations: input.maxIterations ?? null,
+		scopePaths: dedupeStrings((input.scopePaths ?? []).map(normalizePathSpec)),
+		offLimits: dedupeStrings((input.offLimits ?? []).map(normalizePathSpec)),
+		constraints: dedupeStrings(input.constraints ?? []),
+		secondaryMetrics: dedupeStrings(input.secondaryMetrics ?? []),
+		notes: input.notes ?? "",
+		createdAt: input.createdAt ?? Date.now(),
+		closedAt: null,
+	};
+}
+
+function normalizeExperimentConfig(value: unknown): AutoresearchExperimentConfig | null {
+	if (typeof value !== "object" || value === null) return null;
+	const record = value as Record<string, unknown>;
+	if (typeof record.name !== "string" || record.name === "") return null;
+	const direction: MetricDirection = record.direction === "higher" ? "higher" : "lower";
+	return {
+		name: record.name,
+		goal: typeof record.goal === "string" ? record.goal : null,
+		primaryMetric: typeof record.primaryMetric === "string" ? record.primaryMetric : "metric",
+		metricUnit: typeof record.metricUnit === "string" ? record.metricUnit : "",
+		direction,
+		preferredCommand: typeof record.preferredCommand === "string" ? record.preferredCommand : null,
+		branch: typeof record.branch === "string" ? record.branch : null,
+		baselineCommit: typeof record.baselineCommit === "string" ? record.baselineCommit : null,
+		currentSegment: typeof record.currentSegment === "number" ? record.currentSegment : 0,
+		maxIterations: typeof record.maxIterations === "number" ? record.maxIterations : null,
+		scopePaths: toStringArray(record.scopePaths),
+		offLimits: toStringArray(record.offLimits),
+		constraints: toStringArray(record.constraints),
+		secondaryMetrics: toStringArray(record.secondaryMetrics),
+		notes: typeof record.notes === "string" ? record.notes : "",
+		createdAt: typeof record.createdAt === "number" ? record.createdAt : Date.now(),
+		closedAt: typeof record.closedAt === "number" ? record.closedAt : null,
+	};
+}
+
+/**
+ * Session-scoped JSONL run store. Reads are served from a cached in-memory
+ * snapshot; every mutation routes through the sanctioned `.gjc/**` state-writer
+ * primitives (append for new runs, locked rewrite for updates).
+ */
+export class AutoresearchRunsStore {
+	readonly #paths: AutoresearchRunsPaths;
+	readonly #cwd: string;
+	readonly #sessionId: string;
+	#config: AutoresearchExperimentConfig | null;
+	#runs: AutoresearchRunRecord[];
+
+	private constructor(input: {
+		paths: AutoresearchRunsPaths;
+		cwd: string;
+		sessionId: string;
+		config: AutoresearchExperimentConfig | null;
+		runs: AutoresearchRunRecord[];
+	}) {
+		this.#paths = input.paths;
+		this.#cwd = input.cwd;
+		this.#sessionId = input.sessionId;
+		this.#config = input.config;
+		this.#runs = input.runs;
+	}
+
+	static async open(cwd: string, sessionId?: string | null): Promise<AutoresearchRunsStore> {
+		const resolvedSessionId =
+			sessionId?.trim() || resolveGjcSessionForWrite(cwd, { envSessionId: process.env.GJC_SESSION_ID }).gjcSessionId;
+		const paths = autoresearchRunsPaths(cwd, resolvedSessionId);
+		const config = await readExperimentConfig(paths.configPath);
+		const runs = await readRunRecords(paths.runsPath);
+		return new AutoresearchRunsStore({
+			paths,
+			cwd,
+			sessionId: resolvedSessionId,
+			config,
+			runs,
+		});
+	}
+
+	get paths(): AutoresearchRunsPaths {
+		return this.#paths;
+	}
+
+	get config(): AutoresearchExperimentConfig | null {
+		return this.#config;
+	}
+
+	get runs(): AutoresearchRunRecord[] {
+		return [...this.#runs];
+	}
+
+	/** Persist the experiment configuration (first write creates the file). */
+	async saveConfig(config: AutoresearchExperimentConfig): Promise<void> {
+		await writeTextAtomic(
+			this.#paths.configPath,
+			`${JSON.stringify(config, null, 2)}\n`,
+			auditFor(this.#cwd, this.#sessionId, "write"),
+		);
+		this.#config = config;
+		this.#config = config;
+	}
+
+	/** Seed the in-memory config without persisting (mission-derived defaults). */
+	setInMemoryConfig(config: AutoresearchExperimentConfig): void {
+		this.#config = config;
+	}
+
+	/** Start a run: append its record line and return the created record. */
+	async startRun(input: {
+		segment?: number;
+		command: string;
+		preRunDirtyPaths?: string[];
+		startedAt?: number;
+	}): Promise<AutoresearchRunRecord> {
+		const runNumber = this.#runs.reduce((max, run) => Math.max(max, run.runNumber), 0) + 1;
+		const record: AutoresearchRunRecord = {
+			runId: cryptoRandomId(),
+			runNumber,
+			segment: input.segment ?? this.#config?.currentSegment ?? 0,
+			command: input.command,
+			startedAt: input.startedAt ?? Date.now(),
+			completedAt: null,
+			durationMs: null,
+			exitCode: null,
+			timedOut: false,
+			status: null,
+			description: null,
+			metric: null,
+			metrics: {},
+			asi: null,
+			commitHash: null,
+			confidence: null,
+			preRunDirtyPaths: [...(input.preRunDirtyPaths ?? [])],
+			modifiedPaths: [],
+			scopeDeviations: [],
+			justification: null,
+			flagged: false,
+			flaggedReason: null,
+			loggedAt: null,
+			abandonedAt: null,
+		};
+		await appendJsonl(this.#paths.runsPath, record, auditFor(this.#cwd, this.#sessionId, "run_started", "ledger"));
+		this.#runs.push(record);
+		return { ...record };
+	}
+
+	/** Mark a completed run (exit code, duration, parsed metrics/ASI). */
+	async completeRun(runId: string, patch: Partial<AutoresearchRunRecord>): Promise<AutoresearchRunRecord> {
+		return this.#updateRun(runId, current => ({
+			...current,
+			...patch,
+			completedAt: patch.completedAt ?? Date.now(),
+		}));
+	}
+
+	/** Log a run: final status, description, metric, ASI, paths, confidence. */
+	async logRun(runId: string, patch: Partial<AutoresearchRunRecord>): Promise<AutoresearchRunRecord> {
+		return this.#updateRun(runId, current => ({
+			...current,
+			...patch,
+			status: patch.status ?? null,
+			loggedAt: patch.loggedAt ?? Date.now(),
+		}));
+	}
+
+	/** Flag a run as suspect; flagged runs are excluded from baseline/best math. */
+	async flagRun(runId: string, reason: string): Promise<AutoresearchRunRecord> {
+		return this.#updateRun(runId, current => ({
+			...current,
+			flagged: true,
+			flaggedReason: reason,
+		}));
+	}
+
+	async updateRunConfidence(runId: string, confidence: number | null): Promise<AutoresearchRunRecord> {
+		return this.#updateRun(runId, current => ({ ...current, confidence }));
+	}
+
+	/** Abandon every pending run; returns how many were abandoned. */
+	async abandonPendingRuns(): Promise<number> {
+		const pending = this.#runs.filter(run => run.status === null && run.abandonedAt === null);
+		if (pending.length === 0) return 0;
+		await this.#rewrite(runs => {
+			for (const run of runs) {
+				if (run.status === null && run.abandonedAt === null) {
+					run.abandonedAt = Date.now();
+				}
+			}
+		});
+		return pending.length;
+	}
+
+	/** Most recent pending (started, unlogged, unabandoned) run, or null. */
+	getPendingRun(): AutoresearchRunRecord | null {
+		for (let index = this.#runs.length - 1; index >= 0; index -= 1) {
+			const run = this.#runs[index];
+			if (run.status === null && run.abandonedAt === null) return { ...run };
+		}
+		return null;
+	}
+
+	listRuns(): AutoresearchRunRecord[] {
+		return this.#runs.map(run => ({ ...run }));
+	}
+
+	listLoggedRuns(): AutoresearchRunRecord[] {
+		return this.#runs.filter(run => run.status !== null).map(run => ({ ...run }));
+	}
+
+	async #updateRun(
+		runId: string,
+		mutate: (current: AutoresearchRunRecord) => AutoresearchRunRecord,
+	): Promise<AutoresearchRunRecord> {
+		let updated: AutoresearchRunRecord | null = null;
+		await this.#rewrite(runs => {
+			for (const run of runs) {
+				if (run.runId === runId) {
+					const next = mutate(run);
+					Object.assign(run, next);
+					updated = { ...next };
+					break;
+				}
+			}
+		});
+		if (updated === null) {
+			throw new Error(`Autoresearch run ${runId} not found`);
+		}
+		return updated;
+	}
+
+	/** Locked read-modify-write of runs.jsonl; refreshes the in-memory snapshot. */
+	async #rewrite(mutate: (runs: AutoresearchRunRecord[]) => void): Promise<void> {
+		await withWorkflowStateLock(
+			this.#paths.runsPath,
+			async () => {
+				const runs = await readRunRecords(this.#paths.runsPath);
+				mutate(runs);
+				const text = runs.map(run => JSON.stringify(run)).join("\n");
+				await writeTextAtomic(
+					this.#paths.runsPath,
+					text.length > 0 ? `${text}\n` : "",
+					auditFor(this.#cwd, this.#sessionId, "run_updated", "ledger"),
+				);
+				this.#runs = runs.map(run => ({ ...run }));
+			},
+			{ cwd: this.#cwd },
+		);
+	}
+}
+
+function cryptoRandomId(): string {
+	return crypto.randomUUID();
+}
+
+async function readRunRecords(runsPath: string): Promise<AutoresearchRunRecord[]> {
+	const records: AutoresearchRunRecord[] = [];
+	try {
+		const raw = await Bun.file(runsPath).text();
+		for (const line of raw.split(/\r?\n/)) {
+			const trimmed = line.trim();
+			if (trimmed.length === 0) continue;
+			const record = normalizeRunRecord(JSON.parse(trimmed) as unknown);
+			if (record) records.push(record);
+		}
+	} catch (error) {
+		if (isEnoent(error)) return [];
+		throw error;
+	}
+	return records;
+}
+
+async function readExperimentConfig(configPath: string): Promise<AutoresearchExperimentConfig | null> {
+	try {
+		return normalizeExperimentConfig(await Bun.file(configPath).json());
+	} catch (error) {
+		if (isEnoent(error)) return null;
+		throw error;
+	}
+}
+
+function isEnoent(error: unknown): boolean {
+	return (
+		typeof error === "object" && error !== null && "code" in error && (error as { code?: unknown }).code === "ENOENT"
+	);
+}
+
+// ---------------------------------------------------------------------------
+// Baseline / best-metric math (ported from the extension's state.ts)
+// ---------------------------------------------------------------------------
+
+/**
+ * Minimal structural shape the math operates on; both persisted run records
+ * and rebuilt experiment results satisfy it.
+ */
+export interface BaselineCandidate {
+	segment: number;
+	status: ExperimentStatus | null;
+	metric: number | null;
+	metrics: NumericMetricMap;
+	flagged: boolean;
+	runNumber: number;
+}
+
+export function currentResults(results: readonly BaselineCandidate[], segment: number): BaselineCandidate[] {
+	return results.filter(result => result.segment === segment);
+}
+
+/** First kept, unflagged run in the segment — the baseline. */
+export function findBaselineResult(results: readonly BaselineCandidate[], segment: number): BaselineCandidate | null {
+	return currentResults(results, segment).find(result => result.status === "keep" && !result.flagged) ?? null;
+}
+
+export function findBaselineMetric(results: readonly BaselineCandidate[], segment: number): number | null {
+	const baseline = findBaselineResult(results, segment);
+	return baseline && baseline.metric !== null ? baseline.metric : null;
+}
+
+/** Best kept, unflagged metric in the segment, honoring direction. */
+export function findBestKeptMetric(
+	results: readonly BaselineCandidate[],
+	segment: number,
+	direction: MetricDirection,
+): number | null {
+	let best: number | null = null;
+	for (const result of currentResults(results, segment)) {
+		if (result.status !== "keep" || result.flagged || result.metric === null) continue;
+		if (best === null || isBetter(result.metric, best, direction)) {
+			best = result.metric;
+		}
+	}
+	return best;
+}
+
+export function findBaselineRunNumber(results: readonly BaselineCandidate[], segment: number): number | null {
+	const baseline = findBaselineResult(results, segment);
+	return baseline ? baseline.runNumber : null;
+}
+
+/** Baseline secondary-metric values, filling gaps from other unflagged runs. */
+export function findBaselineSecondary(
+	results: readonly BaselineCandidate[],
+	segment: number,
+	knownMetrics: MetricDef[],
+): NumericMetricMap {
+	const baseline = findBaselineResult(results, segment);
+	const values: NumericMetricMap = baseline ? { ...baseline.metrics } : {};
+	for (const metric of knownMetrics) {
+		if (values[metric.name] !== undefined) continue;
+		for (const result of currentResults(results, segment)) {
+			if (result.flagged) continue;
+			const value = result.metrics[metric.name];
+			if (value !== undefined) {
+				values[metric.name] = value;
+				break;
+			}
+		}
+	}
+	return values;
+}
+
+export function sortedMedian(values: number[]): number {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((left, right) => left - right);
+	const midpoint = Math.floor(sorted.length / 2);
+	if (sorted.length % 2 === 0) {
+		return (sorted[midpoint - 1]! + sorted[midpoint]!) / 2;
+	}
+	return sorted[midpoint]!;
+}
+
+/**
+ * Confidence score: how many multiples of the observed noise floor (median
+ * absolute deviation) separate the best kept metric from the baseline. Null
+ * when there are too few runs, no baseline, or no measurable spread.
+ */
+export function computeConfidence(
+	results: readonly BaselineCandidate[],
+	segment: number,
+	direction: MetricDirection,
+): number | null {
+	const current = currentResults(results, segment).filter(
+		result => !result.flagged && result.metric !== null && result.metric > 0,
+	);
+	if (current.length < 3) return null;
+
+	const values = current.map(result => result.metric as number);
+	const median = sortedMedian(values);
+	const mad = sortedMedian(values.map(value => Math.abs(value - median)));
+	if (mad === 0) return null;
+
+	const baseline = findBaselineMetric(results, segment);
+	if (baseline === null) return null;
+
+	let bestKept: number | null = null;
+	for (const result of current) {
+		if (result.status !== "keep" || (result.metric ?? 0) <= 0) continue;
+		if (bestKept === null || isBetter(result.metric as number, bestKept, direction)) {
+			bestKept = result.metric as number;
+		}
+	}
+	if (bestKept === null || bestKept === baseline) return null;
+
+	return Math.abs(bestKept - baseline) / mad;
+}
+
+export interface AutoresearchExperimentResult {
+	runNumber: number;
+	commit: string;
+	metric: number | null;
+	metrics: NumericMetricMap;
+	status: ExperimentStatus;
+	description: string;
+	timestamp: number;
+	segment: number;
+	confidence: number | null;
+	asi?: ASIData;
+	modifiedPaths: string[];
+	scopeDeviations: string[];
+	justification: string | null;
+	flagged: boolean;
+	flaggedReason: string | null;
+}
+
+export interface AutoresearchExperimentState {
+	results: AutoresearchExperimentResult[];
+	bestMetric: number | null;
+	bestDirection: MetricDirection;
+	metricName: string;
+	metricUnit: string;
+	secondaryMetrics: MetricDef[];
+	name: string | null;
+	goal: string | null;
+	currentSegment: number;
+	maxExperiments: number | null;
+	confidence: number | null;
+	scopePaths: string[];
+	offLimits: string[];
+	constraints: string[];
+	notes: string;
+	branch: string | null;
+	baselineCommit: string | null;
+}
+
+/** Rebuild the experiment state view from the persisted config + logged runs. */
+export function buildAutoresearchExperimentState(
+	config: AutoresearchExperimentConfig,
+	loggedRuns: AutoresearchRunRecord[],
+): AutoresearchExperimentState {
+	const secondaryMetrics: MetricDef[] = config.secondaryMetrics.map(name => ({
+		name,
+		unit: inferMetricUnitFromName(name),
+	}));
+	const results: AutoresearchExperimentResult[] = [];
+	for (const run of loggedRuns) {
+		if (run.status === null) continue;
+		const result: AutoresearchExperimentResult = {
+			runNumber: run.runNumber,
+			commit: run.commitHash ?? "",
+			metric: run.metric,
+			metrics: { ...run.metrics },
+			status: run.status,
+			description: run.description ?? "",
+			timestamp: run.loggedAt ?? run.startedAt,
+			segment: run.segment,
+			confidence: run.confidence,
+			asi: run.asi ?? undefined,
+			modifiedPaths: [...run.modifiedPaths],
+			scopeDeviations: [...run.scopeDeviations],
+			justification: run.justification,
+			flagged: run.flagged,
+			flaggedReason: run.flaggedReason,
+		};
+		results.push(result);
+		if (run.segment === config.currentSegment) {
+			registerSecondaryMetrics(secondaryMetrics, run.metrics);
+		}
+	}
+
+	const bestMetric = findBaselineMetric(results, config.currentSegment);
+	const confidence = computeConfidence(results, config.currentSegment, config.direction);
+	return {
+		results,
+		bestMetric,
+		bestDirection: config.direction,
+		metricName: config.primaryMetric,
+		metricUnit: config.metricUnit,
+		secondaryMetrics,
+		name: config.name,
+		goal: config.goal,
+		currentSegment: config.currentSegment,
+		maxExperiments: config.maxIterations,
+		confidence,
+		scopePaths: [...config.scopePaths],
+		offLimits: [...config.offLimits],
+		constraints: [...config.constraints],
+		notes: config.notes,
+		branch: config.branch,
+		baselineCommit: config.baselineCommit,
+	};
+}
+
+function registerSecondaryMetrics(metrics: MetricDef[], values: NumericMetricMap): void {
+	for (const name of Object.keys(values)) {
+		if (metrics.some(metric => metric.name === name)) continue;
+		metrics.push({
+			name,
+			unit: inferMetricUnitFromName(name),
+		});
+	}
+}