@f5-sales-demo/xcsh 19.51.2

package/src/autoresearch/dashboard.ts

@@ -0,0 +1,374 @@
+import { matchesKey, replaceTabs, Text, truncateToWidth, visibleWidth } from "@f5xc-salesdemos/pi-tui";
+import type { Theme } from "../modes/theme/theme";
+import { formatElapsed, formatNum } from "./helpers";
+import {
+	currentResults,
+	findBaselineMetric,
+	findBaselineRunNumber,
+	findBaselineSecondary,
+	findBestKeptResult,
+} from "./state";
+import type { AutoresearchRuntime, DashboardController, ExperimentResult, ExperimentState } from "./types";
+
+export function createDashboardController(): DashboardController {
+	let overlayTui: { requestRender(): void } | null = null;
+	let spinnerTimer: NodeJS.Timeout | undefined;
+	let spinnerFrame = 0;
+
+	const requestRender = (): void => {
+		overlayTui?.requestRender();
+	};
+
+	const clear = (): void => {
+		overlayTui = null;
+		clearInterval(spinnerTimer);
+		spinnerTimer = undefined;
+	};
+
+	return {
+		clear(ctx): void {
+			clear();
+			if (ctx.hasUI) ctx.ui.setWidget("autoresearch", undefined);
+		},
+		requestRender,
+		updateWidget(ctx, runtime): void {
+			if (!ctx.hasUI) return;
+			const state = runtime.state;
+			if (!shouldShowDashboard(runtime, state)) {
+				ctx.ui.setWidget("autoresearch", undefined);
+				return;
+			}
+
+			ctx.ui.setWidget("autoresearch", (_tui, theme) => {
+				if (state.results.length === 0 && runtime.runningExperiment)
+					return new Text(renderRunningOnly(runtime, state, theme), 0, 0);
+				if (runtime.dashboardExpanded) {
+					const width = process.stdout.columns ?? 120;
+					const lines = [
+						renderExpandedHeader(runtime, width, theme),
+						...renderDashboardLines(runtime, width, theme, 8),
+					];
+					return new Text(lines.join("\n"), 0, 0);
+				}
+				return new Text(renderCollapsedLine(runtime, state, theme), 0, 0);
+			});
+		},
+		async showOverlay(ctx, runtime): Promise<void> {
+			if (!ctx.hasUI || !shouldShowDashboard(runtime, runtime.state)) return;
+			await ctx.ui.custom<void>(
+				(tui, theme, _keybindings, done) => {
+					overlayTui = tui;
+					if (!spinnerTimer) {
+						spinnerTimer = setInterval(() => {
+							spinnerFrame += 1;
+							requestRender();
+						}, 80);
+					}
+
+					let scrollOffset = 0;
+					return {
+						render(width: number): string[] {
+							const terminalRows = process.stdout.rows ?? 40;
+							const header = renderExpandedHeader(runtime, width, theme);
+							const body = renderDashboardLines(runtime, width, theme, 0);
+							if (runtime.runningExperiment)
+								body.push(renderOverlayRunningLine(runtime, theme, width, spinnerFrame));
+							const viewportRows = Math.max(4, terminalRows - 4);
+							const maxScroll = Math.max(0, body.length - viewportRows);
+							if (scrollOffset > maxScroll) scrollOffset = maxScroll;
+							const visible = body.slice(scrollOffset, scrollOffset + viewportRows);
+							const footer = renderOverlayFooter(width, scrollOffset, viewportRows, body.length, theme);
+							return [
+								header,
+								...visible,
+								...Array.from({ length: Math.max(0, viewportRows - visible.length) }, () => ""),
+								footer,
+							];
+						},
+						handleInput(data: string): void {
+							const totalRows =
+								renderDashboardLines(runtime, process.stdout.columns ?? 120, theme, 0).length +
+								(runtime.runningExperiment ? 1 : 0);
+							const viewportRows = Math.max(4, (process.stdout.rows ?? 40) - 4);
+							const maxScroll = Math.max(0, totalRows - viewportRows);
+							if (matchesKey(data, "escape") || matchesKey(data, "esc") || data === "q") {
+								done(undefined);
+								return;
+							}
+							if (matchesKey(data, "up") || data === "k") {
+								scrollOffset = Math.max(0, scrollOffset - 1);
+							} else if (matchesKey(data, "down") || data === "j") {
+								scrollOffset = Math.min(maxScroll, scrollOffset + 1);
+							} else if (matchesKey(data, "pageUp")) {
+								scrollOffset = Math.max(0, scrollOffset - viewportRows);
+							} else if (matchesKey(data, "pageDown")) {
+								scrollOffset = Math.min(maxScroll, scrollOffset + viewportRows);
+							} else if (data === "g") {
+								scrollOffset = 0;
+							} else if (data === "G") {
+								scrollOffset = maxScroll;
+							}
+							tui.requestRender();
+						},
+						invalidate(): void {},
+						dispose(): void {
+							clear();
+						},
+					};
+				},
+				{ overlay: true },
+			);
+		},
+	};
+}
+function renderRunningOnly(runtime: AutoresearchRuntime, state: ExperimentState, theme: Theme): string {
+	const parts = [theme.fg("contentAccent", "autoresearch"), theme.fg("warning", " running...")];
+	if (state.name) parts.push(theme.fg("dim", ` | ${replaceTabs(state.name)}`));
+	if (runtime.runningExperiment) parts.push(theme.fg("dim", ` | ${replaceTabs(runtime.runningExperiment.command)}`));
+	return parts.join("");
+}
+function shouldShowDashboard(runtime: AutoresearchRuntime, state: ExperimentState): boolean {
+	return (
+		runtime.autoresearchMode ||
+		state.results.length > 0 ||
+		runtime.runningExperiment !== null ||
+		runtime.lastRunSummary !== null
+	);
+}
+function renderExpandedHeader(runtime: AutoresearchRuntime, width: number, theme: Theme): string {
+	const state = runtime.state;
+	const status = renderModeStatus(runtime, state);
+	const label = state.name ? ` autoresearch: ${replaceTabs(state.name)} ` : " autoresearch ";
+	const hint = theme.fg("dim", ` ctrl+x collapse  ctrl+shift+x overlay${status ? `  ${status}` : ""} `);
+	const fillWidth = Math.max(0, width - visibleWidth(label) - visibleWidth(hint));
+	return truncateToWidth(
+		theme.fg("contentAccent", label) + theme.fg("borderMuted", "-".repeat(fillWidth)) + hint,
+		width,
+	);
+}
+function renderCollapsedLine(runtime: AutoresearchRuntime, state: ExperimentState, theme: Theme): string {
+	if (runtime.lastRunSummary) {
+		const parts = [
+			theme.fg("contentAccent", "autoresearch"),
+			theme.fg("warning", ` pending run #${runtime.lastRunSummary.runNumber}`),
+			theme.fg("dim", runtime.lastRunSummary.passed ? " pass" : " fail"),
+		];
+		if (runtime.lastRunSummary.parsedPrimary !== null)
+			parts.push(
+				theme.fg(
+					"muted",
+					` | ${state.metricName}=${formatNum(runtime.lastRunSummary.parsedPrimary, state.metricUnit)}`,
+				),
+			);
+		parts.push(theme.fg("warning", " | log_experiment required"));
+		if (!runtime.autoresearchMode) parts.push(theme.fg("dim", " | mode off"));
+		return parts.join("");
+	}
+	if (state.results.length === 0) {
+		const modeStatus = runtime.autoresearchMode ? "baseline pending" : "mode off";
+		const parts = [theme.fg("contentAccent", "autoresearch"), theme.fg("warning", ` ${modeStatus}`)];
+		if (state.name) parts.push(theme.fg("dim", ` | ${replaceTabs(state.name)}`));
+		if (runtime.autoresearchMode) parts.push(theme.fg("dim", " | run the baseline"));
+		return parts.join("");
+	}
+	const current = currentResults(state.results, state.currentSegment);
+	const kept = current.filter(result => result.status === "keep").length;
+	const crashed = current.filter(result => result.status === "crash").length;
+	const checksFailed = current.filter(result => result.status === "checks_failed").length;
+	const best = findBestKeptResult(state);
+	const archivedRuns = Math.max(0, state.results.length - current.length);
+	const parts = [
+		theme.fg("contentAccent", "autoresearch"),
+		theme.fg("muted", ` ${current.length} runs`),
+		theme.fg("success", ` ${kept} kept`),
+	];
+	if (archivedRuns > 0) parts.push(theme.fg("dim", ` +${archivedRuns} archived`));
+	if (crashed > 0) parts.push(theme.fg("error", ` ${crashed} crash`));
+	if (checksFailed > 0) parts.push(theme.fg("error", ` ${checksFailed} checks_failed`));
+	parts.push(theme.fg("dim", " | "));
+	if (best && state.bestMetric !== null && best.result.metric !== state.bestMetric) {
+		parts.push(theme.fg("warning", `best ${formatNum(best.result.metric, state.metricUnit)}`));
+		parts.push(theme.fg("dim", ` baseline ${formatNum(state.bestMetric, state.metricUnit)}`));
+	} else if (state.bestMetric !== null) {
+		parts.push(theme.fg("warning", `baseline ${formatNum(state.bestMetric, state.metricUnit)}`));
+	} else {
+		parts.push(theme.fg("warning", `no kept runs yet`));
+	}
+	if (state.confidence !== null) {
+		const confidenceColor = state.confidence >= 2 ? "success" : state.confidence >= 1 ? "warning" : "error";
+		parts.push(theme.fg("dim", " | "), theme.fg(confidenceColor, `conf ${state.confidence.toFixed(1)}x`));
+	}
+	if (runtime.runningExperiment) {
+		parts.push(theme.fg("dim", ` | running ${formatElapsed(Date.now() - runtime.runningExperiment.startedAt)}`));
+	} else if (!runtime.autoresearchMode) {
+		parts.push(theme.fg("dim", ` | ${renderModeStatus(runtime, state)}`));
+	}
+	parts.push(theme.fg("dim", " | ctrl+x expand"));
+	return parts.join("");
+}
+function renderDashboardLines(runtime: AutoresearchRuntime, width: number, theme: Theme, maxRows: number): string[] {
+	const state = runtime.state;
+	if (state.results.length === 0) {
+		if (runtime.lastRunSummary) {
+			const lines = [
+				truncateToWidth(`Pending run: #${runtime.lastRunSummary.runNumber}`, width),
+				truncateToWidth(
+					`Result: ${runtime.lastRunSummary.passed ? "passed" : "failed"}${runtime.lastRunSummary.parsedPrimary !== null ? `  ${state.metricName} ${formatNum(runtime.lastRunSummary.parsedPrimary, state.metricUnit)}` : ""}`,
+					width,
+				),
+				truncateToWidth("Next action: finish log_experiment before starting another run.", width),
+			];
+			if (!runtime.autoresearchMode) lines.push(truncateToWidth("Mode: off", width));
+			return lines;
+		}
+		if (runtime.autoresearchMode) {
+			return [
+				truncateToWidth("Current segment: 0 runs", width),
+				truncateToWidth("Baseline: pending", width),
+				truncateToWidth("Next action: run and log the baseline experiment.", width),
+			];
+		}
+		return [theme.fg("dim", "No experiments logged yet.")];
+	}
+
+	const current = currentResults(state.results, state.currentSegment);
+	const kept = current.filter(result => result.status === "keep").length;
+	const discarded = current.filter(result => result.status === "discard").length;
+	const crashed = current.filter(result => result.status === "crash").length;
+	const checksFailed = current.filter(result => result.status === "checks_failed").length;
+	const baseline = findBaselineMetric(state.results, state.currentSegment);
+	const baselineRunNumber = findBaselineRunNumber(state.results, state.currentSegment);
+	const baselineSecondary = findBaselineSecondary(state.results, state.currentSegment, state.secondaryMetrics);
+	const best = findBestKeptResult(state);
+	const lines = [
+		truncateToWidth(
+			`Current segment: ${current.length} runs  ${kept} kept  ${discarded} discarded  ${crashed} crashed  ${checksFailed} checks_failed`,
+			width,
+		),
+		truncateToWidth(
+			`Baseline: ${formatNum(baseline, state.metricUnit)}${baselineRunNumber ? ` (#${baselineRunNumber})` : ""}`,
+			width,
+		),
+	];
+	if (state.results.length > current.length) {
+		lines.push(
+			truncateToWidth(`Archived from earlier segments: ${state.results.length - current.length} runs`, width),
+		);
+	}
+	if (runtime.lastRunSummary) {
+		lines.push(
+			truncateToWidth(
+				`Pending run: #${runtime.lastRunSummary.runNumber} (${runtime.lastRunSummary.passed ? "passed" : "failed"}) — log_experiment required`,
+				width,
+			),
+		);
+	}
+	if (!runtime.autoresearchMode) lines.push(truncateToWidth(`Mode: ${renderModeStatus(runtime, state)}`, width));
+	if (best) {
+		let progress = `Best: ${formatNum(best.result.metric, state.metricUnit)} (#${best.result.runNumber ?? best.index + 1})`;
+		if (baseline !== null && baseline !== 0 && best.result.metric !== baseline)
+			progress += ` ${formatDelta(best.result.metric, baseline)}`;
+		if (state.confidence !== null) progress += `  conf ${state.confidence.toFixed(1)}x`;
+		lines.push(truncateToWidth(progress, width));
+		if (state.secondaryMetrics.length > 0) {
+			const details = state.secondaryMetrics
+				.map(metric => {
+					const v = best.result.metrics[metric.name];
+					return v !== undefined
+						? `${metric.name} ${renderSecondaryCell(v, metric.unit, baselineSecondary[metric.name])}`
+						: null;
+				})
+				.filter((value): value is string => Boolean(value));
+			if (details.length > 0) lines.push(truncateToWidth(`Secondary: ${details.join("  ")}`, width));
+		}
+	}
+	lines.push("");
+	const secondaryHeader = state.secondaryMetrics.map(metric => truncateToWidth(metric.name, 10)).join(" ");
+	lines.push(
+		truncateToWidth(
+			`${theme.fg("muted", "#".padEnd(4))}${theme.fg("muted", "commit".padEnd(10))}${theme.fg("warning", state.metricName.padEnd(12))}${secondaryHeader ? `${theme.fg("muted", secondaryHeader)} ` : ""}${theme.fg("muted", "status".padEnd(14))}${theme.fg("muted", "description")}`,
+			width,
+		),
+	);
+	lines.push(theme.fg("borderMuted", "-".repeat(Math.max(0, width - 1))));
+
+	const visible = maxRows > 0 ? current.slice(-maxRows) : current;
+	if (visible.length < current.length)
+		lines.push(theme.fg("dim", `... ${current.length - visible.length} earlier runs hidden ...`));
+	for (const result of visible) {
+		lines.push(renderResultRow(result, state, baselineSecondary, width, theme));
+	}
+	return lines;
+}
+function renderResultRow(
+	result: ExperimentResult,
+	state: ExperimentState,
+	baselineSecondary: { [key: string]: number },
+	width: number,
+	theme: Theme,
+): string {
+	const secondary = state.secondaryMetrics
+		.map(metric =>
+			truncateToWidth(
+				renderSecondaryCell(result.metrics[metric.name], metric.unit, baselineSecondary[metric.name]),
+				10,
+			).padEnd(11),
+		)
+		.join("");
+	const statusColor = result.status === "keep" ? "success" : result.status === "discard" ? "warning" : "error";
+	const line =
+		theme.fg("dim", String(result.runNumber ?? state.results.indexOf(result) + 1).padEnd(4)) +
+		theme.fg("contentAccent", (result.commit || "-").padEnd(10)) +
+		theme.fg(statusColor, formatNum(result.metric, state.metricUnit).padEnd(12)) +
+		secondary +
+		theme.fg(statusColor, result.status.padEnd(14)) +
+		theme.fg("muted", replaceTabs(result.description));
+	return truncateToWidth(line, width);
+}
+function renderSecondaryCell(value: number | undefined, unit: string, baseline: number | undefined): string {
+	if (value === undefined) return "-";
+	const formatted = formatNum(value, unit);
+	if (baseline === undefined || baseline === 0 || baseline === value) return formatted;
+	return `${formatted} ${formatDelta(value, baseline)}`;
+}
+function formatDelta(value: number, baseline: number): string {
+	const delta = ((value - baseline) / baseline) * 100;
+	return `${delta > 0 ? "+" : ""}${delta.toFixed(1)}%`;
+}
+function renderOverlayRunningLine(
+	runtime: AutoresearchRuntime,
+	theme: Theme,
+	width: number,
+	spinnerFrame: number,
+): string {
+	return truncateToWidth(
+		theme.fg(
+			"warning",
+			`${theme.spinnerFrames[spinnerFrame % theme.spinnerFrames.length] ?? "*"} running ${formatElapsed(Date.now() - (runtime.runningExperiment?.startedAt ?? Date.now()))} ${replaceTabs(
+				runtime.runningExperiment?.command ?? "",
+			)}`,
+		),
+		width,
+	);
+}
+function renderOverlayFooter(
+	width: number,
+	scrollOffset: number,
+	viewportRows: number,
+	totalRows: number,
+	theme: Theme,
+): string {
+	const position =
+		totalRows > viewportRows
+			? ` ${scrollOffset + 1}-${Math.min(totalRows, scrollOffset + viewportRows)}/${totalRows}`
+			: "";
+	const hint = theme.fg("dim", ` up/down j/k pageup pagedown g G esc${position} `);
+	const fill = Math.max(0, width - visibleWidth(hint));
+	return theme.fg("borderMuted", "-".repeat(fill)) + hint;
+}
+function renderModeStatus(runtime: AutoresearchRuntime, state: ExperimentState): string {
+	if (runtime.autoresearchMode) return state.results.length === 0 ? "baseline pending" : "mode on";
+	const current = currentResults(state.results, state.currentSegment);
+	if (state.maxExperiments !== null && current.length >= state.maxExperiments) return "segment complete";
+	return "mode off";
+}

package/src/autoresearch/git.ts

@@ -0,0 +1,191 @@
+import type { ExtensionAPI } from "../extensibility/extensions";
+import * as git from "../utils/git";
+import { isAutoresearchLocalStatePath, normalizeAutoresearchPath } from "./helpers";
+
+const AUTORESEARCH_BRANCH_PREFIX = "autoresearch/";
+const BRANCH_NAME_MAX_LENGTH = 48;
+type EnsureAutoresearchBranchResult = { error: string; ok: false } | { branchName: string; created: boolean; ok: true };
+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;
+}
+export async function ensureAutoresearchBranch(
+	api: ExtensionAPI,
+	workDir: string,
+	goal: string | null,
+): Promise<EnsureAutoresearchBranchResult> {
+	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,
+		};
+	}
+
+	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: ${err instanceof Error ? err.message : String(err)}`,
+			ok: false,
+		};
+	}
+
+	const workDirPrefix = await git.show.prefix(workDir).catch(() => "");
+	const unsafeDirtyPaths = collectUnsafeDirtyPaths(dirtyPathsOutput, workDirPrefix);
+	const currentBranch = await getCurrentAutoresearchBranch(api, workDir);
+	if (currentBranch) {
+		if (unsafeDirtyPaths.length > 0) return buildUnsafeDirtyPathsFailure(unsafeDirtyPaths);
+		return {
+			branchName: currentBranch,
+			created: false,
+			ok: true,
+		};
+	}
+	if (unsafeDirtyPaths.length > 0) return buildUnsafeDirtyPathsFailure(unsafeDirtyPaths);
+
+	const branchName = await allocateBranchName(workDir, goal);
+	try {
+		await git.branch.checkoutNew(workDir, branchName);
+	} catch (err) {
+		return {
+			error: `Failed to create autoresearch branch ${branchName}: ${err instanceof Error ? err.message : String(err)}`,
+			ok: false,
+		};
+	}
+
+	return {
+		branchName,
+		created: true,
+		ok: true,
+	};
+}
+export function parseWorkDirDirtyPaths(statusOutput: string, workDirPrefix: string): string[] {
+	return parseWorkDirDirtyPathsWithStatus(statusOutput, workDirPrefix).map(e => e.path);
+}
+function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPrefix: string): string | null {
+	const normalizedPath = normalizeStatusPath(repoRelativePath);
+	const normalizedPrefix = normalizeAutoresearchPath(workDirPrefix);
+	if (normalizedPrefix === "" || normalizedPrefix === ".") return normalizedPath;
+	if (normalizedPath === normalizedPrefix) return ".";
+	if (!normalizedPath.startsWith(`${normalizedPrefix}/`)) return null;
+	return normalizeAutoresearchPath(normalizedPath.slice(normalizedPrefix.length + 1));
+}
+function normalizeStatusPath(path: string): string {
+	let normalized = path.trim();
+	if (normalized.startsWith('"') && normalized.endsWith('"')) normalized = normalized.slice(1, -1);
+	return normalizeAutoresearchPath(normalized);
+}
+async function allocateBranchName(workDir: string, goal: string | null): Promise<string> {
+	const baseName = `${AUTORESEARCH_BRANCH_PREFIX}${slugifyGoal(goal)}-${new Date().toISOString().slice(0, 10).replaceAll("-", "")}`;
+	let candidate = baseName;
+	let suffix = 2;
+	while (await git.ref.exists(workDir, `refs/heads/${candidate}`)) {
+		candidate = `${baseName}-${suffix}`;
+		suffix += 1;
+	}
+	return candidate;
+}
+function slugifyGoal(goal: string | null): string {
+	const slug = (goal ?? "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+	return slug.slice(0, BRANCH_NAME_MAX_LENGTH).replace(/-+$/g, "") || "session";
+}
+function buildUnsafeDirtyPathsFailure(unsafeDirtyPaths: string[]): EnsureAutoresearchBranchResult {
+	return {
+		error:
+			"Autoresearch needs a clean git worktree before it can create or reuse an isolated branch. " +
+			`Commit or stash these paths first: ${unsafeDirtyPaths.slice(0, 5).join(", ")}${unsafeDirtyPaths.length > 5 ? ` (+${unsafeDirtyPaths.length - 5} more)` : ""}`,
+		ok: false,
+	};
+}
+function collectUnsafeDirtyPaths(statusOutput: string, workDirPrefix: string): string[] {
+	return parseDirtyPathsWithStatus(statusOutput)
+		.map(entry => ({ rel: relativizeGitPathToWorkDir(entry.path, workDirPrefix), raw: entry.path }))
+		.filter(({ rel }) => !(rel && isAutoresearchLocalStatePath(rel)))
+		.map(({ rel, raw }) => rel ?? normalizeStatusPath(raw));
+}
+interface DirtyPathEntry {
+	path: string;
+	untracked: boolean;
+}
+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 statusCode = statusToken.trim();
+		addDirtyPathEntry(seen, results, firstPath, statusCode.startsWith("??"));
+		if (statusCode.startsWith("R") || statusCode.startsWith("C")) {
+			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 entries = parseWorkDirDirtyPathsWithStatus(currentStatusOutput, workDirPrefix).filter(
+		e => !preRunSet.has(e.path) && !isAutoresearchLocalStatePath(e.path),
+	);
+	return {
+		tracked: entries.filter(e => !e.untracked).map(e => e.path),
+		untracked: entries.filter(e => e.untracked).map(e => e.path),
+	};
+}