@f5-sales-demo/xcsh 19.51.2

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

@@ -0,0 +1,793 @@
+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 { logger } from "@f5xc-salesdemos/pi-utils";
+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 * as git from "../../utils/git";
+import { applyAutoresearchContractToExperimentState } from "../apply-contract-to-state";
+import { loadAutoresearchScriptSnapshot, pathMatchesContractPath, readAutoresearchContract } from "../contract";
+import { computeRunModifiedPaths, getCurrentAutoresearchBranch, parseWorkDirDirtyPathsWithStatus } from "../git";
+import {
+	formatNum,
+	inferMetricUnitFromName,
+	isAutoresearchCommittableFile,
+	isAutoresearchLocalStatePath,
+	isAutoresearchShCommand,
+	isBetter,
+	mergeAsi,
+	readPendingRunSummary,
+	resolveWorkDir,
+	validateWorkDir,
+} from "../helpers";
+import {
+	cloneExperimentState,
+	computeConfidence,
+	currentResults,
+	findBaselineMetric,
+	findBaselineSecondary,
+	findBestKeptMetric,
+} from "../state";
+import type {
+	ASIData,
+	AutoresearchToolFactoryOptions,
+	ExperimentResult,
+	ExperimentState,
+	LogDetails,
+	NumericMetricMap,
+} from "../types";
+
+const EXPERIMENT_TOOL_NAMES = ["init_experiment", "run_experiment", "log_experiment"];
+
+const logExperimentSchema = Type.Object({
+	commit: Type.String({
+		description: "Current git commit hash or placeholder.",
+	}),
+	metric: Type.Number({
+		description: "Primary metric value for this run.",
+	}),
+	status: StringEnum(["keep", "discard", "crash", "checks_failed"], {
+		description: "Outcome for this run.",
+	}),
+	description: Type.String({
+		description: "Short description of the experiment.",
+	}),
+	metrics: Type.Optional(
+		Type.Record(Type.String(), Type.Number(), {
+			description: "Secondary metrics for this run.",
+		}),
+	),
+	force: Type.Optional(
+		Type.Boolean({
+			description:
+				"When true: skip ASI field requirements and allow keeping a run whose primary metric regressed versus the best kept run.",
+		}),
+	),
+	skip_restore: Type.Optional(
+		Type.Boolean({
+			description:
+				"When true and status is discard/crash/checks_failed: skip reverting the working tree to HEAD. Useful when the experiment did not modify tracked files or you want to preserve the current state.",
+		}),
+	),
+	asi: Type.Optional(
+		Type.Record(Type.String(), Type.Unknown(), {
+			description: "Actionable side information captured for this run.",
+		}),
+	),
+});
+
+interface KeepCommitResult {
+	error?: string;
+	note?: string;
+}
+
+export function createLogExperimentTool(
+	options: AutoresearchToolFactoryOptions,
+): ToolDefinition<typeof logExperimentSchema, LogDetails> {
+	return {
+		name: "log_experiment",
+		label: "Log Experiment",
+		description:
+			"Log the experiment result, update dashboard state, persist JSONL history, and apply git keep or revert behavior.",
+		parameters: logExperimentSchema,
+		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 workDir = resolveWorkDir(ctx.cwd);
+
+			const contractResult = readAutoresearchContract(workDir);
+			const scriptSnapshot = loadAutoresearchScriptSnapshot(workDir);
+			const contractErrors = [...contractResult.errors, ...scriptSnapshot.errors];
+			if (contractErrors.length > 0) {
+				return {
+					content: [{ type: "text", text: `Error: ${contractErrors.join(" ")}` }],
+				};
+			}
+			const benchmarkForSync = contractResult.contract.benchmark;
+			if (benchmarkForSync.command && !isAutoresearchShCommand(benchmarkForSync.command)) {
+				return {
+					content: [
+						{
+							type: "text",
+							text:
+								"Error: Benchmark.command in autoresearch.md must invoke `autoresearch.sh` directly before logging. " +
+								"Fix autoresearch.md or move the workload into autoresearch.sh.",
+						},
+					],
+				};
+			}
+
+			const pendingRun =
+				runtime.lastRunSummary ?? (await readPendingRunSummary(workDir, collectLoggedRunNumbers(state.results)));
+			if (!pendingRun) {
+				return {
+					content: [{ type: "text", text: "Error: no unlogged run is available. Run run_experiment first." }],
+				};
+			}
+
+			applyAutoresearchContractToExperimentState(contractResult.contract, state);
+			const logPreamble =
+				"Refreshed session fields from autoresearch.md before logging (benchmark, scope, constraints).\n\n";
+			runtime.lastRunSummary = pendingRun;
+			runtime.lastRunAsi = pendingRun.parsedAsi;
+			runtime.lastRunChecks =
+				pendingRun.checksPass === null
+					? null
+					: {
+							pass: pendingRun.checksPass,
+							output: "",
+							duration: pendingRun.checksDurationSeconds ?? 0,
+						};
+			runtime.lastRunDuration = pendingRun.durationSeconds;
+
+			if (pendingRun.parsedPrimary !== null && params.metric !== pendingRun.parsedPrimary) {
+				return {
+					content: [
+						{
+							type: "text",
+							text:
+								"Error: metric does not match the parsed primary metric from the pending run.\n" +
+								`Expected: ${pendingRun.parsedPrimary}\nReceived: ${params.metric}`,
+						},
+					],
+				};
+			}
+
+			if (params.status === "keep" && !pendingRun.passed) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "Error: cannot keep this run because the pending benchmark did not pass. Log it as crash or checks_failed instead.",
+						},
+					],
+				};
+			}
+
+			if (params.status === "keep" && runtime.lastRunChecks && !runtime.lastRunChecks.pass) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "Error: cannot keep this run because autoresearch.checks.sh failed. Log it as checks_failed instead.",
+						},
+					],
+				};
+			}
+
+			const observedStatusError = validateObservedStatus(params.status, pendingRun);
+			if (observedStatusError) {
+				return {
+					content: [{ type: "text", text: `Error: ${observedStatusError}` }],
+				};
+			}
+
+			const forceLoose = params.force === true;
+			const secondaryMetrics = buildSecondaryMetrics(params.metrics, pendingRun.parsedMetrics, state.metricName);
+
+			const mergedAsi = mergeAsi(runtime.lastRunAsi, sanitizeAsi(params.asi));
+			if (!forceLoose) {
+				const asiValidationError = validateAsiRequirements(mergedAsi, params.status);
+				if (asiValidationError) {
+					return {
+						content: [{ type: "text", text: `Error: ${asiValidationError}` }],
+					};
+				}
+			}
+
+			const preRunDirtyPaths = pendingRun.preRunDirtyPaths;
+			let keepScopeValidation: { committablePaths: string[] } | undefined;
+			if (params.status === "keep") {
+				const scopeValidation = await validateKeepPaths(options, workDir, state);
+				if (typeof scopeValidation === "string") {
+					return {
+						content: [{ type: "text", text: `Error: ${scopeValidation}` }],
+					};
+				}
+				const currentBestMetric = findBestKeptMetric(state.results, state.currentSegment, state.bestDirection);
+				if (
+					!forceLoose &&
+					currentBestMetric !== null &&
+					params.metric !== currentBestMetric &&
+					!isBetter(params.metric, currentBestMetric, state.bestDirection)
+				) {
+					return {
+						content: [
+							{
+								type: "text",
+								text:
+									"Error: cannot keep this run because the primary metric regressed.\n" +
+									`Current best: ${currentBestMetric}\nReceived: ${params.metric}`,
+							},
+						],
+					};
+				}
+				keepScopeValidation = scopeValidation;
+			}
+
+			const experiment: ExperimentResult = {
+				runNumber: runtime.lastRunNumber ?? pendingRun.runNumber,
+				commit: params.commit.slice(0, 7),
+				metric: params.metric,
+				metrics: secondaryMetrics,
+				status: params.status,
+				description: params.description,
+				timestamp: Date.now(),
+				segment: state.currentSegment,
+				confidence: null,
+				asi: mergedAsi,
+			};
+
+			const activeBranch = await getCurrentAutoresearchBranch(options.pi, workDir);
+			if (!activeBranch) {
+				return {
+					content: [
+						{
+							type: "text",
+							text:
+								"Error: autoresearch keep/discard actions require an active `autoresearch/...` branch. " +
+								"Run `/autoresearch` again to restore the protected branch before logging this run.",
+						},
+					],
+				};
+			}
+
+			let gitNote: string | null = null;
+			if (params.status === "keep") {
+				const commitResult = await commitKeptExperiment(options, workDir, state, experiment, keepScopeValidation);
+				if (commitResult.error) {
+					return {
+						content: [{ type: "text", text: `Error: ${commitResult.error}` }],
+					};
+				}
+				gitNote = commitResult.note ?? null;
+			} else if (!params.skip_restore) {
+				const revertResult = await revertFailedExperiment(options, workDir, preRunDirtyPaths);
+				if (revertResult.error) {
+					return {
+						content: [{ type: "text", text: `Error: ${revertResult.error}` }],
+					};
+				}
+				gitNote = revertResult.note ?? null;
+			}
+
+			const previousState = cloneExperimentState(state);
+			state.results.push(experiment);
+			registerSecondaryMetrics(state, secondaryMetrics);
+			state.bestMetric = findBaselineMetric(state.results, state.currentSegment);
+			state.confidence = computeConfidence(state.results, state.currentSegment, state.bestDirection);
+			experiment.confidence = state.confidence;
+
+			const wallClockSeconds = runtime.lastRunDuration;
+			try {
+				persistRun(workDir, experiment);
+			} catch (error) {
+				runtime.state = previousState;
+				options.dashboard.updateWidget(ctx, runtime);
+				options.dashboard.requestRender();
+				throw error;
+			}
+			try {
+				await updateRunMetadata(runtime.lastRunArtifactDir ?? pendingRun.runDirectory, {
+					commit: experiment.commit,
+					confidence: experiment.confidence,
+					description: experiment.description,
+					gitNote,
+					loggedAt: new Date(experiment.timestamp).toISOString(),
+					loggedAsi: experiment.asi,
+					loggedMetric: experiment.metric,
+					loggedMetrics: experiment.metrics,
+					runNumber: runtime.lastRunNumber ?? pendingRun.runNumber,
+					status: experiment.status,
+					wallClockSeconds,
+				});
+			} catch (error) {
+				logger.warn("Failed to update autoresearch run metadata after persisting JSONL history", {
+					error: error instanceof Error ? error.message : String(error),
+					runDirectory: runtime.lastRunArtifactDir ?? pendingRun.runDirectory,
+					runNumber: runtime.lastRunNumber ?? pendingRun.runNumber,
+				});
+			}
+
+			runtime.runningExperiment = null;
+			runtime.lastRunChecks = null;
+			runtime.lastRunDuration = null;
+			runtime.lastRunAsi = null;
+			runtime.lastRunArtifactDir = null;
+			runtime.lastRunNumber = null;
+			runtime.lastRunSummary = null;
+			runtime.autoResumeArmed = true;
+			runtime.lastAutoResumePendingRunNumber = null;
+
+			const currentSegmentRuns = currentResults(state.results, state.currentSegment).length;
+			const text = logPreamble + buildLogText(state, experiment, currentSegmentRuns, wallClockSeconds, gitNote);
+			if (state.maxExperiments !== null && currentSegmentRuns >= state.maxExperiments) {
+				runtime.autoresearchMode = false;
+				options.pi.appendEntry(
+					"autoresearch-control",
+					runtime.goal ? { mode: "off", goal: runtime.goal } : { mode: "off" },
+				);
+				await options.pi.setActiveTools(
+					options.pi.getActiveTools().filter(name => !EXPERIMENT_TOOL_NAMES.includes(name)),
+				);
+			}
+			options.dashboard.updateWidget(ctx, runtime);
+			options.dashboard.requestRender();
+
+			return {
+				content: [{ type: "text", text }],
+				details: {
+					experiment: {
+						...experiment,
+						metrics: { ...experiment.metrics },
+						asi: experiment.asi ? structuredClone(experiment.asi) : undefined,
+					},
+					state: cloneExperimentState(state),
+					wallClockSeconds,
+				},
+			};
+		},
+		renderCall(args, _options, theme): Component {
+			const color = args.status === "keep" ? "success" : args.status === "discard" ? "warning" : "error";
+			return {
+				render(width: number): string[] {
+					const description = truncateToWidth(replaceTabs(args.description ?? ""), Math.max(20, width - 30));
+					return [
+						`${theme.fg("toolTitle", theme.bold("log_experiment"))} ${theme.fg(color, args.status)} ${theme.fg("muted", description)}`,
+					];
+				},
+				invalidate() {},
+			};
+		},
+		renderResult(result, _options, theme): Component {
+			const details = result.details;
+			if (!isLogDetails(details)) {
+				return new Text(replaceTabs(result.content.find(part => part.type === "text")?.text ?? ""), 0, 0);
+			}
+			return {
+				render(width: number): string[] {
+					return [renderSummary(details, theme, width)];
+				},
+				invalidate() {},
+			};
+		},
+	};
+}
+
+function cloneMetrics(value: NumericMetricMap | undefined): NumericMetricMap {
+	return value ? { ...value } : {};
+}
+
+function buildSecondaryMetrics(
+	overrides: NumericMetricMap | undefined,
+	parsedMetrics: NumericMetricMap | null,
+	primaryMetricName: string,
+): NumericMetricMap {
+	const merged: NumericMetricMap = {};
+	for (const [name, value] of Object.entries(parsedMetrics ?? {})) {
+		if (name === "__proto__" || name === "constructor" || name === "prototype") continue;
+		if (name === primaryMetricName) continue;
+		merged[name] = value;
+	}
+	for (const [name, value] of Object.entries(cloneMetrics(overrides))) {
+		if (name === "__proto__" || name === "constructor" || name === "prototype") continue;
+		merged[name] = value;
+	}
+	return merged;
+}
+
+function sanitizeAsi(value: { [key: string]: unknown } | undefined): ASIData | undefined {
+	if (!value) return undefined;
+	const result: ASIData = {};
+	for (const [key, entryValue] of Object.entries(value)) {
+		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+		const sanitized = sanitizeAsiValue(entryValue);
+		if (sanitized !== undefined) {
+			result[key] = sanitized;
+		}
+	}
+	return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function sanitizeAsiValue(value: unknown): ASIData[string] | undefined {
+	if (value === null) return null;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) {
+		const items = value
+			.map(item => sanitizeAsiValue(item))
+			.filter((item): item is NonNullable<typeof item> => item !== undefined);
+		return items;
+	}
+	if (typeof value === "object") {
+		const objectValue = value as { [key: string]: unknown };
+		const result: ASIData = {};
+		for (const [key, entryValue] of Object.entries(objectValue)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			const sanitized = sanitizeAsiValue(entryValue);
+			if (sanitized !== undefined) {
+				result[key] = sanitized;
+			}
+		}
+		return result;
+	}
+	return undefined;
+}
+
+export function validateAsiRequirements(asi: ASIData | undefined, status: ExperimentResult["status"]): string | null {
+	if (!asi) {
+		return "asi is required. Include at minimum a non-empty hypothesis.";
+	}
+	if (typeof asi.hypothesis !== "string" || asi.hypothesis.trim().length === 0) {
+		return "asi.hypothesis is required and must be a non-empty string.";
+	}
+	if (status === "keep") return null;
+	if (typeof asi.rollback_reason !== "string" || asi.rollback_reason.trim().length === 0) {
+		return "asi.rollback_reason is required for discard, crash, and checks_failed results.";
+	}
+	if (typeof asi.next_action_hint !== "string" || asi.next_action_hint.trim().length === 0) {
+		return "asi.next_action_hint is required for discard, crash, and checks_failed results.";
+	}
+	return null;
+}
+
+function registerSecondaryMetrics(state: ExperimentState, metrics: NumericMetricMap): void {
+	for (const name of Object.keys(metrics)) {
+		if (state.secondaryMetrics.some(metric => metric.name === name)) continue;
+		state.secondaryMetrics.push({
+			name,
+			unit: inferMetricUnitFromName(name),
+		});
+	}
+}
+
+function persistRun(workDir: string, experiment: ExperimentResult): void {
+	const entry = {
+		run: experiment.runNumber,
+		...experiment,
+	};
+	const jsonlPath = path.join(workDir, "autoresearch.jsonl");
+	fs.appendFileSync(jsonlPath, `${JSON.stringify(entry)}\n`);
+}
+
+function collectLoggedRunNumbers(results: ExperimentResult[]): Set<number> {
+	const runNumbers = new Set<number>();
+	for (const result of results) {
+		if (result.runNumber !== null) {
+			runNumbers.add(result.runNumber);
+		}
+	}
+	return runNumbers;
+}
+
+function validateObservedStatus(
+	status: ExperimentResult["status"],
+	pendingRun: { checksPass: boolean | null; passed: boolean },
+): string | null {
+	if (pendingRun.checksPass === false) {
+		return status === "checks_failed"
+			? null
+			: "benchmark checks failed for the pending run. Log it as checks_failed.";
+	}
+	if (!pendingRun.passed) {
+		return status === "crash" ? null : "the pending benchmark failed. Log it as crash.";
+	}
+	return status === "keep" || status === "discard" ? null : "the pending benchmark passed. Log it as keep or discard.";
+}
+
+async function commitKeptExperiment(
+	_options: AutoresearchToolFactoryOptions,
+	workDir: string,
+	state: ExperimentState,
+	experiment: ExperimentResult,
+	scopeValidation: { committablePaths: string[] } | undefined,
+): Promise<KeepCommitResult> {
+	if (!scopeValidation || scopeValidation.committablePaths.length === 0) {
+		return { note: "nothing to commit" };
+	}
+
+	try {
+		await git.stage.files(workDir, scopeValidation.committablePaths);
+	} catch (err) {
+		return {
+			error: `git add failed: ${err instanceof Error ? err.message : String(err)}`,
+		};
+	}
+
+	if (!(await git.diff.has(workDir, { cached: true, files: scopeValidation.committablePaths }))) {
+		return { note: "nothing to commit" };
+	}
+
+	const payload: { [key: string]: string | number } = {
+		status: experiment.status,
+		[state.metricName]: experiment.metric,
+	};
+	for (const [name, value] of Object.entries(experiment.metrics)) {
+		payload[name] = value;
+	}
+	const commitMessage = `${experiment.description}\n\nResult: ${JSON.stringify(payload)}`;
+	let commitResultText = "";
+	try {
+		const commitResult = await git.commit(workDir, commitMessage, {
+			files: scopeValidation.committablePaths,
+		});
+		commitResultText = mergeStdoutStderr(commitResult);
+	} catch (err) {
+		return {
+			error: `git commit failed: ${err instanceof Error ? err.message : String(err)}`,
+		};
+	}
+
+	const newCommit = (await git.head.short(workDir, 7)) ?? "";
+	if (newCommit.length >= 7) {
+		experiment.commit = newCommit;
+	}
+	const summaryLine = commitResultText.split("\n").find(line => line.trim().length > 0) ?? "committed";
+	return { note: summaryLine.trim() };
+}
+
+async function revertFailedExperiment(
+	options: AutoresearchToolFactoryOptions,
+	workDir: string,
+	preRunDirtyPaths: string[],
+): Promise<KeepCommitResult> {
+	let statusText: string;
+	try {
+		statusText = await git.status(workDir, {
+			pathspecs: ["."],
+			porcelainV1: true,
+			untrackedFiles: "all",
+			z: true,
+		});
+	} catch (err) {
+		return {
+			error: `git status failed: ${err instanceof Error ? err.message : String(err)}`,
+		};
+	}
+
+	const workDirPrefix = await readGitWorkDirPrefix(options, workDir);
+	const { tracked, untracked } = computeRunModifiedPaths(preRunDirtyPaths, statusText, workDirPrefix);
+	const totalReverted = tracked.length + untracked.length;
+	if (totalReverted === 0) {
+		return { note: "nothing to revert" };
+	}
+
+	if (tracked.length > 0) {
+		try {
+			await git.restore(workDir, { files: tracked, source: "HEAD", staged: true, worktree: true });
+		} catch (err) {
+			return {
+				error: `git restore failed: ${err instanceof Error ? err.message : String(err)}`,
+			};
+		}
+	}
+
+	for (const filePath of untracked) {
+		const absolutePath = path.join(workDir, filePath);
+		try {
+			fs.rmSync(absolutePath, { force: true, recursive: true });
+		} catch {
+			// Best-effort removal of untracked files
+		}
+	}
+
+	return { note: `reverted ${totalReverted} file${totalReverted === 1 ? "" : "s"}` };
+}
+
+function mergeStdoutStderr(result: { stderr: string; stdout: string }): string {
+	return `${result.stdout}${result.stderr}`;
+}
+
+async function validateKeepPaths(
+	options: AutoresearchToolFactoryOptions,
+	workDir: string,
+	state: ExperimentState,
+): Promise<{ committablePaths: string[] } | string> {
+	if (state.scopePaths.length === 0) {
+		return "Files in Scope is empty for the current segment. Re-run init_experiment after fixing autoresearch.md.";
+	}
+
+	let statusText: string;
+	try {
+		statusText = await git.status(workDir, {
+			pathspecs: ["."],
+			porcelainV1: true,
+			untrackedFiles: "all",
+			z: true,
+		});
+	} catch (err) {
+		return `git status failed: ${err instanceof Error ? err.message : String(err)}`;
+	}
+
+	const workDirPrefix = await readGitWorkDirPrefix(options, workDir);
+	const committablePaths: string[] = [];
+	for (const entry of parseWorkDirDirtyPathsWithStatus(statusText, workDirPrefix)) {
+		if (isAutoresearchLocalStatePath(entry.path)) {
+			continue;
+		}
+		if (isAutoresearchCommittableFile(entry.path)) {
+			committablePaths.push(entry.path);
+			continue;
+		}
+		if (state.offLimits.some(spec => pathMatchesContractPath(entry.path, spec))) {
+			return `cannot keep this run because ${entry.path} is listed under Off Limits in autoresearch.md`;
+		}
+		if (!state.scopePaths.some(spec => pathMatchesContractPath(entry.path, spec))) {
+			return `cannot keep this run because ${entry.path} is outside Files in Scope`;
+		}
+		committablePaths.push(entry.path);
+	}
+
+	return { committablePaths };
+}
+
+async function updateRunMetadata(
+	runDirectory: string | null,
+	metadata: {
+		commit: string;
+		confidence: number | null;
+		description: string;
+		gitNote: string | null;
+		loggedAt: string;
+		loggedAsi: ASIData | undefined;
+		loggedMetric: number;
+		loggedMetrics: NumericMetricMap;
+		runNumber: number | null;
+		status: ExperimentResult["status"];
+		wallClockSeconds: number | null;
+	},
+): Promise<void> {
+	if (!runDirectory) return;
+	const runJsonPath = path.join(runDirectory, "run.json");
+	let existing: Record<string, unknown> = {};
+	try {
+		existing = (await Bun.file(runJsonPath).json()) as Record<string, unknown>;
+	} catch {
+		existing = {};
+	}
+	await Bun.write(
+		runJsonPath,
+		JSON.stringify(
+			{
+				...existing,
+				loggedRunNumber: metadata.runNumber,
+				loggedAt: metadata.loggedAt,
+				loggedAsi: metadata.loggedAsi,
+				loggedMetric: metadata.loggedMetric,
+				loggedMetrics: metadata.loggedMetrics,
+				status: metadata.status,
+				description: metadata.description,
+				commit: metadata.commit,
+				gitNote: metadata.gitNote,
+				confidence: metadata.confidence,
+				wallClockSeconds: metadata.wallClockSeconds,
+			},
+			null,
+			2,
+		),
+	);
+}
+
+function buildLogText(
+	state: ExperimentState,
+	experiment: ExperimentResult,
+	currentSegmentRuns: number,
+	wallClockSeconds: number | null,
+	gitNote: string | null,
+): string {
+	const displayRunNumber = experiment.runNumber ?? state.results.length;
+	const lines = [`Logged run #${displayRunNumber}: ${experiment.status} - ${experiment.description}`];
+	if (wallClockSeconds !== null) {
+		lines.push(`Wall clock: ${wallClockSeconds.toFixed(1)}s`);
+	}
+	if (state.bestMetric !== null) {
+		lines.push(`Baseline ${state.metricName}: ${formatNum(state.bestMetric, state.metricUnit)}`);
+	}
+	if (currentSegmentRuns > 1 && state.bestMetric !== null && experiment.metric !== state.bestMetric) {
+		const delta = ((experiment.metric - state.bestMetric) / state.bestMetric) * 100;
+		const sign = delta > 0 ? "+" : "";
+		lines.push(`This run: ${formatNum(experiment.metric, state.metricUnit)} (${sign}${delta.toFixed(1)}%)`);
+	} else {
+		lines.push(`This run: ${formatNum(experiment.metric, state.metricUnit)}`);
+	}
+	if (Object.keys(experiment.metrics).length > 0) {
+		const baselineSecondary = findBaselineSecondary(state.results, state.currentSegment, state.secondaryMetrics);
+		const parts = Object.entries(experiment.metrics).map(([name, value]) => {
+			const unit = state.secondaryMetrics.find(metric => metric.name === name)?.unit ?? "";
+			const baseline = baselineSecondary[name];
+			if (baseline === undefined || baseline === 0 || currentSegmentRuns === 1) {
+				return `${name}: ${formatNum(value, unit)}`;
+			}
+			const delta = ((value - baseline) / baseline) * 100;
+			const sign = delta > 0 ? "+" : "";
+			return `${name}: ${formatNum(value, unit)} (${sign}${delta.toFixed(1)}%)`;
+		});
+		lines.push(`Secondary metrics: ${parts.join("  ")}`);
+	}
+	if (experiment.asi) {
+		const asiSummary = Object.entries(experiment.asi)
+			.map(([key, value]) => `${key}: ${truncateAsiValue(value)}`)
+			.join(" | ");
+		lines.push(`ASI: ${asiSummary}`);
+	}
+	if (state.confidence !== null) {
+		const status = state.confidence >= 2 ? "likely real" : state.confidence >= 1 ? "marginal" : "within noise";
+		lines.push(`Confidence: ${state.confidence.toFixed(1)}x noise floor (${status})`);
+	}
+	if (gitNote) {
+		lines.push(`Git: ${gitNote}`);
+	}
+	if (state.maxExperiments !== null) {
+		lines.push(`Progress: ${currentSegmentRuns}/${state.maxExperiments} runs in current segment`);
+		if (currentSegmentRuns >= state.maxExperiments) {
+			lines.push(`Maximum experiments reached (${state.maxExperiments}). Autoresearch mode is now off.`);
+		}
+	}
+	return lines.join("\n");
+}
+
+async function readGitWorkDirPrefix(options: AutoresearchToolFactoryOptions, workDir: string): Promise<string> {
+	void options;
+	try {
+		return await git.show.prefix(workDir);
+	} catch {
+		return "";
+	}
+}
+
+function truncateAsiValue(value: ASIData[string]): string {
+	const text = typeof value === "string" ? value : JSON.stringify(value);
+	return text.length > 120 ? `${text.slice(0, 117)}...` : text;
+}
+
+function isLogDetails(value: unknown): value is LogDetails {
+	if (typeof value !== "object" || value === null) return false;
+	return "experiment" in value && "state" in value;
+}
+
+function renderSummary(details: LogDetails, theme: Theme, width?: number): string {
+	const { experiment, state } = details;
+	if (!experiment || !state) {
+		return theme.fg("dim", "(no experiment data)");
+	}
+	const color = experiment.status === "keep" ? "success" : experiment.status === "discard" ? "warning" : "error";
+	let summary = `${theme.fg(color, experiment.status.toUpperCase())} ${theme.fg("muted", truncateToWidth(replaceTabs(experiment.description ?? ""), Math.max(20, (width ?? 100) - 30)))}`;
+	summary += ` ${theme.fg("contentAccent", `${state.metricName}=${formatNum(experiment.metric, state.metricUnit)}`)}`;
+	if (state.bestMetric !== null) {
+		summary += ` ${theme.fg("dim", `baseline ${formatNum(state.bestMetric, state.metricUnit)}`)}`;
+	}
+	if (state.confidence !== null) {
+		summary += ` ${theme.fg("dim", `conf ${state.confidence.toFixed(1)}x`)}`;
+	}
+	return summary;
+}