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

package/src/edit/diff.ts

@@ -55,13 +55,10 @@ function formatNumberedDiffLine(prefix: "+" | "-" | " ", lineNum: number, conten
 	return `${prefix}${lineNum}|${content}`;
 }
 
-type DiffSource = "old" | "new";
-
 interface ParsedNumberedDiffRow {
 	prefix: "+" | "-" | " ";
 	lineNumber: number;
 	content: string;
-	source: DiffSource;
 }
 
 function parseNumberedDiffRow(row: string): ParsedNumberedDiffRow | undefined {
@@ -70,18 +67,56 @@ function parseNumberedDiffRow(row: string): ParsedNumberedDiffRow | undefined {
 	const prefix = match[1] as "+" | "-" | " ";
 	const lineNumber = Number.parseInt(match[2], 10);
 	if (!Number.isFinite(lineNumber)) return undefined;
-	return {
-		prefix,
-		lineNumber,
-		content: match[3] ?? "",
-		source: prefix === "+" ? "new" : "old",
-	};
+	return { prefix, lineNumber, content: match[3] ?? "" };
 }
 
 function isDiffChangeRow(row: string | undefined): boolean {
 	return row !== undefined && (row.startsWith("+") || row.startsWith("-"));
 }
 
+/** Blank row separating non-contiguous regions of a numbered diff. */
+const DIFF_GAP_ROW = "";
+
+/** Old-file line number of a source-visible row (`-` or context); `+`/gap/other rows yield undefined. */
+function parseSourceRowLineNumber(row: string): number | undefined {
+	const parsed = parseNumberedDiffRow(row);
+	return parsed === undefined || parsed.prefix === "+" ? undefined : parsed.lineNumber;
+}
+
+/**
+ * Drop gap rows that no longer separate anything. Context rows are inserted
+ * one at a time, each adding its own gap rows from a snapshot of the diff, so
+ * the raw result can contain adjacent gap rows, gap rows whose neighbors
+ * became contiguous after a later insert filled the hole, and gap rows at the
+ * diff edges. The sweep keeps a gap row only when it sits between two
+ * source-numbered rows (old-file coordinates — the same numbering the
+ * insertion gap test uses) that are actually non-contiguous, and never keeps
+ * two in a row.
+ */
+function normalizeDiffGapRows(rows: string[]): void {
+	const kept: string[] = [];
+	for (let i = 0; i < rows.length; i++) {
+		const row = rows[i];
+		if (row !== DIFF_GAP_ROW) {
+			kept.push(row);
+			continue;
+		}
+		if (kept.length === 0 || kept[kept.length - 1] === DIFF_GAP_ROW) continue;
+		let before: number | undefined;
+		for (let j = kept.length - 1; j >= 0 && before === undefined; j--) {
+			before = parseSourceRowLineNumber(kept[j]);
+		}
+		let after: number | undefined;
+		for (let j = i + 1; j < rows.length && after === undefined; j++) {
+			if (rows[j] === DIFF_GAP_ROW) continue;
+			after = parseSourceRowLineNumber(rows[j]);
+		}
+		if (before === undefined || after === undefined || after <= before + 1) continue;
+		kept.push(row);
+	}
+	if (kept.length !== rows.length) rows.splice(0, rows.length, ...kept);
+}
+
 function adjustedContextInsertIndex(rows: readonly string[], index: number): number {
 	let start = index;
 	while (start > 0 && isDiffChangeRow(rows[start - 1])) start--;
@@ -92,7 +127,6 @@ function adjustedContextInsertIndex(rows: readonly string[], index: number): num
 
 function insertBracketContextRows(
 	rows: string[],
-	source: DiffSource,
 	contextLines: ReadonlyMap<number, string>,
 	seenRows: Set<string>,
 ): void {
@@ -106,7 +140,7 @@ function insertBracketContextRows(
 		let nextSourceLine: number | undefined;
 		for (let i = 0; i < rows.length; i++) {
 			const parsed = parseNumberedDiffRow(rows[i]);
-			if (!parsed || parsed.source !== source) continue;
+			if (!parsed || parsed.prefix === "+") continue;
 			if (parsed.lineNumber < lineNumber) {
 				previousSourceLine = parsed.lineNumber;
 				continue;
@@ -117,16 +151,26 @@ function insertBracketContextRows(
 		}
 
 		const chunk: string[] = [];
-		if (previousSourceLine !== undefined && lineNumber > previousSourceLine + 1) chunk.push("...");
+		if (previousSourceLine !== undefined && lineNumber > previousSourceLine + 1) chunk.push(DIFF_GAP_ROW);
 		chunk.push(row);
-		if (nextSourceLine !== undefined && nextSourceLine > lineNumber + 1) chunk.push("...");
+		if (nextSourceLine !== undefined && nextSourceLine > lineNumber + 1) chunk.push(DIFF_GAP_ROW);
 
 		const adjustedIndex = adjustedContextInsertIndex(rows, insertIndex);
 		rows.splice(adjustedIndex, 0, ...chunk);
-		for (const inserted of chunk) seenRows.add(inserted);
+		seenRows.add(row);
 	}
 }
 
+/**
+ * Insert off-window block-boundary rows (enclosing header, matching closing
+ * bracket, …) into a numbered diff. Context rows carry pre-edit line numbers —
+ * the renumbering contract of `buildCompactDiffPreview` — so boundary lines
+ * discovered in the new file are translated back to their pre-edit numbers
+ * and merged with the old-file pass before a single insertion sweep. Without
+ * the translation, a context line sitting in a net-offset region would be
+ * re-inserted under its post-edit number: duplicated, out of order, and
+ * renumbered incorrectly by the preview.
+ */
 function addMatchingBracketContextRows(
 	rows: string[],
 	oldLines: readonly string[],
@@ -136,16 +180,49 @@ function addMatchingBracketContextRows(
 	const oldVisible: number[] = [];
 	const newVisible: number[] = [];
 	const seenRows = new Set(rows);
+	// Change positions in new-file coordinates, used to translate an unchanged
+	// new-file line number back to its pre-edit equivalent.
+	const changes: { newPos: number; delta: 1 | -1 }[] = [];
+	let offset = 0;
 
 	for (const row of rows) {
 		const parsed = parseNumberedDiffRow(row);
 		if (!parsed) continue;
-		if (parsed.source === "old") oldVisible.push(parsed.lineNumber);
-		else newVisible.push(parsed.lineNumber);
+		switch (parsed.prefix) {
+			case "-":
+				oldVisible.push(parsed.lineNumber);
+				changes.push({ newPos: parsed.lineNumber + offset, delta: -1 });
+				offset--;
+				break;
+			case "+":
+				newVisible.push(parsed.lineNumber);
+				changes.push({ newPos: parsed.lineNumber, delta: 1 });
+				offset++;
+				break;
+			default:
+				// Context rows are visible in BOTH files: pre-edit number as
+				// written, post-edit number shifted by the net change so far.
+				oldVisible.push(parsed.lineNumber);
+				newVisible.push(parsed.lineNumber + offset);
+				break;
+		}
 	}
 
-	insertBracketContextRows(rows, "old", findBlockContextLines(oldLines, oldVisible, source), seenRows);
-	insertBracketContextRows(rows, "new", findBlockContextLines(newLines, newVisible, source), seenRows);
+	const toOldLineNumber = (newLineNumber: number): number => {
+		let shift = 0;
+		for (const change of changes) {
+			if (change.newPos <= newLineNumber) shift += change.delta;
+		}
+		return newLineNumber - shift;
+	};
+
+	const contextRows = findBlockContextLines(oldLines, oldVisible, source);
+	for (const [lineNumber, text] of findBlockContextLines(newLines, newVisible, source)) {
+		const oldLineNumber = toOldLineNumber(lineNumber);
+		if (!contextRows.has(oldLineNumber)) contextRows.set(oldLineNumber, text);
+	}
+	insertBracketContextRows(rows, contextRows, seenRows);
+	normalizeDiffGapRows(rows);
 }
 
 /**

package/src/edit/hashline/block-resolver.ts

@@ -8,7 +8,26 @@
 import type { BlockResolver } from "@oh-my-pi/hashline";
 import { blockRangeAt } from "@oh-my-pi/pi-natives";
 
+/**
+ * `blockRangeAt` runs a full synchronous tree-sitter parse of `text` per
+ * call, and streaming previews re-resolve the same (text, line) every
+ * streamed chunk. Memoize by content: identical text + line always yields the
+ * same span. FIFO-bounded; hashing the text is orders of magnitude cheaper
+ * than re-parsing it.
+ */
+const resolutionCache = new Map<string, { start: number; end: number } | null>();
+const RESOLUTION_CACHE_MAX = 512;
+
 export const nativeBlockResolver: BlockResolver = ({ path, text, line }) => {
+	const key = `${Bun.hash(text).toString(36)}:${text.length}:${line}:${path}`;
+	const cached = resolutionCache.get(key);
+	if (cached !== undefined) return cached;
 	const range = blockRangeAt({ code: text, path, line });
-	return range ? { start: range.startLine, end: range.endLine } : null;
+	const result = range ? { start: range.startLine, end: range.endLine } : null;
+	if (resolutionCache.size >= RESOLUTION_CACHE_MAX) {
+		const oldest = resolutionCache.keys().next().value;
+		if (oldest !== undefined) resolutionCache.delete(oldest);
+	}
+	resolutionCache.set(key, result);
+	return result;
 };

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;