@oh-my-pi/pi-coding-agent 15.10.10 → 15.10.11

package/src/edit/hashline/diff.ts

@@ -57,6 +57,39 @@ async function readSectionText(absolutePath: string, sectionPath: string): Promi
 	}
 }
 
+/**
+ * Streaming previews recompute on every streamed chunk; re-reading the target
+ * file from disk each tick dominates the cost on large files. Cache the raw
+ * section text keyed by mtime+size so any on-disk change invalidates
+ * naturally. Used by the streaming path only — the args-complete pass always
+ * reads fresh.
+ */
+const streamingTextCache = new Map<string, { mtimeMs: number; size: number; rawContent: string }>();
+const STREAMING_TEXT_CACHE_MAX = 8;
+
+async function readSectionTextCached(absolutePath: string, sectionPath: string): Promise<string> {
+	let stamp: { mtimeMs: number; size: number } | undefined;
+	try {
+		const stat = await Bun.file(absolutePath).stat();
+		stamp = { mtimeMs: stat.mtimeMs, size: stat.size };
+	} catch {
+		stamp = undefined;
+	}
+	if (stamp) {
+		const cached = streamingTextCache.get(absolutePath);
+		if (cached && cached.mtimeMs === stamp.mtimeMs && cached.size === stamp.size) return cached.rawContent;
+	}
+	const rawContent = await readSectionText(absolutePath, sectionPath);
+	if (stamp) {
+		if (streamingTextCache.size >= STREAMING_TEXT_CACHE_MAX && !streamingTextCache.has(absolutePath)) {
+			const oldest = streamingTextCache.keys().next().value;
+			if (oldest !== undefined) streamingTextCache.delete(oldest);
+		}
+		streamingTextCache.set(absolutePath, { mtimeMs: stamp.mtimeMs, size: stamp.size, rawContent });
+	}
+	return rawContent;
+}
+
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
@@ -220,7 +253,9 @@ export async function computeHashlineSectionDiff(
 ): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
 	try {
 		const absolutePath = resolveToCwd(section.path, cwd);
-		const rawContent = await readSectionText(absolutePath, section.path);
+		const rawContent = options.streaming
+			? await readSectionTextCached(absolutePath, section.path)
+			: await readSectionText(absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
 		// Streaming favors a stable, monotonic preview over an exact unified

package/src/edit/hashline/execute.ts

@@ -78,11 +78,17 @@ interface RenderedSection {
 }
 
 function formatBlockResolution(resolution: BlockResolution): string {
-	const op = resolution.isDelete ? "delete block" : "replace block";
+	const op =
+		resolution.op === "delete"
+			? "delete block"
+			: resolution.op === "insert_after"
+				? "insert after block"
+				: "replace block";
 	const lines = resolution.end - resolution.start + 1;
 	const span =
 		resolution.start === resolution.end ? `line ${resolution.start}` : `lines ${resolution.start}-${resolution.end}`;
-	return `${op} ${resolution.anchorLine} → resolved ${span} (${lines} line${lines === 1 ? "" : "s"})`;
+	const suffix = resolution.op === "insert_after" ? `; body lands after line ${resolution.end}` : "";
+	return `${op} ${resolution.anchorLine} → resolved ${span} (${lines} line${lines === 1 ? "" : "s"})${suffix}`;
 }
 
 function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsResult | undefined): RenderedSection {

package/src/edit/index.ts

@@ -238,8 +238,23 @@ async function executeSinglePathEntries(
 			if (text) contentTexts.push(text);
 		} catch (err) {
 			const errorText = err instanceof Error ? err.message : String(err);
-			contentTexts.push(`Error editing ${path}: ${errorText}`);
+			contentTexts.push(`Error editing ${path} (entry ${i + 1} of ${runs.length}): ${errorText}`);
+			if (i > 0) {
+				contentTexts.push(i === 1 ? `Entry 1 was already applied.` : `Entries 1-${i} were already applied.`);
+			}
+			if (i + 1 < runs.length) {
+				contentTexts.push(
+					(i + 2 === runs.length
+						? `Entry ${runs.length} was NOT applied`
+						: `Entries ${i + 2}-${runs.length} were NOT applied`) +
+						`; re-read the file and re-issue only the failed and unapplied entries.`,
+				);
+			}
 			errorCount++;
+			// Stop at the first failure: later entries were authored against
+			// line numbers/content that assumed this entry succeeded, and
+			// applying them after a failure compounds the damage.
+			break;
 		}
 
 		if (!isLast && onUpdate) {

package/src/edit/modes/patch.ts

@@ -40,6 +40,7 @@ import {
 	countLeadingWhitespace,
 	detectLineEnding,
 	getLeadingWhitespace,
+	normalizeForFuzzy,
 	normalizeToLF,
 	restoreLineEndings,
 	stripBom,
@@ -1007,6 +1008,41 @@ async function readExistingPatchFile(fileSystem: FileSystem, absolutePath: strin
 	}
 }
 
+/**
+ * A prefix/substring strategy matched pattern lines that cover only part of
+ * the corresponding file lines; replacing whole lines would silently drop the
+ * uncovered text the model never saw. Allow the replacement only when every
+ * discarded piece (normalized) survives somewhere in the hunk's new lines.
+ */
+function assertPartialMatchPreservesDiscardedText(
+	path: string,
+	pattern: string[],
+	matchedLines: string[],
+	newLines: string[],
+	matchStartIndex: number,
+): void {
+	let newLinesNorm: string | undefined;
+	for (let j = 0; j < pattern.length; j++) {
+		const lineNorm = normalizeForFuzzy(matchedLines[j]);
+		const patternNorm = normalizeForFuzzy(pattern[j]);
+		if (lineNorm === patternNorm) continue;
+		const at = lineNorm.indexOf(patternNorm);
+		if (at === -1) continue;
+		const discardedParts = [lineNorm.slice(0, at).trim(), lineNorm.slice(at + patternNorm.length).trim()];
+		for (const part of discardedParts) {
+			if (part.length === 0) continue;
+			newLinesNorm ??= newLines.map(normalizeForFuzzy).join("\n");
+			if (!newLinesNorm.includes(part)) {
+				throw new ApplyPatchError(
+					`Refusing partial-line match in ${path} at line ${matchStartIndex + j + 1}: ` +
+						`the file line also contains ${JSON.stringify(part)}, which the replacement would silently drop. ` +
+						`Provide the complete line in the hunk.`,
+				);
+			}
+		}
+	}
+}
+
 /**
  * Compute replacements needed to transform originalLines using the diff hunks.
  */
@@ -1253,6 +1289,18 @@ function computeReplacements(
 		if (searchResult.strategy === "fuzzy-dominant") {
 			const similarity = Math.round(searchResult.confidence * 100);
 			warnings.push(`Dominant fuzzy match selected in ${path} near line ${found + 1} (${similarity}% similar).`);
+		} else if (
+			searchResult.strategy === "comment-prefix" ||
+			searchResult.strategy === "prefix" ||
+			searchResult.strategy === "substring" ||
+			searchResult.strategy === "fuzzy" ||
+			searchResult.strategy === "character"
+		) {
+			const similarity = Math.round(searchResult.confidence * 100);
+			warnings.push(
+				`Inexact match in ${path} near line ${found + 1}: matched via ${searchResult.strategy} strategy ` +
+					`(${similarity}% similar). Re-read the file if the result is not what you intended.`,
+			);
 		}
 
 		// Reject if match is ambiguous (prefix/substring matching found multiple matches)
@@ -1305,6 +1353,10 @@ function computeReplacements(
 			continue;
 		}
 
+		if (searchResult.strategy === "prefix" || searchResult.strategy === "substring") {
+			assertPartialMatchPreservesDiscardedText(path, pattern, actualMatchedLines, newSlice, found);
+		}
+
 		const adjustedNewLines = adjustLinesIndentation(pattern, actualMatchedLines, newSlice);
 		replacements.push({ startIndex: found, oldLen: pattern.length, newLines: adjustedNewLines });
 		lineIndex = found + pattern.length;

package/src/edit/modes/replace.ts

@@ -525,29 +525,45 @@ function matchesAt(lines: string[], pattern: string[], i: number, compare: (a: s
 	return true;
 }
 
-/** Compute average similarity score for pattern at position */
-function fuzzyScoreAt(lines: string[], pattern: string[], i: number): number {
+/**
+ * Compute average similarity score for pre-normalized pattern lines at
+ * position `i` of pre-normalized file lines.
+ *
+ * `minScore` is a bail threshold: when even perfect similarity on the
+ * remaining lines cannot lift the average to `minScore`, returns the partial
+ * average early (always ≤ the true score). The length-difference lower bound
+ * on Levenshtein distance is used to skip the DP entirely for line pairs the
+ * bail test already rules out.
+ */
+function fuzzyScoreAt(linesNorm: string[], patternNorm: string[], i: number, minScore = 0): number {
+	const count = patternNorm.length;
 	let totalScore = 0;
-	for (let j = 0; j < pattern.length; j++) {
-		const lineNorm = normalizeForFuzzy(lines[i + j]);
-		const patternNorm = normalizeForFuzzy(pattern[j]);
-		totalScore += similarity(lineNorm, patternNorm);
+	for (let j = 0; j < count; j++) {
+		const lineNorm = linesNorm[i + j];
+		const patNorm = patternNorm[j];
+		if (lineNorm === patNorm) {
+			totalScore += 1;
+			continue;
+		}
+		const remaining = count - j - 1;
+		const maxLen = Math.max(lineNorm.length, patNorm.length);
+		// similarity ≤ 1 − |lenA−lenB|/maxLen: test the bound before the DP.
+		const upperBound = 1 - Math.abs(lineNorm.length - patNorm.length) / maxLen;
+		if ((totalScore + upperBound + remaining) / count < minScore) return totalScore / count;
+		if (upperBound > 0) totalScore += similarity(lineNorm, patNorm);
+		if ((totalScore + remaining) / count < minScore) return totalScore / count;
 	}
-	return totalScore / pattern.length;
+	return totalScore / count;
 }
 
-/** Check if line starts with pattern (normalized) */
-function lineStartsWithPattern(line: string, pattern: string): boolean {
-	const lineNorm = normalizeForFuzzy(line);
-	const patternNorm = normalizeForFuzzy(pattern);
+/** Check if pre-normalized line starts with pre-normalized pattern */
+function normStartsWith(lineNorm: string, patternNorm: string): boolean {
 	if (patternNorm.length === 0) return lineNorm.length === 0;
 	return lineNorm.startsWith(patternNorm);
 }
 
-/** Check if line contains pattern as significant substring */
-function lineIncludesPattern(line: string, pattern: string): boolean {
-	const lineNorm = normalizeForFuzzy(line);
-	const patternNorm = normalizeForFuzzy(pattern);
+/** Check if pre-normalized line contains pre-normalized pattern as significant substring */
+function normIncludes(lineNorm: string, patternNorm: string): boolean {
 	if (patternNorm.length === 0) return lineNorm.length === 0;
 	if (patternNorm.length < PARTIAL_MATCH_MIN_LENGTH) return false;
 	if (!lineNorm.includes(patternNorm)) return false;
@@ -613,6 +629,13 @@ export function seekSequence(
 	const searchStart = eof && lines.length >= pattern.length ? lines.length - pattern.length : start;
 	const maxStart = lines.length - pattern.length;
 
+	// Fuzzy and partial passes compare normalizeForFuzzy forms; normalize the
+	// file and pattern once per call instead of once per candidate position.
+	let linesNormCache: string[] | undefined;
+	let patternNormCache: string[] | undefined;
+	const getLinesNorm = () => (linesNormCache ??= lines.map(normalizeForFuzzy));
+	const getPatternNorm = () => (patternNormCache ??= pattern.map(normalizeForFuzzy));
+
 	const runExactPasses = (from: number, to: number): SequenceSearchResult | undefined => {
 		const comparisonPasses: Array<{
 			compare: (a: string, b: string) => boolean;
@@ -646,17 +669,19 @@ export function seekSequence(
 			return undefined;
 		}
 
+		const linesNorm = getLinesNorm();
+		const patternNorm = getPatternNorm();
 		const partialPasses: Array<{
-			compare: (line: string, patternLine: string) => boolean;
+			compare: (lineNorm: string, patternLineNorm: string) => boolean;
 			confidence: number;
 			strategy: SequenceMatchStrategy;
 		}> = [
-			{ compare: lineStartsWithPattern, confidence: 0.965, strategy: "prefix" },
-			{ compare: lineIncludesPattern, confidence: 0.94, strategy: "substring" },
+			{ compare: normStartsWith, confidence: 0.965, strategy: "prefix" },
+			{ compare: normIncludes, confidence: 0.94, strategy: "substring" },
 		];
 
 		for (const pass of partialPasses) {
-			const matches = collectIndexedMatches(from, to, i => matchesAt(lines, pattern, i, pass.compare));
+			const matches = collectIndexedMatches(from, to, i => matchesAt(linesNorm, patternNorm, i, pass.compare));
 			const result = toAmbiguousMatchResult(matches, pass.confidence, pass.strategy);
 			if (result) {
 				return result;
@@ -692,9 +717,14 @@ export function seekSequence(
 		matchIndices: [],
 	};
 
+	const fuzzyLinesNorm = getLinesNorm();
+	const fuzzyPatternNorm = getPatternNorm();
+	// Positions scoring below this can neither become a fuzzy match nor affect
+	// the dominant-fuzzy gap test; let fuzzyScoreAt bail early on them.
+	const fuzzyBail = SEQUENCE_FUZZY_THRESHOLD - DOMINANT_FUZZY_DELTA;
 	const scoreFuzzyRange = (from: number, to: number): void => {
 		for (let i = from; i <= to; i++) {
-			const score = fuzzyScoreAt(lines, pattern, i);
+			const score = fuzzyScoreAt(fuzzyLinesNorm, fuzzyPatternNorm, i, fuzzyBail);
 			if (score >= SEQUENCE_FUZZY_THRESHOLD) {
 				if (fuzzyMatches.firstMatch === undefined) {
 					fuzzyMatches.firstMatch = i;
@@ -787,12 +817,16 @@ export function findClosestSequenceMatch(
 	const eof = options?.eof ?? false;
 	const maxStart = lines.length - pattern.length;
 	const searchStart = eof && lines.length >= pattern.length ? maxStart : start;
+	const linesNorm = lines.map(normalizeForFuzzy);
+	const patternNorm = pattern.map(normalizeForFuzzy);
 
 	let bestIndex: number | undefined;
 	let bestScore = 0;
 
+	// Passing the running best as the bail threshold is exact: a bailed
+	// position returns a value strictly below it, so it can never win.
 	for (let i = searchStart; i <= maxStart; i++) {
-		const score = fuzzyScoreAt(lines, pattern, i);
+		const score = fuzzyScoreAt(linesNorm, patternNorm, i, bestScore);
 		if (score > bestScore) {
 			bestScore = score;
 			bestIndex = i;
@@ -801,7 +835,7 @@ export function findClosestSequenceMatch(
 
 	if (eof && searchStart > start) {
 		for (let i = start; i < searchStart; i++) {
-			const score = fuzzyScoreAt(lines, pattern, i);
+			const score = fuzzyScoreAt(linesNorm, patternNorm, i, bestScore);
 			if (score > bestScore) {
 				bestScore = score;
 				bestIndex = i;

package/src/edit/notebook.ts

@@ -21,6 +21,26 @@ export interface NotebookDocument {
 }
 
 const CELL_MARKER_RE = /^# %% \[(code|markdown|raw)\](?: cell:(\d+))?$/;
+/**
+ * Cell source lines that would themselves parse as (possibly already-escaped)
+ * cell markers gain one extra `%` on render and lose it on parse, so a
+ * notebook that *contains* the literal text `# %% [markdown] cell:3` survives
+ * the editable-text round trip instead of being split into extra cells.
+ */
+const ESCAPABLE_MARKER_RE = /^# %%+ \[(?:code|markdown|raw)\](?: cell:\d+)?$/;
+const ESCAPED_MARKER_RE = /^# %%%+ \[(?:code|markdown|raw)\](?: cell:\d+)?$/;
+
+function escapeMarkerLikeSourceLines(source: string): string {
+	if (!source.includes("# %%")) return source;
+	return source
+		.split("\n")
+		.map(line => (ESCAPABLE_MARKER_RE.test(line) ? line.replace("# %", "# %%") : line))
+		.join("\n");
+}
+
+function unescapeMarkerLikeLine(line: string): string {
+	return ESCAPED_MARKER_RE.test(line) ? line.replace("# %%", "# %") : line;
+}
 
 export function isNotebookPath(filePath: string): boolean {
 	return path.extname(filePath).toLowerCase() === ".ipynb";
@@ -100,7 +120,7 @@ export async function readNotebookDocument(absolutePath: string, displayPath: st
 export function notebookToEditableText(notebook: NotebookDocument): string {
 	return notebook.cells
 		.map((cell, index) => {
-			const source = sourceToText(cell.source);
+			const source = escapeMarkerLikeSourceLines(sourceToText(cell.source));
 			return source.length > 0
 				? `# %% [${cell.cell_type}] cell:${index}\n${source}`
 				: `# %% [${cell.cell_type}] cell:${index}`;
@@ -156,7 +176,7 @@ function parseNotebookEditableText(text: string, displayPath: string): ParsedVir
 				`Invalid notebook editable representation for ${displayPath}: expected first line to be "# %% [code] cell:0", "# %% [markdown] cell:0", or "# %% [raw] cell:0".`,
 			);
 		}
-		current.lines.push(line);
+		current.lines.push(unescapeMarkerLikeLine(line));
 	}
 	flush();
 	return cells;

package/src/edit/renderer.ts

@@ -261,7 +261,6 @@ function renderEditHeader(
 	options: {
 		icon: "pending" | "success" | "error";
 		iconOverride?: string;
-		spinnerFrame?: number;
 		op?: Operation;
 		rawPath: string;
 		rename?: string;
@@ -284,7 +283,6 @@ function renderEditHeader(
 			{
 				icon: options.icon,
 				iconOverride: options.iconOverride,
-				spinnerFrame: options.spinnerFrame,
 				title,
 				description,
 			},
@@ -322,6 +320,7 @@ function formatStreamingDiff(
 	uiTheme: Theme,
 	expanded: boolean,
 	label = "streaming",
+	spinnerFrame?: number,
 ): string {
 	if (!diff) return "";
 	// Collapsed uses a "Cursor" tail window: pin the last
@@ -342,11 +341,26 @@ function formatStreamingDiff(
 		text += `${uiTheme.fg("dim", `… (${remainder.join(", ")} above)`)}\n`;
 	}
 	text += renderDiffColored(visible.join("\n"), { filePath: rawPath });
-	if (!expanded || label !== "preview") text += uiTheme.fg("dim", `\n(${label})`);
+	// The animated glyph rides this trailing line — inside the transcript's
+	// volatile-tail holdback — never the block header: an animating head row
+	// pins the native-scrollback commit boundary at the top of the block, so a
+	// tall expanded preview could never scroll-append mid-stream.
+	const spinner = spinnerFrame !== undefined ? `${formatStatusIcon("running", uiTheme, spinnerFrame)} ` : "";
+	// Expanded approval previews hide the "(preview)" label (#1992) but keep
+	// the animated glyph when one is active so the volatile tail stays live.
+	const hideLabel = expanded && label === "preview";
+	if (spinner || !hideLabel) {
+		text += `\n${hideLabel ? spinner.trimEnd() : `${spinner}${uiTheme.fg("dim", `(${label})`)}`}`;
+	}
 	return text;
 }
 
-function formatMultiFileStreamingDiff(previews: PerFileDiffPreview[], uiTheme: Theme, expanded: boolean): string {
+function formatMultiFileStreamingDiff(
+	previews: PerFileDiffPreview[],
+	uiTheme: Theme,
+	expanded: boolean,
+	spinnerFrame?: number,
+): string {
 	const parts: string[] = [];
 	for (const preview of previews) {
 		if (!preview.diff && !preview.error) continue;
@@ -356,7 +370,13 @@ function formatMultiFileStreamingDiff(previews: PerFileDiffPreview[], uiTheme: T
 			continue;
 		}
 		if (preview.diff) {
-			parts.push(`${header}${formatStreamingDiff(preview.diff, preview.path, uiTheme, expanded, "preview")}`);
+			// Only the last file's preview carries the animated streaming glyph;
+			// earlier files have settled and must stay byte-stable so their rows
+			// can commit to native scrollback mid-stream.
+			const isLast = preview === previews[previews.length - 1];
+			parts.push(
+				`${header}${formatStreamingDiff(preview.diff, preview.path, uiTheme, expanded, "preview", isLast ? spinnerFrame : undefined)}`,
+			);
 		}
 	}
 	return parts.join("");
@@ -368,16 +388,17 @@ function getCallPreview(
 	uiTheme: Theme,
 	renderContext: EditRenderContext | undefined,
 	expanded: boolean,
+	spinnerFrame?: number,
 ): string {
 	const multi = renderContext?.perFileDiffPreview;
 	if (multi && multi.length > 1 && multi.some(p => p.diff || p.error)) {
-		return formatMultiFileStreamingDiff(multi, uiTheme, expanded);
+		return formatMultiFileStreamingDiff(multi, uiTheme, expanded, spinnerFrame);
 	}
 	if (args.previewDiff) {
-		return formatStreamingDiff(args.previewDiff, rawPath, uiTheme, expanded, "preview");
+		return formatStreamingDiff(args.previewDiff, rawPath, uiTheme, expanded, "preview", spinnerFrame);
 	}
 	if (args.diff && args.op) {
-		return formatStreamingDiff(args.diff, rawPath, uiTheme, expanded);
+		return formatStreamingDiff(args.diff, rawPath, uiTheme, expanded, "streaming", spinnerFrame);
 	}
 	if (args.diff) {
 		return renderPlainTextPreview(args.diff, uiTheme, rawPath);
@@ -554,15 +575,20 @@ export const editToolRenderer = {
 			fileCount = countEditFiles(editArgs.edits);
 		}
 		return framedBlock(uiTheme, width => {
+			// Static pending icon, never the animated glyph: the header is the
+			// head row of the framed block, and native-scrollback commits are
+			// prefix-only — an animating head row would pin the commit boundary
+			// at the top and keep a tall expanded preview from scroll-appending
+			// mid-stream. The liveness cue rides the trailing "(preview)" /
+			// "(streaming)" line instead.
 			const header = renderEditHeader(width, uiTheme, {
 				icon: "pending",
-				spinnerFrame: options?.spinnerFrame,
 				op,
 				rawPath,
 				rename,
 				extraSuffix: fileCount > 1 ? uiTheme.fg("dim", ` (+${fileCount - 1} more)`) : undefined,
 			});
-			let body = getCallPreview(editArgs, rawPath, uiTheme, renderContext, options.expanded);
+			let body = getCallPreview(editArgs, rawPath, uiTheme, renderContext, options.expanded, options?.spinnerFrame);
 			if (applyPatchSummary?.error) {
 				body += `\n${uiTheme.fg("error", truncateToWidth(replaceTabs(applyPatchSummary.error, rawPath), Math.max(1, width - 2)))}`;
 			}

package/src/eval/__tests__/completion-bridge.test.ts

@@ -38,7 +38,7 @@ const SLOW = makeModel("p", "slow");
 const REASONING_SLOW = makeModel("p", "slow", {
 	api: "anthropic-messages",
 	reasoning: true,
-	thinking: { minLevel: Effort.Low, maxLevel: Effort.High, mode: "anthropic-adaptive" },
+	thinking: { efforts: [Effort.Low, Effort.Medium, Effort.High], mode: "anthropic-adaptive" },
 });
 
 interface SessionOptions {

package/src/eval/backend.ts

@@ -20,8 +20,6 @@ export interface ExecutorBackendExecOptions {
 	 */
 	idleTimeoutMs: number;
 	reset: boolean;
-	artifactPath: string | undefined;
-	artifactId: string | undefined;
 	onChunk: (chunk: string) => void;
 	/**
 	 * Live status events (read/write/agent/…) delivered as they are emitted,

package/src/eval/completion-bridge.ts

@@ -12,7 +12,8 @@
  * in, text (or, with `schema`, a structured object) out.
  */
 import { instrumentedCompleteSimple, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
-import { type Api, Effort, getSupportedEfforts, type Model, type Tool } from "@oh-my-pi/pi-ai";
+import { type Api, Effort, type Model, type Tool } from "@oh-my-pi/pi-ai";
+import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
 import * as z from "zod/v4";
 import { extractTextContent, extractToolCall, parseJsonPayload } from "../commit/utils";
 

package/src/eval/idle-timeout.ts

@@ -6,8 +6,6 @@
  * `agent()`/`parallel()`/`completion()` work is ignored completely, then {@link resume}
  * starts a fresh timeout window once the runtime gets control back.
  *
- * The active timer self-reschedules instead of being torn down on every
- * activity event, so frequent activity costs one timestamp write per event.
  * Pause is reference-counted because `parallel()` can have multiple bridge calls
  * in flight at once.
  */
@@ -36,11 +34,6 @@ export class IdleTimeout {
 		return this.#idleMs;
 	}
 
-	/** Record runtime activity, pushing the active deadline forward by `idleMs`. */
-	bump(): void {
-		if (this.#settled || this.#pauseDepth > 0) return;
-		this.#deadlineMs = Date.now() + this.#idleMs;
-	}
 	/** Suspend timeout accounting while control is delegated to host-side work. */
 	pause(): void {
 		if (this.#settled) return;
@@ -86,8 +79,8 @@ export class IdleTimeout {
 		if (this.#settled || this.#pauseDepth > 0) return;
 		const remainingMs = this.#deadlineMs - Date.now();
 		if (remainingMs > 0) {
-			// A bump moved the deadline forward after this timer was armed; wait
-			// out the remaining window instead of firing early.
+			// The deadline moved forward (resume re-arming) after this timer was
+			// armed; wait out the remaining window instead of firing early.
 			this.#arm(remainingMs);
 			return;
 		}

package/src/eval/js/context-manager.ts

@@ -1,13 +1,10 @@
-import { isCompiledBinary, logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { logger, Snowflake, workerHostEntry } from "@oh-my-pi/pi-utils";
 import type { ToolSession } from "../../tools";
 import { ToolAbortError, ToolError } from "../../tools/tool-errors";
 import { callSessionTool, type JsStatusEvent } from "./tool-bridge";
 import { WorkerCore } from "./worker-core";
-// Worker entry. See `tab-supervisor.ts` for the rationale behind the
-// literal-string + `new URL(import.meta.url)` hybrid: the literal is what
-// Bun's `--compile` bundler discovers, the `new URL` form is what makes dev
-// runs portable across cwds. The worker is registered as an additional
-// `--compile` entrypoint in `scripts/build-binary.ts`.
+// Coding-agent binary/bundle workers route through the CLI entrypoint with a
+// hidden argv mode, so compiled/npm builds only need one JavaScript entry.
 import type {
 	JsDisplayOutput,
 	RunErrorPayload,
@@ -384,8 +381,9 @@ async function raceWithTimeout<T>(promise: Promise<T>, timeoutMs: number, reason
 
 async function spawnJsWorker(): Promise<WorkerHandle> {
 	try {
-		const worker = isCompiledBinary()
-			? new Worker("./packages/coding-agent/src/eval/js/worker-entry.ts", { type: "module" })
+		const hostEntry = workerHostEntry();
+		const worker = hostEntry
+			? new Worker(hostEntry, { type: "module", argv: ["__omp_js_eval_worker"] })
 			: new Worker(new URL("./worker-entry.ts", import.meta.url).href, { type: "module" });
 		return wrapBunWorker(worker);
 	} catch (err) {

package/src/eval/js/executor.ts

@@ -63,9 +63,13 @@ function isTimeoutReason(reason: unknown): boolean {
 }
 
 function formatJsTimeoutAnnotation(timeoutMs: number | undefined): string {
-	if (timeoutMs === undefined) return "Command timed out";
+	// Timeout cancellation force-kills the worker (the only way to interrupt
+	// synchronous user code), which discards the persistent VM state. Say so,
+	// or the model will keep referencing variables that no longer exist.
+	const reset = "The JS worker was force-killed and its VM state was reset; variables from earlier cells are gone.";
+	if (timeoutMs === undefined) return `Command timed out. ${reset}`;
 	const secs = Math.max(1, Math.round(timeoutMs / 1000));
-	return `Command timed out after ${secs} seconds`;
+	return `Command timed out after ${secs} seconds. ${reset}`;
 }
 
 export async function executeJs(code: string, options: JsExecutorOptions): Promise<JsResult> {

package/src/eval/js/index.ts

@@ -30,8 +30,6 @@ export default {
 			sessionId: namespaceSessionId(opts.sessionId),
 			sessionFile: opts.sessionFile,
 			reset: opts.reset,
-			artifactPath: opts.artifactPath,
-			artifactId: opts.artifactId,
 			onChunk: opts.onChunk,
 			onStatus: opts.onStatus,
 			session: opts.session,

package/src/eval/js/shared/helpers.ts

@@ -83,12 +83,11 @@ export function createHelpers(ctx: HelperContext): HelperBundle {
 		},
 		append: async (rawPath, content) => {
 			const target = resolveHelperPath(ctx, rawPath, "write");
-			await Bun.write(
-				target,
-				`${await Bun.file(target)
-					.text()
-					.catch(() => "")}${content}`,
-			);
+			// O(1) append; read-all+rewrite both raced concurrent writers and went
+			// quadratic when called in a loop. Bun.write creates parent dirs, so
+			// keep that behavior for the append path too.
+			await fs.promises.mkdir(path.dirname(target), { recursive: true });
+			await fs.promises.appendFile(target, content, "utf-8");
 			ctx.emitStatus({
 				op: "append",
 				path: target,

package/src/eval/js/shared/local-module-loader.ts

@@ -102,7 +102,7 @@ export class LocalModuleLoader {
 		});
 		const moduleDir = path.dirname(modulePath);
 		const localDeps = new Set<string>();
-		for (const specifier of collectModuleSourceSpecifiers(stripped)) {
+		for (const specifier of await collectModuleSourceSpecifiers(stripped)) {
 			const resolved = resolveImportSpecifier(moduleDir, specifier);
 			if (isLocalPathSpecifier(specifier) && isManagedLocalModulePath(resolved)) {
 				localDeps.add(resolved);