pi-lens 3.8.39 → 3.8.41

package/clients/read-guard-tool-lines.ts

@@ -4,6 +4,9 @@ import { logReadGuardEvent } from "./read-guard-logger.js";
 
 export interface GuardLineResult {
 	touchedLines: [number, number] | undefined;
+	// Individual ranges for multi-edit calls (e.g. rename at 4 scattered spots).
+	// When set, read-guard checks each range independently instead of the bounding box.
+	editRanges?: [number, number][];
 	preflightError?: string;
 }
 
@@ -98,7 +101,7 @@ function resolveOldTextEdits(
 		if (occurrenceLines.length === 0) {
 			const preview = oldText.trimStart().substring(0, 60).replace(/\n/g, "↵");
 			errors.push(
-				`edits[${editIndex}].oldText ("${preview}") was not found in the current file content. Re-read the file and refresh the edit target before retrying.`,
+				`edits[${editIndex}].oldText ("${preview}") was not found in the current file content. Re-read the relevant section of the file to confirm the exact text, then retry with the verbatim content.`,
 			);
 			logReadGuardEvent({
 				event: "oldtext_not_found",
@@ -154,7 +157,7 @@ function resolveOldTextEdits(
 			errors.length > 0
 				? errors
 				: [
-						"One or more edit targets could not be resolved to exact lines. Re-read the file and retry with more precise oldText context.",
+						"One or more edit targets could not be resolved to exact lines. Re-read the relevant section and retry with the exact content as it appears in the file.",
 					];
 		return {
 			touchedLines: undefined,
@@ -182,6 +185,7 @@ function resolveOldTextEdits(
 		Math.min(...starts),
 		Math.max(...ends),
 	];
+	const editRanges = resolvedRanges.length > 1 ? resolvedRanges : undefined;
 	logReadGuardEvent({
 		event: "touched_lines_detected",
 		sessionId,
@@ -194,7 +198,7 @@ function resolveOldTextEdits(
 			totalEditCount: edits.length,
 		},
 	});
-	return { touchedLines };
+	return { touchedLines, editRanges };
 }
 
 /**
@@ -309,6 +313,7 @@ export function getTouchedLinesForGuard(
 				return { touchedLines: undefined };
 			}
 			let oldTextTouchedLines: [number, number] | undefined;
+			let oldTextEditRanges: [number, number][] | undefined;
 			if (unresolvedOldTextEdits.length > 0 && filePath) {
 				const resolved = resolveOldTextEdits(
 					unresolvedOldTextEdits,
@@ -319,6 +324,7 @@ export function getTouchedLinesForGuard(
 					return resolved;
 				}
 				oldTextTouchedLines = resolved.touchedLines;
+				oldTextEditRanges = resolved.editRanges;
 			}
 			const starts = rangedEdits.map(([start]) => start);
 			const ends = rangedEdits.map(([, end]) => end);
@@ -330,6 +336,13 @@ export function getTouchedLinesForGuard(
 				Math.min(...starts),
 				Math.max(...ends),
 			];
+			const allEditRanges = [...rangedEdits];
+			if (oldTextEditRanges?.length) {
+				allEditRanges.push(...oldTextEditRanges);
+			} else if (oldTextTouchedLines) {
+				allEditRanges.push(oldTextTouchedLines);
+			}
+			const editRanges = allEditRanges.length > 1 ? allEditRanges : undefined;
 			if (filePath) {
 				logReadGuardEvent({
 					event: "touched_lines_detected",
@@ -348,7 +361,7 @@ export function getTouchedLinesForGuard(
 					},
 				});
 			}
-			return { touchedLines };
+			return { touchedLines, editRanges };
 		}
 		if (filePath) {
 			logReadGuardEvent({

package/clients/read-guard.ts

@@ -43,6 +43,7 @@ export interface EditRecord {
 	precedingReads: ReadRecord[];
 	verdict: "allowed" | "blocked" | "warned";
 	reason?: string;
+	timestamp: number;
 }
 
 export interface ReadGuardVerdict {
@@ -78,6 +79,14 @@ const DEFAULT_CONFIG: ReadGuardConfig = {
 	],
 };
 
+const OWN_EDIT_STALE_GRACE_MS = Math.max(
+	0,
+	Number.parseInt(
+		process.env.PI_LENS_READ_GUARD_OWN_EDIT_GRACE_MS ?? "120000",
+		10,
+	) || 120000,
+);
+
 // --- ReadGuard Class ---
 
 export class ReadGuard {
@@ -136,6 +145,7 @@ export class ReadGuard {
 	checkEdit(
 		filePath: string,
 		touchedLines?: [number, number],
+		editRanges?: [number, number][],
 	): ReadGuardVerdict {
 		// Check exemptions
 		if (this.exemptions.has(filePath)) {
@@ -163,7 +173,7 @@ export class ReadGuard {
 		if (!fileReads || fileReads.length === 0) {
 			const verdict = this.blockOrWarn(
 				"zero-read",
-				`🔴 BLOCKED — Edit without read\n\nYou are trying to edit \`${filePath}\` but have not read it in this conversation.\n\nTo proceed:\n  1. Read the file first: \`read path="${filePath}"\`\n  2. Or run \`/lens-allow-edit ${filePath}\` to override (use sparingly)`,
+				`🔴 BLOCKED — Edit without read\n\nYou are trying to edit \`${filePath}\` but have not read it in this conversation.\n\nRead the file first, then retry the edit: \`read path="${filePath}"\``,
 			);
 			this.recordVerdict(filePath, "edit", touchedLines, verdict, {
 				reasonKind: "zero_read",
@@ -172,17 +182,22 @@ export class ReadGuard {
 		}
 
 		// 2. FileTime check (actual staleness)
+		let ignoredOwnEditStaleness = false;
 		if (this.fileTime.hasChanged(filePath)) {
 			const lastRead = fileReads[fileReads.length - 1];
-			const verdict = this.blockOrWarn(
-				"file-modified",
-				`🔴 BLOCKED — File modified since read\n\nYou last read \`${filePath}\` at ${new Date(lastRead.timestamp).toISOString()}.\nThe file has been modified on disk since then (auto-format, external tool, or previous edit).\n\nYour mental model is out of sync with the actual file content.\nTo proceed:\n  1. Re-read the file: \`read path="${filePath}"\``,
-			);
-			this.recordVerdict(filePath, "edit", touchedLines, verdict, {
-				reasonKind: "file_modified",
-				lastReadTimestamp: lastRead.timestamp,
-			});
-			return verdict;
+			if (this.canTreatStalenessAsOwnPriorEdit(filePath, lastRead.timestamp)) {
+				ignoredOwnEditStaleness = true;
+			} else {
+				const verdict = this.blockOrWarn(
+					"file-modified",
+					`🔴 BLOCKED — File modified since read\n\nYou last read \`${filePath}\` at ${new Date(lastRead.timestamp).toISOString()}.\nThe file has been modified on disk since then (auto-format, external tool, or previous edit).\n\nYour mental model is out of sync with the actual file content.\nTo proceed:\n  1. Re-read the file: \`read path="${filePath}"\``,
+				);
+				this.recordVerdict(filePath, "edit", touchedLines, verdict, {
+					reasonKind: "file_modified",
+					lastReadTimestamp: lastRead.timestamp,
+				});
+				return verdict;
+			}
 		}
 
 		// If no line range specified, we can only check zero-read and FileTime
@@ -195,44 +210,51 @@ export class ReadGuard {
 		}
 
 		// 3. Range coverage check
-		const coverage = this.checkCoverage(filePath, touchedLines);
-
-		if (coverage.covered) {
-			const verdict = this.allow();
-			this.recordVerdict(filePath, "edit", touchedLines, verdict, {
-				reasonKind: coverage.viaSymbol ? "symbol_coverage" : "range_coverage",
-				viaSymbol: coverage.viaSymbol,
-			});
-			return verdict;
+		// When the edit touches multiple disjoint spots (e.g. rename across 4 tool
+		// registrations), check each spot independently. Collapsing to a bounding
+		// box would falsely flag reads that cover exactly the right lines.
+		const rangesToCheck: [number, number][] =
+			editRanges && editRanges.length > 1 ? editRanges : [touchedLines];
+
+		let viaSymbol = false;
+		for (const range of rangesToCheck) {
+			const coverage = this.checkCoverage(filePath, range);
+			if (!coverage.covered) {
+				const lastRead = fileReads[fileReads.length - 1];
+				const [editStart, editEnd] = range;
+				const lastReadEnd =
+					lastRead.effectiveOffset + lastRead.effectiveLimit - 1;
+				const verdict = this.blockOrWarn(
+					"out-of-range",
+					`🔴 BLOCKED — Edit outside read range\n\nYou read \`${filePath}\` lines ${lastRead.effectiveOffset}-${lastReadEnd}${lastRead.enclosingSymbol ? ` (${lastRead.enclosingSymbol.kind} \`${lastRead.enclosingSymbol.name}\`)` : ""}, but your edit touches lines ${editStart}-${editEnd}.\n\nRead the relevant section first, then retry the edit:\n  \`read path="${filePath}" offset=${Math.max(1, editStart - 5)} limit=${Math.min(30, editEnd - editStart + 10)}\``,
+					{
+						editRange: range,
+						readRanges: fileReads.map((r) => ({
+							start: r.effectiveOffset,
+							end: r.effectiveOffset + r.effectiveLimit - 1,
+						})),
+						symbolRanges: fileReads
+							.filter((r) => r.enclosingSymbol)
+							.map((r) => ({
+								name: r.enclosingSymbol!.name,
+								start: r.enclosingSymbol!.startLine,
+								end: r.enclosingSymbol!.endLine,
+							})),
+					},
+				);
+				this.recordVerdict(filePath, "edit", touchedLines, verdict, {
+					reasonKind: "out_of_range",
+				});
+				return verdict;
+			}
+			if (coverage.viaSymbol) viaSymbol = true;
 		}
 
-		// Not covered — block or warn
-		const lastRead = fileReads[fileReads.length - 1];
-		const [editStart, editEnd] = touchedLines;
-		const lastReadEnd = lastRead.effectiveOffset + lastRead.effectiveLimit - 1;
-		const symbolCtx = lastRead.enclosingSymbol
-			? ` (${lastRead.enclosingSymbol.kind} \`${lastRead.enclosingSymbol.name}\`)`
-			: "";
-		const verdict = this.blockOrWarn(
-			"out-of-range",
-			`🔴 BLOCKED — Edit outside read range\n\nYou read \`${filePath}\` lines ${lastRead.effectiveOffset}-${lastReadEnd}${symbolCtx}, but your edit touches lines ${editStart}-${editEnd}.\n\nThe edit target is outside the context you previously read.\nTo proceed:\n  1. Read the relevant section: \`read path="${filePath}" offset=${Math.max(1, editStart - 5)} limit=${Math.min(30, editEnd - editStart + 10)}\`\n  2. Or read the full file: \`read path="${filePath}"\``,
-			{
-				editRange: touchedLines,
-				readRanges: fileReads.map((r) => ({
-					start: r.effectiveOffset,
-					end: r.effectiveOffset + r.effectiveLimit - 1,
-				})),
-				symbolRanges: fileReads
-					.filter((r) => r.enclosingSymbol)
-					.map((r) => ({
-						name: r.enclosingSymbol!.name,
-						start: r.enclosingSymbol!.startLine,
-						end: r.enclosingSymbol!.endLine,
-					})),
-			},
-		);
+		const verdict = this.allow();
 		this.recordVerdict(filePath, "edit", touchedLines, verdict, {
-			reasonKind: "out_of_range",
+			reasonKind: viaSymbol ? "symbol_coverage" : "range_coverage",
+			viaSymbol,
+			ignoredOwnEditStaleness,
 		});
 		return verdict;
 	}
@@ -249,6 +271,15 @@ export class ReadGuard {
 		}
 	}
 
+	/**
+	 * Refresh the FileTime stamp after the model's own write lands on disk.
+	 * Call this from the tool_result handler so the next checkEdit on the same
+	 * file doesn't see "file_modified" caused by our own previous edit.
+	 */
+	recordWritten(filePath: string): void {
+		this.fileTime.read(filePath);
+	}
+
 	/**
 	 * Add a one-time exemption for a file.
 	 * Called via /lens-allow-edit command.
@@ -331,6 +362,19 @@ export class ReadGuard {
 
 	// --- Private helpers ---
 
+	private canTreatStalenessAsOwnPriorEdit(
+		filePath: string,
+		lastReadTimestamp: number,
+	): boolean {
+		const edits = this.edits.get(filePath) ?? [];
+		const latest = edits.at(-1);
+		if (!latest) return false;
+		if (latest.verdict !== "allowed" && latest.verdict !== "warned")
+			return false;
+		if (latest.timestamp < lastReadTimestamp) return false;
+		return Date.now() - latest.timestamp <= OWN_EDIT_STALE_GRACE_MS;
+	}
+
 	private checkCoverage(
 		filePath: string,
 		touchedLines: [number, number],
@@ -457,6 +501,7 @@ export class ReadGuard {
 			precedingReads: this.reads.get(filePath) ?? [],
 			verdict: mapVerdictAction(verdict.action),
 			reason: verdict.reason,
+			timestamp: Date.now(),
 		});
 		this.edits.set(filePath, arr);
 	}
@@ -473,7 +518,11 @@ export class ReadGuard {
 		const reads = this.reads.get(filePath) ?? [];
 		logReadGuardEvent({
 			event:
-				verdict.action === "allow" ? "edit_allowed" : (verdict.action === "warn" ? "edit_warned" : "edit_blocked"),
+				verdict.action === "allow"
+					? "edit_allowed"
+					: verdict.action === "warn"
+						? "edit_warned"
+						: "edit_blocked",
 			sessionId: this.sessionId,
 			filePath,
 			metadata: {

package/clients/runtime-agent-end.ts

@@ -84,6 +84,9 @@ export async function handleAgentEnd({
 
 			if (result.formatChanged) {
 				summary.changed.push(filePath);
+				if (!getFlag("no-read-guard")) {
+					runtime.readGuard.recordWritten(filePath);
+				}
 				try {
 					const content = nodeFs.readFileSync(filePath, "utf-8");
 					const lineCount = content.split("\n").length;

package/clients/runtime-session.ts

@@ -5,6 +5,7 @@ import type { BiomeClient } from "./biome-client.js";
 import type { CacheManager } from "./cache-manager.js";
 import type { DependencyChecker } from "./dependency-checker.js";
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
+import { clearAllSessions as clearFileTimeSessions } from "./file-time.js";
 import { getKnipIgnorePatterns } from "./file-utils.js";
 import type { GoClient } from "./go-client.js";
 import type { JscpdClient } from "./jscpd-client.js";
@@ -15,6 +16,7 @@ import {
 	getDefaultStartupTools,
 } from "./language-profile.js";
 import { runLogCleanup } from "./log-cleanup.js";
+import { setSessionLanguages } from "./widget-state.js";
 import { initLSPConfig, loadLSPConfig } from "./lsp/config.js";
 import { getLSPService } from "./lsp/index.js";
 import type { MetricsClient } from "./metrics-client.js";
@@ -440,6 +442,7 @@ export async function handleSessionStart(
 
 	metricsClient.reset();
 	getDiagnosticTracker().reset();
+	clearFileTimeSessions();
 	runtime.complexityBaselines.clear();
 	resetDispatchBaselines();
 	runtime.resetForSession();
@@ -624,6 +627,8 @@ export async function handleSessionStart(
 		}
 	}
 
+	setSessionLanguages(languageProfile.detectedKinds);
+
 	dbg(
 		`session_start total: ${Date.now() - sessionStartMs}ms (interactive path; background tasks may continue)`,
 	);

package/clients/runtime-tool-result.ts

@@ -4,7 +4,9 @@ import * as path from "node:path";
 import type { BiomeClient } from "./biome-client.js";
 import type { CacheManager } from "./cache-manager.js";
 import { createFileTime } from "./file-time.js";
+import type { ReadGuard } from "./read-guard.js";
 import { getFormatService } from "./format-service.js";
+import { isExternalOrVendorFile } from "./path-utils.js";
 import { resolveLanguageRootForFile } from "./language-profile.js";
 import { logLatency } from "./latency-logger.js";
 import type { MetricsClient } from "./metrics-client.js";
@@ -35,6 +37,7 @@ interface ToolResultDeps {
 	resetLSPService: () => void;
 	agentBehaviorRecord: (toolName: string, filePath?: string) => unknown[];
 	formatBehaviorWarnings: (warnings: unknown[]) => string;
+	readGuard?: ReadGuard;
 }
 
 function parseDiffRanges(diff: string): { start: number; end: number }[] {
@@ -77,6 +80,13 @@ const lastAnalyzedStateByFile = new Map<
 	{ turnIndex: number; stateHash: string }
 >();
 
+// Called at turn_start — entries from the previous turn can never match the new
+// turnIndex so they're dead weight. Clearing here keeps the map bounded to the
+// files touched in the current turn only (typically < 20).
+export function clearLastAnalyzedStateCache(): void {
+	lastAnalyzedStateByFile.clear();
+}
+
 function getFileStateHash(filePath: string): string {
 	try {
 		const content = nodeFs.readFileSync(filePath);
@@ -108,7 +118,9 @@ export async function handleToolResult(deps: ToolResultDeps): Promise<{
 	const rawFilePath = (event.input as { path?: string }).path;
 	const workspaceRoot = runtime.projectRoot || process.cwd();
 	const filePath = rawFilePath
-		? (path.isAbsolute(rawFilePath) ? rawFilePath : path.resolve(workspaceRoot, rawFilePath))
+		? path.isAbsolute(rawFilePath)
+			? rawFilePath
+			: path.resolve(workspaceRoot, rawFilePath)
 		: rawFilePath;
 	const behaviorWarnings = agentBehaviorRecord(event.toolName, filePath);
 
@@ -124,6 +136,16 @@ export async function handleToolResult(deps: ToolResultDeps): Promise<{
 		);
 		return;
 	}
+	if (isExternalOrVendorFile(filePath, workspaceRoot)) {
+		dbg(
+			`tool_result: skipped pipeline - file outside project root or in node_modules: ${filePath}`,
+		);
+		return;
+	}
+
+	// Refresh the read-guard's FileTime stamp so that the model's own write
+	// doesn't trigger a spurious "file_modified" block on the next edit.
+	deps.readGuard?.recordWritten(filePath);
 
 	// Keep cachedExports in sync after each write/edit so the pre-write STOP
 	// check doesn't fire on names that were removed from this file this session.
@@ -177,6 +199,14 @@ export async function handleToolResult(deps: ToolResultDeps): Promise<{
 	// tool_result is emitted after write/edit has already been applied.
 	// Asserting pre-write stamps here produces false positives on rapid edits.
 	sessionFileTime.read(filePath);
+	if (!getFlag("no-read-guard")) {
+		const readGuard = (
+			runtime as {
+				readGuard?: { recordWritten?: (writtenPath: string) => void };
+			}
+		).readGuard;
+		readGuard?.recordWritten?.(filePath);
+	}
 
 	const toolResultStart = Date.now();
 	dbg(`tool_result: tracking turn state for ${event.toolName} on ${filePath}`);
@@ -307,6 +337,23 @@ export async function handleToolResult(deps: ToolResultDeps): Promise<{
 		stateHash: getFileStateHash(filePath),
 	});
 
+	// The model's write/edit and pi-lens' own immediate format/autofix are now
+	// reflected on disk. Refresh read-guard staleness stamps so a follow-up edit
+	// is judged by read-range coverage, not by our own previous write.
+	if (!getFlag("no-read-guard")) {
+		const changedForReadGuard = new Set([
+			path.resolve(filePath),
+			...(result.changedFiles ?? []).map((changedFile) =>
+				path.resolve(changedFile),
+			),
+		]);
+		for (const changedFile of changedForReadGuard) {
+			if (nodeFs.existsSync(changedFile)) {
+				deps.readGuard?.recordWritten(changedFile);
+			}
+		}
+	}
+
 	if (
 		!result.isError &&
 		!getFlag("no-autoformat") &&

package/clients/runtime-turn.ts

@@ -11,6 +11,7 @@ import {
 import { getKnipIgnorePatterns } from "./file-utils.js";
 import type { JscpdClient } from "./jscpd-client.js";
 import type { KnipClient, KnipIssue } from "./knip-client.js";
+import { logLatency } from "./latency-logger.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import type { RuntimeCoordinator } from "./runtime-coordinator.js";
 import type { TestRunnerClient } from "./test-runner-client.js";
@@ -117,6 +118,7 @@ export async function handleTurnEnd(deps: TurnEndDeps): Promise<void> {
 		return;
 	}
 
+	const turnEndStart = Date.now();
 	const blockerParts: string[] = [];
 
 	// Merge accumulated cascade results from all pipeline runs this turn.
@@ -124,6 +126,7 @@ export async function handleTurnEnd(deps: TurnEndDeps): Promise<void> {
 	//   1. Primary-level: dedup by primary file (last writer wins).
 	//   2. Neighbor-level: each neighbor is claimed by the latest cascade result
 	//      that covers it — suppresses stale neighbor state from earlier writes.
+	const t0 = Date.now();
 	const cascadeResults = runtime.consumeCascadeResults();
 	if (cascadeResults.length > 0) {
 		const seen = new Map<string, (typeof cascadeResults)[number]>();
@@ -163,7 +166,16 @@ export async function handleTurnEnd(deps: TurnEndDeps): Promise<void> {
 			},
 		});
 	}
-
+	logLatency({
+		type: "phase",
+		toolName: "turn_end",
+		filePath: cwd,
+		phase: "cascade_merge",
+		durationMs: Date.now() - t0,
+		metadata: { resultCount: cascadeResults.length },
+	});
+
+	const t1 = Date.now();
 	if (runtime.isStartupScanInFlight("jscpd")) {
 		dbg("turn_end: skipping jscpd (startup scan still in flight)");
 	} else if (await jscpdClient.ensureAvailable()) {
@@ -238,7 +250,15 @@ export async function handleTurnEnd(deps: TurnEndDeps): Promise<void> {
 			cacheManager.writeCache("jscpd", result, cwd);
 		}
 	}
-
+	logLatency({
+		type: "phase",
+		toolName: "turn_end",
+		filePath: cwd,
+		phase: "jscpd",
+		durationMs: Date.now() - t1,
+	});
+
+	const t2 = Date.now();
 	if (runtime.isStartupScanInFlight("knip")) {
 		dbg("turn_end: skipping knip (startup scan still in flight)");
 	} else if (await knipClient.ensureAvailable()) {
@@ -283,7 +303,15 @@ export async function handleTurnEnd(deps: TurnEndDeps): Promise<void> {
 			}
 		}
 	}
-
+	logLatency({
+		type: "phase",
+		toolName: "turn_end",
+		filePath: cwd,
+		phase: "knip",
+		durationMs: Date.now() - t2,
+	});
+
+	const t3 = Date.now();
 	if (await depChecker.ensureAvailable()) {
 		const madgeFiles = cacheManager.getFilesForMadge(cwd);
 		if (madgeFiles.length > 0) {
@@ -308,6 +336,14 @@ export async function handleTurnEnd(deps: TurnEndDeps): Promise<void> {
 		}
 	}
 
+	logLatency({
+		type: "phase",
+		toolName: "turn_end",
+		filePath: cwd,
+		phase: "madge",
+		durationMs: Date.now() - t3,
+	});
+
 	// --- Test runner: fire once per turn after all edits are done ---
 	// Runs for each unique test target across modified files; results appear
 	// in the next turn's context injection alongside jscpd/madge findings.
@@ -386,7 +422,7 @@ export async function handleTurnEnd(deps: TurnEndDeps): Promise<void> {
 			`turn_end: ${blockerParts.length} blocker section(s) found, persisting for next context`,
 		);
 		const content = capTurnEndMessage(blockerParts.join("\n\n"));
-		const signature = `${files.slice().sort().join("|")}::${content}`;
+		const signature = `${files.slice().sort((a, b) => a.localeCompare(b)).join("|")}::${content}`;
 		const last = cacheManager.readCache<{ signature: string }>(
 			"turn-end-findings-last",
 			cwd,
@@ -407,5 +443,13 @@ export async function handleTurnEnd(deps: TurnEndDeps): Promise<void> {
 	}
 
 	runtime.fixedThisTurn.clear();
+	logLatency({
+		type: "tool_result",
+		toolName: "turn_end",
+		filePath: cwd,
+		durationMs: Date.now() - turnEndStart,
+		result: blockerParts.length > 0 ? "blockers_found" : "clean",
+		metadata: { fileCount: files.length, blockerSections: blockerParts.length },
+	});
 	resetFormatService();
 }

package/clients/sanitize.ts

@@ -244,7 +244,7 @@ export function sanitizeGoOutput(output: string): string {
 
 	return extractDiagnosticLines(output, (line) => {
 		const clean = stripAnsi(line);
-		return /^\.\/|\.go:/.test(clean) || isErrorLine(clean);
+		return /(?:^\.\/)|(?:\.go:)/.test(clean) || isErrorLine(clean);
 	});
 }