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

package/src/autoresearch/contract.ts

@@ -1,4 +1,3 @@
-import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AutoresearchBenchmarkContract, AutoresearchContract, MetricDirection } from "./types";
@@ -76,49 +75,6 @@ export function validateAutoresearchContract(contract: AutoresearchContract): st
 	return errors;
 }
 
-export function buildAutoresearchSegmentFingerprint(
-	contract: AutoresearchContract,
-	scripts: {
-		benchmarkScript: string;
-		checksScript: string | null;
-	},
-): string {
-	const payload = {
-		benchmark: contract.benchmark,
-		scopePaths: contract.scopePaths,
-		offLimits: contract.offLimits,
-		constraints: contract.constraints,
-		scripts,
-	};
-	return crypto.createHash("sha256").update(JSON.stringify(payload)).digest("hex");
-}
-
-export function getAutoresearchFingerprintMismatchError(
-	stateFingerprint: string | null,
-	workDir: string,
-): string | null {
-	if (!stateFingerprint) {
-		return "The current segment has no fingerprint metadata. Re-run init_experiment before continuing.";
-	}
-
-	const contractResult = readAutoresearchContract(workDir);
-	const scriptSnapshot = loadAutoresearchScriptSnapshot(workDir);
-	const errors = [...contractResult.errors, ...scriptSnapshot.errors];
-	if (errors.length > 0) {
-		return `${errors.join(" ")} Re-run init_experiment after fixing the workspace contract.`;
-	}
-
-	const currentFingerprint = buildAutoresearchSegmentFingerprint(contractResult.contract, {
-		benchmarkScript: scriptSnapshot.benchmarkScript,
-		checksScript: scriptSnapshot.checksScript,
-	});
-	if (currentFingerprint === stateFingerprint) {
-		return null;
-	}
-
-	return "autoresearch.md, autoresearch.sh, or autoresearch.checks.sh changed since the current segment was initialized. Re-run init_experiment before continuing.";
-}
-
 export function loadAutoresearchScriptSnapshot(workDir: string): AutoresearchScriptSnapshot {
 	const benchmarkScriptPath = path.join(workDir, "autoresearch.sh");
 	const checksScriptPath = path.join(workDir, "autoresearch.checks.sh");

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

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "../extensibility/extensions";
+import * as git from "../utils/git";
 import { isAutoresearchLocalStatePath, normalizeAutoresearchPath } from "./helpers";
 
 const AUTORESEARCH_BRANCH_PREFIX = "autoresearch/";
@@ -17,9 +18,8 @@ export interface EnsureAutoresearchBranchSuccess {
 
 export type EnsureAutoresearchBranchResult = EnsureAutoresearchBranchFailure | EnsureAutoresearchBranchSuccess;
 
-export async function getCurrentAutoresearchBranch(api: ExtensionAPI, workDir: string): Promise<string | null> {
-	const currentBranchResult = await api.exec("git", ["branch", "--show-current"], { cwd: workDir, timeout: 5_000 });
-	const currentBranch = currentBranchResult.stdout.trim();
+export async function getCurrentAutoresearchBranch(_api: ExtensionAPI, workDir: string): Promise<string | null> {
+	const currentBranch = (await git.branch.current(workDir)) ?? "";
 	return currentBranch.startsWith(AUTORESEARCH_BRANCH_PREFIX) ? currentBranch : null;
 }
 
@@ -28,28 +28,30 @@ export async function ensureAutoresearchBranch(
 	workDir: string,
 	goal: string | null,
 ): Promise<EnsureAutoresearchBranchResult> {
-	const repoRootResult = await api.exec("git", ["rev-parse", "--show-toplevel"], { cwd: workDir, timeout: 5_000 });
-	if (repoRootResult.code !== 0) {
+	const repoRoot = await git.repo.root(workDir);
+	if (!repoRoot) {
 		return {
 			error: "Autoresearch requires a git repository so it can isolate experiments and revert failed runs safely.",
 			ok: false,
 		};
 	}
-	const repoRoot = repoRootResult.stdout.trim() || workDir;
 
-	const dirtyPathsResult = await api.exec("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
-		cwd: repoRoot,
-		timeout: 5_000,
-	});
-	if (dirtyPathsResult.code !== 0) {
+	let dirtyPathsOutput: string;
+	try {
+		dirtyPathsOutput = await git.status(repoRoot, {
+			porcelainV1: true,
+			untrackedFiles: "all",
+			z: true,
+		});
+	} catch (err) {
 		return {
-			error: `Unable to inspect git status before starting autoresearch: ${mergeStdoutStderr(dirtyPathsResult).trim() || `exit ${dirtyPathsResult.code}`}`,
+			error: `Unable to inspect git status before starting autoresearch: ${err instanceof Error ? err.message : String(err)}`,
 			ok: false,
 		};
 	}
 
 	const workDirPrefix = await readGitWorkDirPrefix(api, workDir);
-	const unsafeDirtyPaths = collectUnsafeDirtyPaths(dirtyPathsResult.stdout, workDirPrefix);
+	const unsafeDirtyPaths = collectUnsafeDirtyPaths(dirtyPathsOutput, workDirPrefix);
 	const currentBranch = await getCurrentAutoresearchBranch(api, workDir);
 	if (currentBranch) {
 		if (unsafeDirtyPaths.length > 0) {
@@ -66,12 +68,11 @@ export async function ensureAutoresearchBranch(
 	}
 
 	const branchName = await allocateBranchName(api, workDir, goal);
-	const checkoutResult = await api.exec("git", ["checkout", "-b", branchName], { cwd: workDir, timeout: 10_000 });
-	if (checkoutResult.code !== 0) {
+	try {
+		await git.branch.checkoutNew(workDir, branchName);
+	} catch (err) {
 		return {
-			error:
-				`Failed to create autoresearch branch ${branchName}: ` +
-				`${mergeStdoutStderr(checkoutResult).trim() || `exit ${checkoutResult.code}`}`,
+			error: `Failed to create autoresearch branch ${branchName}: ${err instanceof Error ? err.message : String(err)}`,
 			ok: false,
 		};
 	}
@@ -109,11 +110,12 @@ export function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPref
 }
 
 async function readGitWorkDirPrefix(api: ExtensionAPI, workDir: string): Promise<string> {
-	const prefixResult = await api.exec("git", ["rev-parse", "--show-prefix"], { cwd: workDir, timeout: 5_000 });
-	if (prefixResult.code !== 0) {
+	void api;
+	try {
+		return await git.show.prefix(workDir);
+	} catch {
 		return "";
 	}
-	return prefixResult.stdout.trim();
 }
 
 export function parseDirtyPaths(statusOutput: string): string[] {
@@ -180,11 +182,8 @@ async function allocateBranchName(api: ExtensionAPI, workDir: string, goal: stri
 }
 
 async function branchExists(api: ExtensionAPI, workDir: string, branchName: string): Promise<boolean> {
-	const result = await api.exec("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], {
-		cwd: workDir,
-		timeout: 5_000,
-	});
-	return result.code === 0;
+	void api;
+	return git.ref.exists(workDir, `refs/heads/${branchName}`);
 }
 
 function slugifyGoal(goal: string | null): string {
@@ -204,10 +203,6 @@ function currentDateStamp(): string {
 	return `${year}${month}${day}`;
 }
 
-function mergeStdoutStderr(result: { stderr: string; stdout: string }): string {
-	return `${result.stdout}${result.stderr}`;
-}
-
 function addDirtyPath(paths: Set<string>, rawPath: string): void {
 	const normalizedPath = normalizeStatusPath(rawPath);
 	if (normalizedPath.length === 0) return;
@@ -241,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;
-}