@f5xc-salesdemos/xcsh 18.56.0 → 18.57.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "18.56.0",
+	"version": "18.57.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5xc-salesdemos/xcsh",
 	"author": "Can Boluk",
@@ -48,12 +48,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@f5xc-salesdemos/xcsh-stats": "18.56.0",
-		"@f5xc-salesdemos/pi-agent-core": "18.56.0",
-		"@f5xc-salesdemos/pi-ai": "18.56.0",
-		"@f5xc-salesdemos/pi-natives": "18.56.0",
-		"@f5xc-salesdemos/pi-tui": "18.56.0",
-		"@f5xc-salesdemos/pi-utils": "18.56.0",
+		"@f5xc-salesdemos/xcsh-stats": "18.57.0",
+		"@f5xc-salesdemos/pi-agent-core": "18.57.0",
+		"@f5xc-salesdemos/pi-ai": "18.57.0",
+		"@f5xc-salesdemos/pi-natives": "18.57.0",
+		"@f5xc-salesdemos/pi-tui": "18.57.0",
+		"@f5xc-salesdemos/pi-utils": "18.57.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/autoresearch/contract.ts

@@ -1,18 +1,22 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { inferMetricUnitFromName } from "./helpers";
+import { inferMetricUnitFromName, normalizeAutoresearchPath } from "./helpers";
 import type { AutoresearchContract, ExperimentState, MetricDirection } from "./types";
 
 const HEADING_REGEX = /^##\s+(.+?)\s*$/;
 const LIST_ITEM_REGEX = /^\s*[-*]\s+(.*)$/;
 const KEY_VALUE_REGEX = /^\s*[-*]\s+([^:]+):\s*(.*)$/;
