@oh-my-pi/pi-coding-agent 13.19.0 → 14.0.2

package/src/autoresearch/dashboard.ts

@@ -1,6 +1,5 @@
-import { matchesKey, Text, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { matchesKey, replaceTabs, Text, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
-import { replaceTabs } from "../tools/render-utils";
 import { formatElapsed, formatNum, isBetter } from "./helpers";
 import { currentResults, findBaselineMetric, findBaselineRunNumber, findBaselineSecondary } from "./state";
 import type { AutoresearchRuntime, DashboardController, ExperimentResult, ExperimentState } from "./types";

package/src/autoresearch/git.ts

@@ -236,3 +236,94 @@ function collectUnsafeDirtyPaths(statusOutput: string, workDirPrefix: string): s
 	}
 	return unsafeDirtyPaths;
 }
+
+export interface DirtyPathEntry {
+	path: string;
+	untracked: boolean;
+}
+
+export function parseDirtyPathsWithStatus(statusOutput: string): DirtyPathEntry[] {
+	if (statusOutput.includes("\0")) {
+		return parseDirtyPathsNulWithStatus(statusOutput);
+	}
+	return parseDirtyPathsLinesWithStatus(statusOutput);
+}
+
+function parseDirtyPathsNulWithStatus(statusOutput: string): DirtyPathEntry[] {
+	const seen = new Set<string>();
+	const results: DirtyPathEntry[] = [];
+	let index = 0;
+	while (index + 3 <= statusOutput.length) {
+		const statusToken = statusOutput.slice(index, index + 3);
+		index += 3;
+		const pathEnd = statusOutput.indexOf("\0", index);
+		if (pathEnd < 0) break;
+		const firstPath = statusOutput.slice(index, pathEnd);
+		index = pathEnd + 1;
+		const untracked = statusToken.trim().startsWith("??");
+		addDirtyPathEntry(seen, results, firstPath, untracked);
+		if (isRenameOrCopy(statusToken)) {
+			const secondPathEnd = statusOutput.indexOf("\0", index);
+			if (secondPathEnd < 0) break;
+			const secondPath = statusOutput.slice(index, secondPathEnd);
+			index = secondPathEnd + 1;
+			addDirtyPathEntry(seen, results, secondPath, false);
+		}
+	}
+	return results;
+}
+
+function parseDirtyPathsLinesWithStatus(statusOutput: string): DirtyPathEntry[] {
+	const seen = new Set<string>();
+	const results: DirtyPathEntry[] = [];
+	for (const line of statusOutput.split("\n")) {
+		const trimmedLine = line.trimEnd();
+		if (trimmedLine.length < 4) continue;
+		const statusToken = trimmedLine.slice(0, 3);
+		const rawPath = trimmedLine.slice(3).trim();
+		if (rawPath.length === 0) continue;
+		const untracked = statusToken.trim().startsWith("??");
+		const renameParts = rawPath.split(" -> ");
+		for (const renamePart of renameParts) {
+			addDirtyPathEntry(seen, results, renamePart, untracked);
+		}
+	}
+	return results;
+}
+
+function addDirtyPathEntry(seen: Set<string>, results: DirtyPathEntry[], rawPath: string, untracked: boolean): void {
+	const normalizedPath = normalizeStatusPath(rawPath);
+	if (normalizedPath.length === 0 || seen.has(normalizedPath)) return;
+	seen.add(normalizedPath);
+	results.push({ path: normalizedPath, untracked });
+}
+
+export function parseWorkDirDirtyPathsWithStatus(statusOutput: string, workDirPrefix: string): DirtyPathEntry[] {
+	const results: DirtyPathEntry[] = [];
+	for (const entry of parseDirtyPathsWithStatus(statusOutput)) {
+		const relativePath = relativizeGitPathToWorkDir(entry.path, workDirPrefix);
+		if (relativePath === null) continue;
+		results.push({ path: relativePath, untracked: entry.untracked });
+	}
+	return results;
+}
+
+export function computeRunModifiedPaths(
+	preRunDirtyPaths: string[],
+	currentStatusOutput: string,
+	workDirPrefix: string,
+): { tracked: string[]; untracked: string[] } {
+	const preRunSet = new Set(preRunDirtyPaths);
+	const tracked: string[] = [];
+	const untracked: string[] = [];
+	for (const entry of parseWorkDirDirtyPathsWithStatus(currentStatusOutput, workDirPrefix)) {
+		if (preRunSet.has(entry.path)) continue;
+		if (isAutoresearchLocalStatePath(entry.path)) continue;
+		if (entry.untracked) {
+			untracked.push(entry.path);
+		} else {
+			tracked.push(entry.path);
+		}
+	}
+	return { tracked, untracked };
+}

