@f5-sales-demo/xcsh 19.51.2

package/src/autoresearch/state.ts

@@ -0,0 +1,303 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { SessionEntry } from "../session/session-manager";
+import { normalizeAutoresearchList, normalizeContractPathSpec } from "./contract";
+import { cloneNumericMetricMap, DENIED_KEY_NAMES, finiteOrNull, inferMetricUnitFromName, isBetter } from "./helpers";
+import type {
+	ASIData,
+	AutoresearchRuntime,
+	ExperimentResult,
+	ExperimentState,
+	ExperimentStatus,
+	MetricDef,
+	MetricDirection,
+	NumericMetricMap,
+} from "./types";
+
+interface AutoresearchJsonConfigEntry {
+	type: "config";
+	name?: string;
+	metricName?: string;
+	metricUnit?: string;
+	bestDirection?: MetricDirection;
+	benchmarkCommand?: string;
+	secondaryMetrics?: string[];
+	scopePaths?: string[];
+	offLimits?: string[];
+	constraints?: string[];
+}
+interface AutoresearchJsonRunEntry {
+	run?: number;
+	commit?: string;
+	metric?: number;
+	metrics?: NumericMetricMap;
+	status?: ExperimentStatus;
+	description?: string;
+	timestamp?: number;
+	confidence?: number | null;
+	asi?: ASIData;
+}
+type ReconstructedExperimentData = { hasLog: boolean; state: ExperimentState };
+type AutoresearchControlEntryData = { mode: "on" | "off" | "clear"; goal?: string };
+interface ReconstructedControlState {
+	autoresearchMode: boolean;
+	goal: string | null;
+	lastMode: AutoresearchControlEntryData["mode"] | null;
+}
+type RuntimeStore = { clear(sessionKey: string): void; ensure(sessionKey: string): AutoresearchRuntime };
+
+export function createExperimentState(): ExperimentState {
+	return {
+		results: [],
+		bestMetric: null,
+		bestDirection: "lower",
+		metricName: "metric",
+		metricUnit: "",
+		secondaryMetrics: [],
+		name: null,
+		currentSegment: 0,
+		maxExperiments: null,
+		confidence: null,
+		benchmarkCommand: null,
+		scopePaths: [],
+		offLimits: [],
+		constraints: [],
+	};
+}
+export function createSessionRuntime(): AutoresearchRuntime {
+	return {
+		autoresearchMode: false,
+		autoResumeArmed: false,
+		dashboardExpanded: false,
+		lastAutoResumePendingRunNumber: null,
+		lastRunChecks: null,
+		lastRunDuration: null,
+		lastRunAsi: null,
+		lastRunArtifactDir: null,
+		lastRunNumber: null,
+		lastRunSummary: null,
+		runningExperiment: null,
+		state: createExperimentState(),
+		goal: null,
+	};
+}
+export function cloneExperimentState(state: ExperimentState): ExperimentState {
+	return structuredClone(state);
+}
+export function currentResults(results: ExperimentResult[], segment: number): ExperimentResult[] {
+	return results.filter(result => result.segment === segment);
+}
+function findBaselineResult(results: ExperimentResult[], segment: number): ExperimentResult | null {
+	return currentResults(results, segment).find(result => result.status === "keep") ?? null;
+}
+export function findBaselineMetric(results: ExperimentResult[], segment: number): number | null {
+	return findBaselineResult(results, segment)?.metric ?? null;
+}
+export function findBestKeptMetric(
+	results: ExperimentResult[],
+	segment: number,
+	direction: MetricDirection,
+): number | null {
+	let best: number | null = null;
+	for (const result of currentResults(results, segment)) {
+		if (result.status !== "keep") continue;
+		if (best === null || isBetter(result.metric, best, direction)) best = result.metric;
+	}
+	return best;
+}
+export function findBestKeptResult(state: ExperimentState): { index: number; result: ExperimentResult } | null {
+	let best: { index: number; result: ExperimentResult } | null = null;
+	for (let index = 0; index < state.results.length; index += 1) {
+		const result = state.results[index];
+		if (result.segment !== state.currentSegment || result.status !== "keep" || result.metric <= 0) continue;
+		if (!best || isBetter(result.metric, best.result.metric, state.bestDirection)) best = { index, result };
+	}
+	return best;
+}
+export function findBaselineRunNumber(results: ExperimentResult[], segment: number): number | null {
+	const baseline = findBaselineResult(results, segment);
+	return baseline ? (baseline.runNumber ?? results.indexOf(baseline) + 1) : null;
+}
+export function findBaselineSecondary(
+	results: ExperimentResult[],
+	segment: number,
+	knownMetrics: MetricDef[],
+): NumericMetricMap {
+	const baseline = findBaselineResult(results, segment);
+	const values: NumericMetricMap = baseline ? { ...baseline.metrics } : {};
+	const current = currentResults(results, segment);
+	for (const metric of knownMetrics) {
+		if (values[metric.name] !== undefined) continue;
+		const found = current.find(r => r.metrics[metric.name] !== undefined);
+		if (found) values[metric.name] = found.metrics[metric.name];
+	}
+	return values;
+}
+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];
+}
+export function computeConfidence(
+	results: ExperimentResult[],
+	segment: number,
+	direction: MetricDirection,
+): number | null {
+	const current = currentResults(results, segment).filter(result => result.metric > 0);
+	if (current.length < 3) return null;
+
+	const values = current.map(result => result.metric);
+	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;
+
+	const bestKept = findBestKeptMetric(results, segment, direction);
+	if (bestKept === null || bestKept <= 0 || bestKept === baseline) return null;
+
+	return Math.abs(bestKept - baseline) / mad;
+}
+export function reconstructStateFromJsonl(workDir: string): ReconstructedExperimentData {
+	const state = createExperimentState();
+	const jsonlPath = path.join(workDir, "autoresearch.jsonl");
+	if (!fs.existsSync(jsonlPath)) return { hasLog: false, state };
+	const lines = fs.readFileSync(jsonlPath, "utf8").split("\n").filter(Boolean);
+
+	let segment = 0;
+	let sawConfig = false;
+	for (const line of lines) {
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(line) as unknown;
+		} catch {
+			continue;
+		}
+
+		const configEntry = parseConfigEntry(parsed);
+		if (configEntry) {
+			if (sawConfig || state.results.length > 0) segment += 1;
+			sawConfig = true;
+			state.currentSegment = segment;
+			if (configEntry.name) state.name = configEntry.name;
+			if (configEntry.metricName) state.metricName = configEntry.metricName;
+			if (configEntry.metricUnit !== undefined) state.metricUnit = configEntry.metricUnit;
+			if (configEntry.bestDirection) state.bestDirection = configEntry.bestDirection;
+			if (configEntry.benchmarkCommand !== undefined) state.benchmarkCommand = configEntry.benchmarkCommand;
+			state.scopePaths = [...(configEntry.scopePaths ?? [])];
+			state.offLimits = [...(configEntry.offLimits ?? [])];
+			state.constraints = [...(configEntry.constraints ?? [])];
+			state.secondaryMetrics = (configEntry.secondaryMetrics ?? []).map(name => ({
+				name,
+				unit: inferMetricUnitFromName(name),
+			}));
+			continue;
+		}
+
+		if (!isRunEntry(parsed)) continue;
+		const result: ExperimentResult = {
+			runNumber: finiteOrNull(parsed.run),
+			commit: typeof parsed.commit === "string" ? parsed.commit : "",
+			metric: finiteOrNull(parsed.metric) ?? 0,
+			metrics: cloneNumericMetricMap(parsed.metrics) ?? {},
+			status: isExperimentStatus(parsed.status) ? parsed.status : "keep",
+			description: typeof parsed.description === "string" ? parsed.description : "",
+			timestamp: finiteOrNull(parsed.timestamp) ?? 0,
+			segment,
+			confidence: finiteOrNull(parsed.confidence),
+			asi: cloneAsi(parsed.asi),
+		};
+		state.results.push(result);
+		if (segment !== state.currentSegment) continue;
+		registerSecondaryMetrics(state.secondaryMetrics, result.metrics);
+	}
+
+	state.bestMetric = findBaselineMetric(state.results, state.currentSegment);
+	state.confidence = computeConfidence(state.results, state.currentSegment, state.bestDirection);
+	return { hasLog: true, state };
+}
+export function reconstructControlState(entries: SessionEntry[]): ReconstructedControlState {
+	let autoresearchMode = false;
+	let goal: string | null = null;
+	let lastMode: ReconstructedControlState["lastMode"] = null;
+	for (const entry of entries) {
+		if (entry.type !== "custom" || entry.customType !== "autoresearch-control") continue;
+		const data = parseControlEntry(entry.data);
+		if (!data) continue;
+		lastMode = data.mode;
+		autoresearchMode = data.mode === "on";
+		goal = data.goal ?? goal;
+		if (data.mode === "clear") goal = null;
+	}
+	return { autoresearchMode, goal, lastMode };
+}
+export function createRuntimeStore(): RuntimeStore {
+	const runtimes = new Map<string, AutoresearchRuntime>();
+	return {
+		clear(sessionKey: string): void {
+			runtimes.delete(sessionKey);
+		},
+		ensure(sessionKey: string): AutoresearchRuntime {
+			const existing = runtimes.get(sessionKey);
+			if (existing) return existing;
+			const runtime = createSessionRuntime();
+			runtimes.set(sessionKey, runtime);
+			return runtime;
+		},
+	};
+}
+function registerSecondaryMetrics(metrics: MetricDef[], values: NumericMetricMap): void {
+	const known = new Set(metrics.map(m => m.name));
+	for (const name of Object.keys(values)) {
+		if (!known.has(name)) metrics.push({ name, unit: inferMetricUnitFromName(name) });
+	}
+}
+function nonEmpty(v: unknown): v is string {
+	return typeof v === "string" && v.trim().length > 0;
+}
+function parseConfigEntry(value: unknown): AutoresearchJsonConfigEntry | null {
+	if (typeof value !== "object" || value === null || (value as { type?: unknown }).type !== "config") return null;
+	const candidate = value as AutoresearchJsonConfigEntry;
+	const config: AutoresearchJsonConfigEntry = { type: "config" };
+	if (nonEmpty(candidate.name)) config.name = candidate.name;
+	if (nonEmpty(candidate.metricName)) config.metricName = candidate.metricName;
+	if (typeof candidate.metricUnit === "string") config.metricUnit = candidate.metricUnit;
+	if (candidate.bestDirection === "lower" || candidate.bestDirection === "higher")
+		config.bestDirection = candidate.bestDirection;
+	if (nonEmpty(candidate.benchmarkCommand)) config.benchmarkCommand = candidate.benchmarkCommand;
+	config.secondaryMetrics = parseNormalizedStringList(candidate.secondaryMetrics);
+	config.scopePaths = parseNormalizedStringList(candidate.scopePaths, normalizeContractPathSpec);
+	config.offLimits = parseNormalizedStringList(candidate.offLimits, normalizeContractPathSpec);
+	config.constraints = parseNormalizedStringList(candidate.constraints);
+	return config;
+}
+function isRunEntry(value: unknown): value is AutoresearchJsonRunEntry {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value as { type?: unknown };
+	return candidate.type === undefined || candidate.type === "run";
+}
+function isExperimentStatus(value: unknown): value is ExperimentResult["status"] {
+	return value === "keep" || value === "discard" || value === "crash" || value === "checks_failed";
+}
+function parseNormalizedStringList(value: unknown, normalize?: (v: string) => string): string[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const filtered = value.filter((item): item is string => typeof item === "string");
+	return normalizeAutoresearchList(normalize ? filtered.map(normalize) : filtered);
+}
+function cloneAsi(value: unknown): ExperimentResult["asi"] {
+	if (typeof value !== "object" || value === null) return undefined;
+	const clone = structuredClone(value as Record<string, unknown>);
+	for (const key of DENIED_KEY_NAMES) delete clone[key];
+	return clone as ExperimentResult["asi"];
+}
+function parseControlEntry(value: unknown): AutoresearchControlEntryData | null {
+	if (typeof value !== "object" || value === null) return null;
+	const candidate = value as { goal?: unknown; mode?: unknown };
+	if (candidate.mode !== "on" && candidate.mode !== "off" && candidate.mode !== "clear") return null;
+	const data: AutoresearchControlEntryData = { mode: candidate.mode };
+	if (nonEmpty(candidate.goal)) data.goal = candidate.goal;
+	return data;
+}