-
-export function readAutoresearchContract(workDir: string) {
-	const contractPath = path.join(workDir, "autoresearch.md");
-	let content = "";
+function tryReadFile(filePath: string): string | null {
 	try {
-		content = fs.readFileSync(contractPath, "utf8");
+		return fs.readFileSync(filePath, "utf8");
 	} catch {
+		return null;
+	}
+}
+export function readAutoresearchContract(workDir: string) {
+	const contractPath = path.join(workDir, "autoresearch.md");
+	const content = tryReadFile(contractPath);
+	if (content === null)
 		return {
 			contract: {
 				benchmark: { command: null, primaryMetric: null, metricUnit: "", direction: null, secondaryMetrics: [] },
@@ -23,13 +27,9 @@ export function readAutoresearchContract(workDir: string) {
 			errors: [`${contractPath} does not exist. Create it before initializing autoresearch.`],
 			path: contractPath,
 		};
-	}
-
 	const contract = parseAutoresearchContract(content);
-	const errors = validateAutoresearchContract(contract);
-	return { contract, errors, path: contractPath };
+	return { contract, errors: validateAutoresearchContract(contract), path: contractPath };
 }
-
 export function parseAutoresearchContract(markdown: string): AutoresearchContract {
 	const sections = extractSections(markdown);
 	return {
@@ -39,7 +39,6 @@ export function parseAutoresearchContract(markdown: string): AutoresearchContrac
 		constraints: parseListSection(sections.get("constraints") ?? ""),
 	};
 }
-
 function validateAutoresearchContract(contract: AutoresearchContract): string[] {
 	const errors: string[] = [];
 	if (!contract.benchmark.command) errors.push("Benchmark.command is required in autoresearch.md.");
@@ -48,77 +47,54 @@ function validateAutoresearchContract(contract: AutoresearchContract): string[]
 		errors.push("Benchmark.direction must be `lower` or `higher` in autoresearch.md.");
 	if (contract.scopePaths.length === 0)
 		errors.push("Files in Scope must contain at least one path in autoresearch.md.");
-	for (const p of contract.scopePaths) {
-		if (isUnsafeContractPathSpec(p)) errors.push(`Files in Scope contains an invalid path: ${p}`);
-	}
-	for (const p of contract.offLimits) {
-		if (isUnsafeContractPathSpec(p)) errors.push(`Off Limits contains an invalid path: ${p}`);
-	}
+	for (const [label, paths] of [
+		["Files in Scope", contract.scopePaths],
+		["Off Limits", contract.offLimits],
+	] as const)
+		for (const p of paths)
+			if (path.posix.isAbsolute(p) || p === ".." || p.startsWith("../"))
+				errors.push(`${label} contains an invalid path: ${p}`);
 	return errors;
 }
-
 export function loadAutoresearchScriptSnapshot(workDir: string) {
 	const benchmarkScriptPath = path.join(workDir, "autoresearch.sh");
 	const checksScriptPath = path.join(workDir, "autoresearch.checks.sh");
-	const errors: string[] = [];
-
-	let benchmarkScript = "";
-	try {
-		benchmarkScript = fs.readFileSync(benchmarkScriptPath, "utf8");
-	} catch {
-		errors.push(`${benchmarkScriptPath} does not exist. Create it before initializing autoresearch.`);
-	}
-
-	let checksScript: string | null = null;
-	try {
-		checksScript = fs.readFileSync(checksScriptPath, "utf8");
-	} catch {
-		checksScript = null;
-	}
-
+	const benchmarkScript = tryReadFile(benchmarkScriptPath);
 	return {
-		benchmarkScript,
+		benchmarkScript: benchmarkScript ?? "",
 		benchmarkScriptPath,
-		checksScript,
+		checksScript: tryReadFile(checksScriptPath),
 		checksScriptPath,
-		errors,
+		errors:
+			benchmarkScript === null
+				? [`${benchmarkScriptPath} does not exist. Create it before initializing autoresearch.`]
+				: [],
 	};
 }
-
 export function normalizeAutoresearchList(values: readonly string[]): string[] {
 	return [...new Set(values.map(v => v.trim()).filter(Boolean))];
 }
-
 export function normalizeContractPathSpec(value: string): string {
-	const normalized = path.posix.normalize(value.trim().replaceAll("\\", "/"));
-	if (normalized === "." || normalized === "./") return ".";
-	return normalized.replace(/^\.\/+/, "").replace(/\/+$/, "");
+	return normalizeAutoresearchPath(path.posix.normalize(value.trim().replaceAll("\\", "/")));
 }
-
 export function pathMatchesContractPath(pathValue: string, specValue: string): boolean {
 	const normalizedPath = normalizeContractPathSpec(pathValue);
 	const normalizedSpec = normalizeContractPathSpec(specValue);
 	if (normalizedSpec === ".") return true;
 	return normalizedPath === normalizedSpec || normalizedPath.startsWith(`${normalizedSpec}/`);
 }
-
 export function contractListsEqual(left: readonly string[], right: readonly string[]): boolean {
-	return arraysEqual(normalizeAutoresearchList(left), normalizeAutoresearchList(right));
+	const a = normalizeAutoresearchList(left);
+	const b = normalizeAutoresearchList(right);
+	return a.length === b.length && a.every((v, i) => v === b[i]);
 }
-
 export function contractPathListsEqual(left: readonly string[], right: readonly string[]): boolean {
-	return arraysEqual(normalizeContractPathList(left), normalizeContractPathList(right));
-}
-
-function arraysEqual(a: string[], b: string[]): boolean {
+	const norm = (values: readonly string[]) =>
+		normalizeAutoresearchList(values.map(normalizeContractPathSpec)).sort((l, r) => l.localeCompare(r));
+	const a = norm(left);
+	const b = norm(right);
 	return a.length === b.length && a.every((v, i) => v === b[i]);
 }
-function normalizeContractPathList(values: readonly string[]): string[] {
-	return normalizeAutoresearchList(values.map(normalizeContractPathSpec)).sort((left, right) =>
-		left.localeCompare(right),
-	);
-}
-
 function extractSections(markdown: string): Map<string, string> {
 	const sections = new Map<string, string>();
 	let heading: string | null = null;
@@ -136,7 +112,6 @@ function extractSections(markdown: string): Map<string, string> {
 	if (heading) sections.set(heading, content.join("\n").trim());
 	return sections;
 }
-
 function parseBenchmarkSection(section: string): AutoresearchContract["benchmark"] {
 	const entries = new Map<string, string>();
 	const lines = section.split("\n");
@@ -181,7 +156,6 @@ function parseBenchmarkSection(section: string): AutoresearchContract["benchmark
 			: [],
 	};
 }
-
 function parseListSection(section: string, normalizeItem?: (value: string) => string): string[] {
 	const items: string[] = [];
 	let activeItem: string | null = null;
@@ -208,10 +182,6 @@ function parseListSection(section: string, normalizeItem?: (value: string) => st
 	const normalizedItems = normalizeAutoresearchList(items);
 	return normalizeItem ? normalizedItems.map(normalizeItem) : normalizedItems;
 }
-function isUnsafeContractPathSpec(value: string): boolean {
-	return path.posix.isAbsolute(value) || value === ".." || value.startsWith("../");
-}
-
 /**
  * Updates session fields from a validated `autoresearch.md` parse (same fields as `init_experiment`).
  * Does not touch `name`, `currentSegment`, `results`, `bestMetric`, `confidence`, or `maxExperiments`.

package/src/autoresearch/dashboard.ts

@@ -1,7 +1,13 @@
 import { matchesKey, replaceTabs, Text, truncateToWidth, visibleWidth } from "@f5xc-salesdemos/pi-tui";
 import type { Theme } from "../modes/theme/theme";
-import { formatElapsed, formatNum, isBetter } from "./helpers";
-import { currentResults, findBaselineMetric, findBaselineRunNumber, findBaselineSecondary } from "./state";
+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 {
@@ -15,10 +21,8 @@ export function createDashboardController(): DashboardController {
 
 	const clear = (): void => {
 		overlayTui = null;
-		if (spinnerTimer) {
-			clearInterval(spinnerTimer);
-			spinnerTimer = undefined;
-		}
+		clearInterval(spinnerTimer);
+		spinnerTimer = undefined;
 	};
 
 	return {
@@ -117,14 +121,12 @@ export function createDashboardController(): DashboardController {
 		},
 	};
 }
-
 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 ||
@@ -133,7 +135,6 @@ function shouldShowDashboard(runtime: AutoresearchRuntime, state: ExperimentStat
 		runtime.lastRunSummary !== null
 	);
 }
-
 function renderExpandedHeader(runtime: AutoresearchRuntime, width: number, theme: Theme): string {
 	const state = runtime.state;
 	const status = renderModeStatus(runtime, state);
@@ -145,7 +146,6 @@ function renderExpandedHeader(runtime: AutoresearchRuntime, width: number, theme
 		width,
 	);
 }
-
 function renderCollapsedLine(runtime: AutoresearchRuntime, state: ExperimentState, theme: Theme): string {
 	if (runtime.lastRunSummary) {
 		const parts = [
@@ -153,14 +153,13 @@ function renderCollapsedLine(runtime: AutoresearchRuntime, state: ExperimentStat
 			theme.fg("warning", ` pending run #${runtime.lastRunSummary.runNumber}`),
 			theme.fg("dim", runtime.lastRunSummary.passed ? " pass" : " fail"),
 		];
-		if (runtime.lastRunSummary.parsedPrimary !== null) {
+		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("");
@@ -176,7 +175,7 @@ function renderCollapsedLine(runtime: AutoresearchRuntime, state: ExperimentStat
 	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 = findBestResult(state);
+	const best = findBestKeptResult(state);
 	const archivedRuns = Math.max(0, state.results.length - current.length);
 	const parts = [
 		theme.fg("contentAccent", "autoresearch"),
@@ -197,8 +196,7 @@ function renderCollapsedLine(runtime: AutoresearchRuntime, state: ExperimentStat
 	}
 	if (state.confidence !== null) {
 		const confidenceColor = state.confidence >= 2 ? "success" : state.confidence >= 1 ? "warning" : "error";
-		parts.push(theme.fg("dim", " | "));
-		parts.push(theme.fg(confidenceColor, `conf ${state.confidence.toFixed(1)}x`));
+		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)}`));
@@ -208,7 +206,6 @@ function renderCollapsedLine(runtime: AutoresearchRuntime, state: ExperimentStat
 	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) {
@@ -242,7 +239,7 @@ function renderDashboardLines(runtime: AutoresearchRuntime, width: number, theme
 	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 = findBestResult(state);
+	const best = findBestKeptResult(state);
 	const lines = [
 		truncateToWidth(
 			`Current segment: ${current.length} runs  ${kept} kept  ${discarded} discarded  ${crashed} crashed  ${checksFailed} checks_failed`,
@@ -268,28 +265,31 @@ function renderDashboardLines(runtime: AutoresearchRuntime, width: number, theme
 	}
 	if (!runtime.autoresearchMode) lines.push(truncateToWidth(`Mode: ${renderModeStatus(runtime, state)}`, width));
 	if (best) {
-		const bestRunNumber = best.result.runNumber ?? best.index + 1;
-		let progress = `Best: ${formatNum(best.result.metric, state.metricUnit)} (#${bestRunNumber})`;
+		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 =>
-					renderSecondarySummary(
-						metric.name,
-						best.result.metrics[metric.name],
-						baselineSecondary[metric.name],
-						metric.unit,
-					),
-				)
+				.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("");
-	lines.push(renderTableHeader(state, width, theme));
+	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;
@@ -300,15 +300,6 @@ function renderDashboardLines(runtime: AutoresearchRuntime, width: number, theme
 	}
 	return lines;
 }
-
-function renderTableHeader(state: ExperimentState, width: number, theme: Theme): string {
-	const secondaryHeader = state.secondaryMetrics.map(metric => truncateToWidth(metric.name, 10)).join(" ");
-	return 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,
-	);
-}
-
 function renderResultRow(
 	result: ExperimentResult,
 	state: ExperimentState,
@@ -316,7 +307,6 @@ function renderResultRow(
 	width: number,
 	theme: Theme,
 ): string {
-	const runNumber = result.runNumber ?? state.results.indexOf(result) + 1;
 	const secondary = state.secondaryMetrics
 		.map(metric =>
 			truncateToWidth(
@@ -327,7 +317,7 @@ function renderResultRow(
 		.join("");
 	const statusColor = result.status === "keep" ? "success" : result.status === "discard" ? "warning" : "error";
 	const line =
-		theme.fg("dim", String(runNumber).padEnd(4)) +
+		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 +
@@ -335,47 +325,32 @@ function renderResultRow(
 		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 renderSecondarySummary(
-	name: string,
-	value: number | undefined,
-	baseline: number | undefined,
-	unit: string,
-): string | null {
-	if (value === undefined) return null;
-	return `${name} ${renderSecondaryCell(value, unit, 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 {
-	const spinner = theme.spinnerFrames[spinnerFrame % theme.spinnerFrames.length] ?? "*";
 	return truncateToWidth(
 		theme.fg(
 			"warning",
-			`${spinner} running ${formatElapsed(Date.now() - (runtime.runningExperiment?.startedAt ?? Date.now()))} ${replaceTabs(
+			`${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,
@@ -391,20 +366,9 @@ function renderOverlayFooter(
 	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";
 }
-
-function findBestResult(state: ExperimentState): { index: number; result: ExperimentResult } | null {
-	let best: { index: number; result: ExperimentResult } | null = null;
-	for (let index = 0; index < state.results.length; index += 1) {
-		const result = state.results[index];
-		if (result.segment !== state.currentSegment || result.status !== "keep" || result.metric <= 0) continue;
-		if (!best || isBetter(result.metric, best.result.metric, state.bestDirection)) best = { index, result };
-	}
-	return best;
-}

package/src/autoresearch/git.ts

@@ -4,14 +4,11 @@ import { isAutoresearchLocalStatePath, normalizeAutoresearchPath } from "./helpe
 
 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,
@@ -68,17 +65,9 @@ export async function ensureAutoresearchBranch(
 		ok: true,
 	};
 }
-
 export function parseWorkDirDirtyPaths(statusOutput: string, workDirPrefix: string): string[] {
-	const relativePaths: string[] = [];
-	for (const dirtyPath of parseDirtyPaths(statusOutput)) {
-		const relativePath = relativizeGitPathToWorkDir(dirtyPath, workDirPrefix);
-		if (relativePath === null) continue;
-		relativePaths.push(relativePath);
-	}
-	return relativePaths;
+	return parseWorkDirDirtyPathsWithStatus(statusOutput, workDirPrefix).map(e => e.path);
 }
-
 function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPrefix: string): string | null {
 	const normalizedPath = normalizeStatusPath(repoRelativePath);
 	const normalizedPrefix = normalizeAutoresearchPath(workDirPrefix);
@@ -87,16 +76,11 @@ function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPrefix: str
 	if (!normalizedPath.startsWith(`${normalizedPrefix}/`)) return null;
 	return normalizeAutoresearchPath(normalizedPath.slice(normalizedPrefix.length + 1));
 }
-function parseDirtyPaths(statusOutput: string): string[] {
-	return parseDirtyPathsWithStatus(statusOutput).map(entry => entry.path);
-}
-
 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;
@@ -108,49 +92,34 @@ async function allocateBranchName(workDir: string, goal: string | null): Promise
 	return candidate;
 }
 function slugifyGoal(goal: string | null): string {
-	const normalized = (goal ?? "")
+	const slug = (goal ?? "")
 		.toLowerCase()
 		.replace(/[^a-z0-9]+/g, "-")
 		.replace(/^-+|-+$/g, "");
-	const trimmed = normalized.slice(0, BRANCH_NAME_MAX_LENGTH).replace(/-+$/g, "");
-	return trimmed || "session";
+	return slug.slice(0, BRANCH_NAME_MAX_LENGTH).replace(/-+$/g, "") || "session";
 }
 function buildUnsafeDirtyPathsFailure(unsafeDirtyPaths: string[]): EnsureAutoresearchBranchResult {
-	const preview = unsafeDirtyPaths.slice(0, 5).join(", ");
-	const suffix = unsafeDirtyPaths.length > 5 ? ` (+${unsafeDirtyPaths.length - 5} more)` : "";
 	return {
 		error:
 			"Autoresearch needs a clean git worktree before it can create or reuse an isolated branch. " +
-			`Commit or stash these paths first: ${preview}${suffix}`,
+			`Commit or stash these paths first: ${unsafeDirtyPaths.slice(0, 5).join(", ")}${unsafeDirtyPaths.length > 5 ? ` (+${unsafeDirtyPaths.length - 5} more)` : ""}`,
 		ok: false,
 	};
 }
-
-function isRenameOrCopy(statusToken: string): boolean {
-	const trimmed = statusToken.trim();
-	return trimmed.startsWith("R") || trimmed.startsWith("C");
-}
-
 function collectUnsafeDirtyPaths(statusOutput: string, workDirPrefix: string): string[] {
-	const unsafeDirtyPaths: string[] = [];
-	for (const dirtyPath of parseDirtyPaths(statusOutput)) {
-		const relativePath = relativizeGitPathToWorkDir(dirtyPath, workDirPrefix);
-		if (relativePath && isAutoresearchLocalStatePath(relativePath)) continue;
-		unsafeDirtyPaths.push(relativePath ?? normalizeStatusPath(dirtyPath));
-	}
-	return unsafeDirtyPaths;
+	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[] = [];
@@ -162,9 +131,9 @@ function parseDirtyPathsNulWithStatus(statusOutput: string): DirtyPathEntry[] {
 		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 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);
@@ -174,7 +143,6 @@ function parseDirtyPathsNulWithStatus(statusOutput: string): DirtyPathEntry[] {
 	}
 	return results;
 }
-
 function parseDirtyPathsLinesWithStatus(statusOutput: string): DirtyPathEntry[] {
 	const seen = new Set<string>();
 	const results: DirtyPathEntry[] = [];
@@ -192,14 +160,12 @@ function parseDirtyPathsLinesWithStatus(statusOutput: string): DirtyPathEntry[]
 	}
 	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)) {
@@ -209,19 +175,17 @@ export function parseWorkDirDirtyPathsWithStatus(statusOutput: string, workDirPr
 	}
 	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;
-		(entry.untracked ? untracked : tracked).push(entry.path);
-	}
-	return { tracked, untracked };
+	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),
+	};
 }