package/src/autoresearch/helpers.ts

@@ -269,6 +269,45 @@ export async function readPendingRunSummary(
 	return null;
 }
 
+export async function abandonUnloggedAutoresearchRuns(
+	workDir: string,
+	loggedRunNumbers: ReadonlySet<number>,
+): Promise<number> {
+	const runsDir = path.join(workDir, ".autoresearch", "runs");
+	let entries: fs.Dirent[];
+	try {
+		entries = await fs.promises.readdir(runsDir, { withFileTypes: true });
+	} catch (error) {
+		if (isEnoent(error)) return 0;
+		throw error;
+	}
+
+	let abandoned = 0;
+	const stamp = new Date().toISOString();
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const directoryName = entry.name;
+		const runDirectory = path.join(runsDir, directoryName);
+		const runJsonPath = path.join(runDirectory, "run.json");
+		let parsed: unknown;
+		try {
+			parsed = await Bun.file(runJsonPath).json();
+		} catch (error) {
+			if (isEnoent(error)) continue;
+			throw error;
+		}
+
+		const pending = parsePendingRunSummary(parsed, runDirectory, directoryName, loggedRunNumbers);
+		if (!pending) continue;
+
+		const existing = typeof parsed === "object" && parsed !== null ? (parsed as Record<string, unknown>) : {};
+		await Bun.write(runJsonPath, JSON.stringify({ ...existing, abandonedAt: stamp }, null, 2));
+		abandoned += 1;
+	}
+
+	return abandoned;
+}
+
 export function readConfig(cwd: string): AutoresearchConfig {
 	const configPath = path.join(cwd, "autoresearch.config.json");
 	try {
@@ -326,6 +365,7 @@ function parsePendingRunSummary(
 ): PendingRunSummary | null {
 	if (typeof value !== "object" || value === null) return null;
 	const candidate = value as {
+		abandonedAt?: unknown;
 		checks?: { durationSeconds?: unknown; passed?: unknown; timedOut?: unknown };
 		completedAt?: unknown;
 		command?: unknown;
@@ -335,6 +375,7 @@ function parsePendingRunSummary(
 		parsedAsi?: unknown;
 		parsedMetrics?: unknown;
 		parsedPrimary?: unknown;
+		preRunDirtyPaths?: unknown;
 		runNumber?: unknown;
 		status?: unknown;
 		timedOut?: unknown;
@@ -342,6 +383,9 @@ function parsePendingRunSummary(
 	if (candidate.loggedAt !== undefined || candidate.status !== undefined) {
 		return null;
 	}
+	if (typeof candidate.abandonedAt === "string" && candidate.abandonedAt.trim().length > 0) {
+		return null;
+	}
 
 	const command = typeof candidate.command === "string" ? candidate.command : "";
 	const runNumber =
@@ -389,6 +433,10 @@ function parsePendingRunSummary(
 			: null;
 	const checksTimedOut = candidate.checks?.timedOut === true;
 
+	const preRunDirtyPaths = Array.isArray(candidate.preRunDirtyPaths)
+		? candidate.preRunDirtyPaths.filter((item): item is string => typeof item === "string")
+		: [];
+
 	return {
 		checksDurationSeconds,
 		checksPass,
@@ -399,6 +447,7 @@ function parsePendingRunSummary(
 		parsedMetrics,
 		parsedPrimary,
 		passed: exitCode === 0 && !timedOut && checksPass !== false,
+		preRunDirtyPaths,
 		runDirectory,
 		runNumber,
 	};

package/src/autoresearch/index.ts

@@ -1,9 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AutocompleteItem } from "@oh-my-pi/pi-tui";
-import { renderPromptTemplate } from "../config/prompt-templates";
+import { prompt } from "@oh-my-pi/pi-utils";
 import type { ExtensionContext, ExtensionFactory } from "../extensibility/extensions";
-import commandInitializeTemplate from "./command-initialize.md" with { type: "text" };
 import commandResumeTemplate from "./command-resume.md" with { type: "text" };
 import { pathMatchesContractPath } from "./contract";
 import { createDashboardController } from "./dashboard";
@@ -12,7 +11,6 @@ import {
 	formatNum,
 	isAutoresearchCommittableFile,
 	isAutoresearchLocalStatePath,
-	isAutoresearchShCommand,
 	normalizeAutoresearchPath,
 	readMaxExperiments,
 	readPendingRunSummary,
@@ -37,18 +35,6 @@ import type { AutoresearchRuntime, ChecksResult, ExperimentResult, PendingRunSum
 
 const EXPERIMENT_TOOL_NAMES = ["init_experiment", "run_experiment", "log_experiment"];
 
-interface AutoresearchSetupInput {
-	intent: string;
-	benchmarkCommand: string;
-	metricName: string;
-	metricUnit: string;
-	direction: "lower" | "higher";
-	secondaryMetrics: string[];
-	scopePaths: string[];
-	offLimits: string[];
-	constraints: string[];
-}
-
 export const createAutoresearchExtension: ExtensionFactory = api => {
 	const runtimeStore = createRuntimeStore();
 	const dashboard = createDashboardController();
@@ -109,17 +95,6 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 	api.on("tool_call", (event, ctx) => {
 		const runtime = getRuntime(ctx);
 		if (!runtime.autoresearchMode) return;
-		if (event.toolName === "bash") {
-			const command = typeof event.input.command === "string" ? event.input.command : "";
-			const validationError = validateAutoresearchBashCommand(command);
-			if (validationError) {
-				return {
-					block: true,
-					reason: validationError,
-				};
-			}
-			return;
-		}
 		if (event.toolName !== "write" && event.toolName !== "edit" && event.toolName !== "ast_edit") return;
 
 		const rawPaths = getGuardedToolPaths(event.toolName, event.input);
@@ -151,14 +126,17 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 	});
 
 	api.registerCommand("autoresearch", {
-		description: "Start, stop, or clear builtin autoresearch mode.",
+		description: "Toggle builtin autoresearch mode, or pass off / clear, or a goal message.",
 		getArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
 			if (argumentPrefix.includes(" ")) return null;
+			const normalized = argumentPrefix.trim().toLowerCase();
+			// No suggestions for an empty argument prefix so Tab after "/autoresearch " does not
+			// force-complete into off/clear; bare command submit toggles like /plan.
+			if (normalized.length === 0) return null;
 			const completions: AutocompleteItem[] = [
 				{ label: "off", value: "off", description: "Leave autoresearch mode" },
 				{ label: "clear", value: "clear", description: "Delete autoresearch.jsonl and leave autoresearch mode" },
 			];
-			const normalized = argumentPrefix.trim().toLowerCase();
 			const filtered = completions.filter(item => item.label.startsWith(normalized));
 			return filtered.length > 0 ? filtered : null;
 		},
@@ -171,6 +149,15 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 				return;
 			}
 
+			if (trimmed === "" && runtime.autoresearchMode) {
+				setMode(ctx, false, runtime.goal, "off");
+				dashboard.updateWidget(ctx, runtime);
+				const experimentTools = new Set(EXPERIMENT_TOOL_NAMES);
+				await api.setActiveTools(api.getActiveTools().filter(name => !experimentTools.has(name)));
+				ctx.ui.notify("Autoresearch mode disabled", "info");
+				return;
+			}
+
 			if (trimmed === "off") {
 				setMode(ctx, false, runtime.goal, "off");
 				dashboard.updateWidget(ctx, runtime);
@@ -227,7 +214,7 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 				dashboard.updateWidget(ctx, runtime);
 				await api.setActiveTools([...new Set([...api.getActiveTools(), ...EXPERIMENT_TOOL_NAMES])]);
 				api.sendUserMessage(
-					renderPromptTemplate(commandResumeTemplate, {
+					prompt.render(commandResumeTemplate, {
 						autoresearch_md_path: autoresearchMdPath,
 						branch_status_line: branchResult.created
 							? `Created and checked out dedicated git branch \`${branchResult.branchName}\` before resuming.`
@@ -239,57 +226,21 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 				return;
 			}
 
-			const setup = await promptForAutoresearchSetup(
-				ctx,
-				trimmed || runtime.goal || "what should autoresearch improve?",
-			);
-			if (!setup) return;
-
-			const branchResult = await ensureAutoresearchBranch(api, workDir, setup.intent);
+			const branchGoal = trimmed.length > 0 ? trimmed : null;
+			const branchResult = await ensureAutoresearchBranch(api, workDir, branchGoal);
 			if (!branchResult.ok) {
 				ctx.ui.notify(branchResult.error, "error");
 				return;
 			}
 
-			setMode(ctx, true, setup.intent, "on");
-			runtime.state.name = setup.intent;
-			runtime.state.metricName = setup.metricName;
-			runtime.state.metricUnit = setup.metricUnit;
-			runtime.state.bestDirection = setup.direction;
-			runtime.state.secondaryMetrics = setup.secondaryMetrics.map(name => ({ name, unit: "" }));
-			runtime.state.benchmarkCommand = setup.benchmarkCommand;
-			runtime.state.scopePaths = [...setup.scopePaths];
-			runtime.state.offLimits = [...setup.offLimits];
-			runtime.state.constraints = [...setup.constraints];
+			setMode(ctx, true, branchGoal, "on");
 			dashboard.updateWidget(ctx, runtime);
 			await api.setActiveTools([...new Set([...api.getActiveTools(), ...EXPERIMENT_TOOL_NAMES])]);
-			api.sendUserMessage(
-				renderPromptTemplate(commandInitializeTemplate, {
-					branch_status_line: branchResult.created
-						? `Created and checked out dedicated git branch \`${branchResult.branchName}\`.`
-						: `Using dedicated git branch \`${branchResult.branchName}\`.`,
-					intent: setup.intent,
-					benchmark_command: setup.benchmarkCommand,
-					metric_name: setup.metricName,
-					metric_unit: setup.metricUnit,
-					direction: setup.direction,
-					has_secondary_metrics: setup.secondaryMetrics.length > 0,
-					secondary_metrics: setup.secondaryMetrics,
-					secondary_metrics_block: formatBulletBlock(
-						setup.secondaryMetrics,
-						value => `  - \`${value}\``,
-						"  - `(none)`",
-					),
-					scope_paths: setup.scopePaths,
-					scope_paths_block: formatBulletBlock(setup.scopePaths, value => `  - \`${value}\``),
-					has_off_limits: setup.offLimits.length > 0,
-					off_limits: setup.offLimits,
-					off_limits_block: formatBulletBlock(setup.offLimits, value => `  - \`${value}\``, "  - `(none)`"),
-					has_constraints: setup.constraints.length > 0,
-					constraints: setup.constraints,
-					constraints_block: formatBulletBlock(setup.constraints, value => `  - ${value}`, "  - `(none)`"),
-				}),
-			);
+			if (trimmed.length > 0) {
+				api.sendUserMessage(trimmed);
+			} else {
+				ctx.ui.notify("Autoresearch enabled—describe what to optimize in your next message.", "info");
+			}
 		},
 	});
 
@@ -352,7 +303,7 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 		api.sendMessage(
 			{
 				customType: "autoresearch-resume",
-				content: renderPromptTemplate(resumeMessageTemplate, {
+				content: prompt.render(resumeMessageTemplate, {
 					autoresearch_md_path: autoresearchMdPath,
 					has_ideas: fs.existsSync(ideasPath),
 					has_pending_run: Boolean(pendingRun),
@@ -394,15 +345,16 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 				status: result.status,
 			};
 		});
+		const hasAutoresearchMd = fs.existsSync(autoresearchMdPath);
 		return {
-			systemPrompt: renderPromptTemplate(promptTemplate, {
+			systemPrompt: prompt.render(promptTemplate, {
 				base_system_prompt: event.systemPrompt,
 				has_goal: goal.trim().length > 0,
 				goal,
+				has_autoresearch_md: hasAutoresearchMd,
 				working_dir: workDir,
 				default_metric_name: runtime.state.metricName,
 				metric_name: runtime.state.metricName,
-				has_autoresearch_md: fs.existsSync(autoresearchMdPath),
 				autoresearch_md_path: autoresearchMdPath,
 				has_checks: fs.existsSync(checksPath),
 				checks_path: checksPath,
@@ -438,93 +390,6 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 	});
 };
 
-async function promptForAutoresearchSetup(
-	ctx: ExtensionContext,
-	defaultIntent: string,
-): Promise<AutoresearchSetupInput | undefined> {
-	const intentInput = await ctx.ui.input("Autoresearch Intent", defaultIntent);
-	if (intentInput === undefined) return undefined;
-	const intent = intentInput.trim();
-	if (intent.length === 0) {
-		ctx.ui.notify("Autoresearch intent is required", "info");
-		return undefined;
-	}
-
-	const benchmarkCommandInput = await ctx.ui.input("Benchmark Command", "bash autoresearch.sh");
-	if (benchmarkCommandInput === undefined) return undefined;
-	const benchmarkCommand = benchmarkCommandInput.trim();
-	if (benchmarkCommand.length === 0) {
-		ctx.ui.notify("Benchmark command is required", "info");
-		return undefined;
-	}
-	if (!isAutoresearchShCommand(benchmarkCommand)) {
-		ctx.ui.notify("Benchmark command must invoke `autoresearch.sh` directly", "info");
-		return undefined;
-	}
-
-	const metricNameInput = await ctx.ui.input("Primary Metric Name", "runtime_ms");
-	if (metricNameInput === undefined) return undefined;
-	const metricName = metricNameInput.trim();
-	if (metricName.length === 0) {
-		ctx.ui.notify("Primary metric name is required", "info");
-		return undefined;
-	}
-
-	const metricUnitInput = await ctx.ui.input("Metric Unit", "ms");
-	if (metricUnitInput === undefined) return undefined;
-	const metricUnit = metricUnitInput.trim();
-
-	const directionInput = await ctx.ui.input("Metric Direction", "lower");
-	if (directionInput === undefined) return undefined;
-	const normalizedDirection = directionInput.trim().toLowerCase();
-	if (normalizedDirection !== "lower" && normalizedDirection !== "higher") {
-		ctx.ui.notify("Metric direction must be `lower` or `higher`", "info");
-		return undefined;
-	}
-
-	const secondaryMetricsInput = await ctx.ui.input("Tradeoff Metrics", "");
-	if (secondaryMetricsInput === undefined) return undefined;
-
-	const scopePathsInput = await ctx.ui.input("Files in Scope", "packages/coding-agent/src/autoresearch");
-	if (scopePathsInput === undefined) return undefined;
-	const scopePaths = splitSetupList(scopePathsInput);
-	if (scopePaths.length === 0) {
-		ctx.ui.notify("Files in Scope must include at least one path", "info");
-		return undefined;
-	}
-
-	const offLimitsInput = await ctx.ui.input("Off Limits", "");
-	if (offLimitsInput === undefined) return undefined;
-	const constraintsInput = await ctx.ui.input("Constraints", "");
-	if (constraintsInput === undefined) return undefined;
-
-	return {
-		intent,
-		benchmarkCommand,
-		metricName,
-		metricUnit,
-		direction: normalizedDirection,
-		secondaryMetrics: splitSetupList(secondaryMetricsInput),
-		scopePaths,
-		offLimits: splitSetupList(offLimitsInput),
-		constraints: splitSetupList(constraintsInput),
-	};
-}
-
-function splitSetupList(value: string): string[] {
-	return value
-		.split(/\r?\n|,/)
-		.map(entry => entry.trim())
-		.filter((entry, index, values) => entry.length > 0 && values.indexOf(entry) === index);
-}
-
-function formatBulletBlock(values: string[], renderValue: (value: string) => string, emptyValue = ""): string {
-	if (values.length === 0) {
-		return emptyValue;
-	}
-	return values.map(renderValue).join("\n");
-}
-
 function hasLocalAutoresearchState(workDir: string): boolean {
 	return fs.existsSync(path.join(workDir, "autoresearch.jsonl")) || fs.existsSync(path.join(workDir, ".autoresearch"));
 }
@@ -667,27 +532,3 @@ function canonicalizeTargetPath(targetPath: string): string {
 	}
 	return path.resolve(canonicalizeExistingPath(currentPath), ...pendingSegments);
 }
-
-function validateAutoresearchBashCommand(command: string): string | null {
-	const trimmed = command.trim();
-	if (trimmed.length === 0) {
-		return null;
-	}
-	const mutationPatterns = [
-		/(^|[;&|()]\s*)(?:bash|sh)\b/,
-		/(^|[;&|()]\s*)(?:python|python3|node|perl|ruby|php)\b/,
-		/(^|[;&|()]\s*)(?:mv|cp|rm|mkdir|touch|chmod|chown|ln|install|patch)\b/,
-		/(^|[;&|()]\s*)sed\s+-i\b/,
-		/(^|[;&|()]\s*)git\s+(?:add|apply|checkout|clean|commit|merge|rebase|reset|restore|revert|stash|switch|worktree)\b/,
-		/(^|[^<])>>?/,
-		/\|\s*tee\b/,
-		/<<<?/,
-	];
-	if (mutationPatterns.some(pattern => pattern.test(trimmed))) {
-		return (
-			"Autoresearch only allows read-only shell inspection. " +
-			"Use write/edit/ast_edit for file changes and run_experiment for benchmark execution."
-		);
-	}
-	return null;
-}

package/src/autoresearch/prompt.md

@@ -8,7 +8,11 @@ Autoresearch mode is active.
 Primary goal:
 {{goal}}
 {{else}}
+{{#if has_autoresearch_md}}
 Primary goal is documented in `autoresearch.md` for this session.
+{{else}}
+There is no `autoresearch.md` yet. Infer what to optimize from the latest user message and the conversation; after you create `autoresearch.md`, keep it as the durable source of truth for goal and benchmark contract.
+{{/if}}
 {{/if}}
 
 Working directory:
@@ -63,7 +67,7 @@ An unlogged run artifact exists at `{{pending_run_directory}}`.
 
 - `init_experiment` — initialize or reset the experiment session for the current optimization target.
 - `run_experiment` — run a benchmark or experiment command with timing, output capture, structured metric parsing, and optional backpressure checks.
-- `log_experiment` — record the result, update the dashboard, persist JSONL history, auto-commit kept experiments, and auto-revert discarded or failed experiments.
+- `log_experiment` — record the result, update the dashboard, persist JSONL history, auto-commit kept experiments, and revert only run-modified files for discarded or failed experiments (pre-existing uncommitted changes are preserved).
 
 ### Operating protocol
 
@@ -83,6 +87,8 @@ An unlogged run artifact exists at `{{pending_run_directory}}`.
    - Use the same workload every run unless you intentionally re-initialize with a new segment.
    - Keep the measurement harness, evaluator, and fixed benchmark inputs stable unless you intentionally start a new segment and document the change.
 4. Initialize the loop with `init_experiment` before the first logged run of a segment.
+   - Pass `from_autoresearch_md: true` with only `name` to load the benchmark contract from `autoresearch.md` without mirroring every field in the tool call.
+   - Use `abandon_unlogged_runs: true` only when you intentionally discard unlogged run artifacts and need a fresh segment (for example after a bad or obsolete benchmark directory).
 5. Run a baseline first.
    - Establish the baseline metric before attempting optimizations.
    - Track secondary metrics only when they matter to correctness, quality, or obvious regressions.
@@ -90,7 +96,9 @@ An unlogged run artifact exists at `{{pending_run_directory}}`.
    - Make one coherent experiment at a time.
    - Run `run_experiment`.
    - Interpret the result honestly.
-   - Call `log_experiment` after every run.
+   - Call `log_experiment` after every run (it refreshes benchmark/scope fields from `autoresearch.md` before logging so keep validation matches the file on disk).
+   - Use `run_experiment` with `force: true` only when you must override the segment benchmark command or skip the direct-`autoresearch.sh` rule.
+   - On `log_experiment`, `force: true` relaxes ASI requirements and allows keeping a primary-metric regression; prefer normal logging when possible.
 7. Keep the primary metric as the decision maker.
    - `keep` when the primary metric improves.
    - `discard` when it regresses or stays flat.
@@ -137,7 +145,11 @@ Suggested structure:
 {{#if has_goal}}
 - {{goal}}
 {{else}}
+{{#if has_autoresearch_md}}
 - document the active target here before the first benchmark
+{{else}}
+- (derive from the user's messages, then record here)
+{{/if}}
 {{/if}}
 
 ## Benchmark
@@ -194,15 +206,20 @@ Resume from the existing notes:
 {{else}}
 ### Initial setup
 
-`autoresearch.md` does not exist yet.
+`autoresearch.md` does not exist yet. You decide the benchmark contract, harness, and scope from the user's messages and the repository—do not ask the user to re-type benchmark commands or metric names in a separate UI prompt.
+
+Before the first benchmark:
 
-Create the experiment workspace before the first benchmark:
+- Write `autoresearch.md` with goal, benchmark command (must be a **direct** invocation of `autoresearch.sh`, e.g. `bash autoresearch.sh`), primary metric name and unit, direction (`lower` or `higher`), tradeoff metrics if relevant, files in scope, off limits, and constraints.
+- Add a short preflight section: prerequisites, one-time setup, and the comparability invariant that must stay fixed across runs.
+- Mark ground-truth evaluators, fixed datasets, and other measurement-critical files as off limits or hard constraints when they define the benchmark contract.
+- Write or update `autoresearch.program.md` when you learn durable heuristics, failure patterns, or repo-specific strategy for later resume turns.
+- Create `autoresearch.sh` as the canonical benchmark entrypoint; print the primary metric as `METRIC <name>=<number>` and optional secondary metrics as additional `METRIC` lines.
+- Optionally add `autoresearch.checks.sh` if correctness or quality needs a hard gate.
+- Call `init_experiment` with arguments that match `autoresearch.md` exactly (benchmark command, metric, unit, direction, scope paths, off limits, constraints).
+- Run and log the baseline.
 
-- write `autoresearch.md`
-- write `autoresearch.sh`
-- optionally write `autoresearch.checks.sh`
-- run `init_experiment`
-- run and log the baseline
+Until `init_experiment` succeeds, only autoresearch control files (`autoresearch.md`, `autoresearch.sh`, `autoresearch.program.md`, `autoresearch.ideas.md`, `autoresearch.checks.sh`) may be edited; after initialization, respect Files in Scope from the contract.
 
 {{/if}}
 {{#if has_checks}}

package/src/autoresearch/state.ts

@@ -34,7 +34,6 @@ export function createExperimentState(): ExperimentState {
 		scopePaths: [],
 		offLimits: [],
 		constraints: [],
-		segmentFingerprint: null,
 	};
 }
 
@@ -203,8 +202,6 @@ export function reconstructStateFromJsonl(workDir: string): ReconstructedExperim
 			state.scopePaths = cloneStringArray(configEntry.scopePaths);
 			state.offLimits = cloneStringArray(configEntry.offLimits);
 			state.constraints = cloneStringArray(configEntry.constraints);
-			state.segmentFingerprint =
-				typeof configEntry.segmentFingerprint === "string" ? configEntry.segmentFingerprint : null;
 			state.secondaryMetrics = hydrateMetricDefs(configEntry.secondaryMetrics);
 			continue;
 		}
@@ -322,9 +319,6 @@ function parseConfigEntry(value: unknown): AutoresearchJsonConfigEntry | null {
 			candidate.constraints.filter((item): item is string => typeof item === "string"),
 		);
 	}
-	if (typeof candidate.segmentFingerprint === "string" && candidate.segmentFingerprint.trim().length > 0) {
-		config.segmentFingerprint = candidate.segmentFingerprint;
-	}
 	return config;
 }