package/src/autoresearch/tools/init-experiment.ts

@@ -0,0 +1,400 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { StringEnum } from "@f5xc-salesdemos/pi-ai";
+import { type Component, Text } from "@f5xc-salesdemos/pi-tui";
+import { Type } from "@sinclair/typebox";
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { Theme } from "../../modes/theme/theme";
+import { replaceTabs, truncateToWidth } from "../../tools/render-utils";
+import { applyAutoresearchContractToExperimentState } from "../apply-contract-to-state";
+import {
+	contractListsEqual,
+	contractPathListsEqual,
+	loadAutoresearchScriptSnapshot,
+	readAutoresearchContract,
+} from "../contract";
+import {
+	abandonUnloggedAutoresearchRuns,
+	isAutoresearchShCommand,
+	readMaxExperiments,
+	readPendingRunSummary,
+	resolveWorkDir,
+	validateWorkDir,
+} from "../helpers";
+import { cloneExperimentState } from "../state";
+import type { AutoresearchToolFactoryOptions, ExperimentState } from "../types";
+
+const initExperimentSchema = Type.Object({
+	name: Type.String({
+		description: "Human-readable experiment name.",
+	}),
+	from_autoresearch_md: Type.Optional(
+		Type.Boolean({
+			description:
+				"When true, load benchmark command, metrics, scope, off-limits, and constraints from autoresearch.md instead of passing mirrored fields below.",
+		}),
+	),
+	abandon_unlogged_runs: Type.Optional(
+		Type.Boolean({
+			description:
+				"When true, mark all completed but unlogged run artifacts as abandoned so initialization can proceed without logging them first.",
+		}),
+	),
+	new_segment: Type.Optional(
+		Type.Boolean({
+			description:
+				"When true, force a new segment even when the contract fields have not changed. Without this, re-initialization with matching contract is a no-op.",
+		}),
+	),
+	metric_name: Type.Optional(
+		Type.String({
+			description: "Primary metric name shown in the dashboard. Required when from_autoresearch_md is false.",
+		}),
+	),
+	metric_unit: Type.Optional(
+		Type.String({
+			description: "Unit for the primary metric, for example µs, ms, s, kb, or empty.",
+		}),
+	),
+	direction: Type.Optional(
+		StringEnum(["lower", "higher"], {
+			description: "Whether lower or higher values are better. Defaults to lower.",
+		}),
+	),
+	benchmark_command: Type.Optional(
+		Type.String({
+			description: "Benchmark command recorded in autoresearch.md. Required when from_autoresearch_md is false.",
+		}),
+	),
+	scope_paths: Type.Optional(
+		Type.Array(Type.String(), {
+			description: "Files in Scope from autoresearch.md. Required when from_autoresearch_md is false.",
+			minItems: 1,
+		}),
+	),
+	off_limits: Type.Optional(
+		Type.Array(Type.String(), {
+			description: "Off Limits paths from autoresearch.md.",
+		}),
+	),
+	constraints: Type.Optional(
+		Type.Array(Type.String(), {
+			description: "Constraints from autoresearch.md.",
+		}),
+	),
+});
+
+interface InitExperimentDetails {
+	state: ExperimentState;
+}
+
+export function createInitExperimentTool(
+	options: AutoresearchToolFactoryOptions,
+): ToolDefinition<typeof initExperimentSchema, InitExperimentDetails> {
+	return {
+		name: "init_experiment",
+		label: "Init Experiment",
+		description:
+			"Initialize or reset the autoresearch session for the current optimization target before the first logged run of a segment.",
+		parameters: initExperimentSchema,
+		defaultInactive: true,
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const workDirError = validateWorkDir(ctx.cwd);
+			if (workDirError) {
+				return {
+					content: [{ type: "text", text: `Error: ${workDirError}` }],
+				};
+			}
+
+			const runtime = options.getRuntime(ctx);
+			const state = runtime.state;
+			const isReinitializing = state.results.length > 0;
+			const workDir = resolveWorkDir(ctx.cwd);
+			const loggedRunNumbers = collectLoggedRunNumbers(state.results);
+
+			let abandonSummary = "";
+			if (params.abandon_unlogged_runs === true) {
+				const abandoned = await abandonUnloggedAutoresearchRuns(workDir, loggedRunNumbers);
+				if (abandoned > 0) {
+					abandonSummary =
+						abandoned === 1
+							? "Abandoned 1 unlogged run artifact.\n"
+							: `Abandoned ${abandoned} unlogged run artifacts.\n`;
+				}
+			}
+
+			const pendingRun = await readPendingRunSummary(workDir, loggedRunNumbers);
+			if (pendingRun) {
+				const metricInfo = pendingRun.parsedPrimary !== null ? `, metric=${pendingRun.parsedPrimary}` : "";
+				const passedInfo = pendingRun.passed ? "passed" : "failed";
+				return {
+					content: [
+						{
+							type: "text",
+							text:
+								abandonSummary +
+								`Error: run #${pendingRun.runNumber} has not been logged yet.\n` +
+								`Pending: command="${pendingRun.command}"${metricInfo}, ${passedInfo}\n` +
+								"Call log_experiment before re-initializing, or pass abandon_unlogged_runs=true.",
+						},
+					],
+				};
+			}
+
+			const contractResult = readAutoresearchContract(workDir);
+			const scriptSnapshot = loadAutoresearchScriptSnapshot(workDir);
+			const errors = [...contractResult.errors, ...scriptSnapshot.errors];
+			if (errors.length > 0) {
+				return {
+					content: [{ type: "text", text: `${abandonSummary}Error: ${errors.join(" ")}` }],
+				};
+			}
+
+			const benchmarkContract = contractResult.contract.benchmark;
+			const expectedDirection = benchmarkContract.direction ?? "lower";
+			const expectedMetricUnit = benchmarkContract.metricUnit;
+			if (benchmarkContract.command && !isAutoresearchShCommand(benchmarkContract.command)) {
+				return {
+					content: [
+						{
+							type: "text",
+							text:
+								abandonSummary +
+								"Error: Benchmark.command in autoresearch.md must invoke `autoresearch.sh` directly. " +
+								"Move the real workload into `autoresearch.sh` and re-run init_experiment.",
+						},
+					],
+				};
+			}
+
+			const fromMd = params.from_autoresearch_md === true;
+			if (!fromMd) {
+				const metricName = params.metric_name?.trim();
+				const benchmarkCommand = params.benchmark_command?.trim();
+				const scopePaths = params.scope_paths;
+				if (!metricName || !benchmarkCommand || !scopePaths || scopePaths.length === 0) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									"Error: when from_autoresearch_md is false or omitted, metric_name, benchmark_command, and scope_paths are required and must match autoresearch.md. " +
+									"Alternatively pass from_autoresearch_md=true with only name (plus optional flags).",
+							},
+						],
+					};
+				}
+				if (benchmarkContract.command !== benchmarkCommand) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									"Error: benchmark_command does not match autoresearch.md. " +
+									`Expected: ${benchmarkContract.command ?? "(missing)"}\nReceived: ${params.benchmark_command}`,
+							},
+						],
+					};
+				}
+				if (benchmarkContract.primaryMetric !== metricName) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									"Error: metric_name does not match autoresearch.md. " +
+									`Expected: ${benchmarkContract.primaryMetric ?? "(missing)"}\nReceived: ${params.metric_name}`,
+							},
+						],
+					};
+				}
+				if ((params.metric_unit ?? "") !== expectedMetricUnit) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									"Error: metric_unit does not match autoresearch.md. " +
+									`Expected: ${expectedMetricUnit || "(empty)"}\nReceived: ${params.metric_unit ?? "(empty)"}`,
+							},
+						],
+					};
+				}
+				if ((params.direction ?? "lower") !== expectedDirection) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									"Error: direction does not match autoresearch.md. " +
+									`Expected: ${expectedDirection}\nReceived: ${params.direction ?? "lower"}`,
+							},
+						],
+					};
+				}
+				if (!contractPathListsEqual(scopePaths, contractResult.contract.scopePaths)) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									"Error: scope_paths do not match autoresearch.md. " +
+									`Expected: ${contractResult.contract.scopePaths.join(", ")}`,
+							},
+						],
+					};
+				}
+				if (!contractPathListsEqual(params.off_limits ?? [], contractResult.contract.offLimits)) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									"Error: off_limits do not match autoresearch.md. " +
+									`Expected: ${contractResult.contract.offLimits.join(", ") || "(empty)"}`,
+							},
+						],
+					};
+				}
+				if (!contractListsEqual(params.constraints ?? [], contractResult.contract.constraints)) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									"Error: constraints do not match autoresearch.md. " +
+									`Expected: ${contractResult.contract.constraints.join(", ") || "(empty)"}`,
+							},
+						],
+					};
+				}
+			}
+
+			// Check if contract matches current state — if so, re-init is a no-op
+			if (isReinitializing && params.new_segment !== true) {
+				const contract = contractResult.contract;
+				const bm = contract.benchmark;
+				const contractMatches =
+					(bm.primaryMetric ?? "metric") === state.metricName &&
+					bm.metricUnit === state.metricUnit &&
+					(bm.direction ?? "lower") === state.bestDirection &&
+					(bm.command ?? null) === state.benchmarkCommand &&
+					contractPathListsEqual(contract.scopePaths, state.scopePaths) &&
+					contractPathListsEqual(contract.offLimits, state.offLimits) &&
+					contractListsEqual(contract.constraints, state.constraints);
+				if (contractMatches) {
+					runtime.autoresearchMode = true;
+					runtime.autoResumeArmed = true;
+					options.dashboard.updateWidget(ctx, runtime);
+					options.dashboard.requestRender();
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									abandonSummary +
+									`Experiment session already initialized with matching contract. Continuing segment ${state.currentSegment}.`,
+							},
+						],
+						details: { state: cloneExperimentState(state) },
+					};
+				}
+			}
+
+			applyAutoresearchContractToExperimentState(contractResult.contract, state);
+			state.name = params.name;
+			state.maxExperiments = readMaxExperiments(ctx.cwd);
+			state.bestMetric = null;
+			state.confidence = null;
+			if (isReinitializing) {
+				state.currentSegment += 1;
+			}
+
+			const jsonlPath = path.join(workDir, "autoresearch.jsonl");
+			const configLine = JSON.stringify({
+				type: "config",
+				name: state.name,
+				metricName: state.metricName,
+				metricUnit: state.metricUnit,
+				bestDirection: state.bestDirection,
+				benchmarkCommand: state.benchmarkCommand,
+				secondaryMetrics: state.secondaryMetrics.map(metric => metric.name),
+				scopePaths: state.scopePaths,
+				offLimits: state.offLimits,
+				constraints: state.constraints,
+			});
+
+			if (isReinitializing) {
+				fs.appendFileSync(jsonlPath, `${configLine}\n`);
+			} else {
+				fs.writeFileSync(jsonlPath, `${configLine}\n`);
+			}
+
+			runtime.autoresearchMode = true;
+			runtime.autoResumeArmed = true;
+			runtime.lastAutoResumePendingRunNumber = null;
+			runtime.lastRunChecks = null;
+			runtime.lastRunDuration = null;
+			runtime.lastRunAsi = null;
+			runtime.lastRunArtifactDir = null;
+			runtime.lastRunNumber = null;
+			runtime.lastRunSummary = null;
+			options.dashboard.updateWidget(ctx, runtime);
+			options.dashboard.requestRender();
+
+			const lines = [
+				abandonSummary.trimEnd(),
+				`Experiment initialized: ${state.name}`,
+				`Metric: ${state.metricName} (${state.metricUnit || "unitless"}, ${state.bestDirection} is better)`,
+				`Benchmark command: ${state.benchmarkCommand}`,
+				`Working directory: ${workDir}`,
+				`Files in Scope: ${state.scopePaths.join(", ")}`,
+				isReinitializing
+					? "Previous results remain in history. This starts a new segment and requires a fresh baseline."
+					: "Now run the baseline experiment and log it.",
+			].filter(line => line.length > 0);
+			if (state.maxExperiments !== null) {
+				lines.push(`Max iterations: ${state.maxExperiments}`);
+			}
+
+			return {
+				content: [{ type: "text", text: lines.join("\n") }],
+				details: { state: cloneExperimentState(state) },
+			};
+		},
+		renderCall(args, _options, theme): Component {
+			return {
+				render(width: number): string[] {
+					return [renderInitCall(args.name, theme, width)];
+				},
+				invalidate() {},
+			};
+		},
+		renderResult(result): Text {
+			const text = replaceTabs(result.content.find(part => part.type === "text")?.text ?? "");
+			return new Text(text, 0, 0);
+		},
+	};
+}
+
+function renderInitCall(name: string | undefined, theme: Theme, width?: number): string {
+	return `${theme.fg("toolTitle", theme.bold("init_experiment"))} ${theme.fg("contentAccent", truncateToWidth(replaceTabs(name ?? ""), Math.max(20, (width ?? 100) - 20)))}`;
+}
+
+function collectLoggedRunNumbers(results: ExperimentState["results"]): Set<number> {
+	const runNumbers = new Set<number>();
+	for (const result of results) {
+		if (result.runNumber !== null) {
+			runNumbers.add(result.runNumber);
+		}
+	}
+	return runNumbers;
+}