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

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [15.10.10] - 2026-06-09
+
+### Added
+
+- Added a read-only `view` op to the `todo` tool that echoes the current list without mutating state, so the agent can recover exact task text instead of guessing it from memory.
+
+### Changed
+
+- Rewrote the bash tool's coreutils guidance (tool prompt and system prompt) around an explicit litmus: pipelines that compute a new fact (`wc -l`, `sort | uniq -c`, `comm`, `diff`) are legitimate bash, while commands that merely move, page, or trim bytes a dedicated tool can fetch remain banned — output trimming destroys data the `artifact://` capture would have saved.
+
+### Fixed
+
+- Fixed the model selector dropping an immediate Enter when cached models were available but the selector's offline refresh was still pending.
+- Fixed dynamic `import(...)` inside functions passed to the browser tool's `tab.evaluate`/`page.evaluate` failing with `__omp_import__ is not defined`. The eval/browser JS runtime rewrites dynamic-import callees to the worker-injected `__omp_import__` helper, but puppeteer serializes evaluate callbacks with `Function.prototype.toString()` and re-runs them inside the page, where the helper does not exist. The rewriter now substitutes a guarded shim that falls back to native dynamic import when the helper is absent, so serialized code works in the page realm while in-worker imports keep resolving against the session cwd.
+- Transcript block freezing is now unconditional instead of gated on ED3-risk terminal detection: every finalized block replays its frozen snapshot once it crosses out of the live region, on all terminals including Windows, because the rewritten renderer's committed scrollback is immutable everywhere. Still-mutating blocks (pending tools, streaming messages, async thinking renderers) anchor the live region and keep repainting until they finalize, which structurally fixes stale/duplicated output from late async expansions ([#1823](https://github.com/can1357/oh-my-pi/issues/1823)).
+- Fixed the edit tool's post-edit diff preview occasionally echoing a context line twice with out-of-order numbering. Block-boundary context injection classified space-prefixed diff rows as old-file-only, so an unchanged line sitting in a net-offset region (old N / new N+k) was missing from the new file's visibility window; `findBlockContextLines` then re-surfaced it under its post-edit number and the row was spliced in after the adjacent change run. New-file boundary lines are now translated back to pre-edit numbers (the compact-preview renumbering contract) and merged into a single old-numbered insertion pass — also fixing closers below a net-offset edit being dropped or renumbered incorrectly.
+- Fixed the Anthropic web-search provider claiming the Claude Code identity on API-key requests: the CC billing header + system instruction were injected whenever the model wasn't Haiku 3.5, regardless of auth mode. Injection is now OAuth-gated like the streaming path, and OAuth search requests patch the billing header's `cch` attestation (via `wrapFetchForCch`) instead of shipping the `cch=00000` placeholder.
+- Fixed long streamed content appearing cut off mid-run: scrolled-off rows were erased from the viewport without ever being appended to terminal history. The transcript's commit boundary (`deriveLiveCommitState`) was all-or-nothing per block — one perpetually rewriting row (a task tool's ticking progress tree, per-agent cost/tool counters, spinner stats) suspended scrollback commits for the entire block, so once the block outgrew the viewport its static head (e.g. a task's prompt/context markdown) was neither committed nor on screen until the tool sealed, and was lost outright if the session ended mid-run. A stable-prefix ratchet now promotes leading rows that stayed visibly identical for a full 30-frame window as commit-safe, so the settled head reaches native scrollback while only the genuinely volatile tail stays deferred; a rewrite above the promoted run retreats the boundary and the engine audit recommits (duplication, never loss).
+- Fixed local tiny-title worker stdout/stderr leaking raw native model output such as `</title>` and cache/status lines into the interactive TUI scrollback ([#2206](https://github.com/can1357/oh-my-pi/issues/2206)).
+- Fixed task-agent discovery advertising Claude Code custom agents from `.claude/agents/*.md` as OMP subagents; direct task-agent discovery now only loads OMP-native `.omp` agent roots, while Claude marketplace plugin agents keep their existing provider path ([#2209](https://github.com/can1357/oh-my-pi/issues/2209)).
+
+### Removed
+
+- Removed the `clearOnShrink` setting and its `PI_CLEAR_ON_SHRINK` environment variable: the rewritten renderer always clears shrunken rows exactly, so the flicker/perf tradeoff the setting controlled no longer exists. Existing config entries are ignored.
+- Removed the prompt-submit native-scrollback reconciliation checkpoint and the eager streaming render mode from the interactive controllers — the renderer's append-only contract made both obsolete.
+
 ## [15.10.9] - 2026-06-09
 
 ### Fixed

package/dist/types/config/model-registry.d.ts

@@ -262,6 +262,11 @@ export interface CanonicalModelQueryOptions {
     availableOnly?: boolean;
     candidates?: readonly Model<Api>[];
 }
+/** A canonical record (with query-filtered variants) plus the variant model selected for it. */
+export interface CanonicalModelSelection {
+    record: CanonicalModelRecord;
+    model: Model<Api>;
+}
 /**
  * Model registry - loads and manages models, resolves API keys via AuthStorage.
  */
@@ -306,6 +311,14 @@ export declare class ModelRegistry {
      */
     getAll(): Model<Api>[];
     getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[];
+    /**
+     * One-pass equivalent of `getCanonicalModels` + `resolveCanonicalModel` per
+     * record. The per-query state (candidate-selector set, availability memo,
+     * provider rank, candidate order) is built once, so the whole catalog
+     * resolves in O(records + candidates) instead of O(records × candidates).
+     * This is the path the model selector hydrates from synchronously on open.
+     */
+    getCanonicalModelSelections(options?: CanonicalModelQueryOptions): CanonicalModelSelection[];
     getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
     resolveCanonicalModel(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
     getCanonicalId(model: Model<Api>): string | undefined;

package/dist/types/config/settings-schema.d.ts

@@ -716,15 +716,6 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Show terminal cursor for IME support";
         };
     };
-    readonly clearOnShrink: {
-        readonly type: "boolean";
-        readonly default: false;
-        readonly ui: {
-            readonly tab: "appearance";
-            readonly label: "Clear on Shrink";
-            readonly description: "Clear empty rows when content shrinks (may cause flicker)";
-        };
-    };
     readonly defaultThinkingLevel: {
         readonly type: "enum";
         readonly values: readonly [...import("@oh-my-pi/pi-ai").Effort[], "auto"];

package/dist/types/debug/terminal-info.d.ts

@@ -18,7 +18,6 @@ export interface TerminalStateInfo {
     hyperlinks: boolean;
     deccara: boolean;
     screenToScrollback: boolean;
-    eagerEraseScrollbackRisk: boolean;
     synchronizedOutput: boolean;
     multiplexer: string | null;
     env: {

package/dist/types/modes/components/transcript-container.d.ts

@@ -1,25 +1,18 @@
 import { Container, type NativeScrollbackLiveRegion } from "@oh-my-pi/pi-tui";
 /**
- * Transcript container that freezes the rendered output of every block except
- * the bottom-most (live) one on terminals where committed native scrollback is
- * immutable.
+ * Transcript container that always renders every block's current content and
+ * reports the live-region seam (`NativeScrollbackLiveRegion`) that gates the
+ * engine's append-only scrollback commits.
  *
- * On ED3-risk terminals with an unobservable viewport (ghostty/kitty/iTerm2/…)
- * the renderer cannot clear saved lines (`\x1b[3J` may yank a reader) or query
- * whether the user has scrolled, so any block that re-lays-out *after* it has
- * scrolled past the viewport leaves a stale duplicate above the live region
- * (a finalized assistant message re-wrapping, a tool preview collapsing to its
- * compact result, a late async tool completion). The renderer's only safe move
- * for such an offscreen edit is to not repaint — which is correct only if the
- * committed region never changes underneath it.
- *
- * This container provides that guarantee: a block's render is snapshotted while
- * it is the live (bottom-most) block, and once a newer block is appended it
- * replays the snapshot instead of recomputing. Mutations after a block leaves
- * live are intentionally deferred until the next checkpoint {@link thaw} (prompt
- * submit → native-scrollback rebuild), where the whole transcript is replayed
- * and any drift reconciles safely. On terminals that can rebuild history this
- * freezing is unnecessary, so it renders every block live for full fidelity.
+ * The engine never rewrites committed history: rows above the seam that have
+ * entered the tape keep whatever bytes they were committed with ("let the
+ * history be"), while the visible window always repaints from each block's
+ * latest render — a late tool result, a post-finalize error pin, or an expand
+ * toggle is always reflected on screen. Blocks that are still mutating (an
+ * unfinalized tool, a streaming assistant message) stay below the seam so
+ * their rows do not enter history while they can still change; a streaming
+ * block whose render grows append-only deepens the seam through its settled
+ * head so a long reply's scrolled-off rows still reach scrollback mid-stream.
  */
 export declare class TranscriptContainer extends Container implements NativeScrollbackLiveRegion {
     #private;
@@ -27,13 +20,6 @@ export declare class TranscriptContainer extends Container implements NativeScro
     clear(): void;
     getNativeScrollbackLiveRegionStart(): number | undefined;
     getNativeScrollbackCommitSafeEnd(): number | undefined;
-    /**
-     * Retire all frozen snapshots so the next render reflects each block's current
-     * state. Call at reconciliation checkpoints (prompt submit) where the whole
-     * transcript is replayed into native scrollback and any drift a frozen block
-     * accumulated is reconciled.
-     */
-    thaw(): void;
     render(width: number): string[];
 }
 /**

package/dist/types/task/discovery.d.ts

@@ -7,8 +7,7 @@ export interface DiscoveryResult {
 /**
  * Discover agents from filesystem and merge with bundled agents.
  *
- * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
- *
+ * Precedence (highest wins): project .omp, user .omp, Claude plugin agents, then bundled
  * @param cwd - Current working directory for project agent discovery
  */
 export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;

package/dist/types/tiny/title-client.d.ts

@@ -32,7 +32,7 @@ export declare const TINY_WORKER_ARG = "--tiny-worker";
  */
 export declare function tinyWorkerEnvOverlay(env: Record<string, string | undefined>, deviceSetting: string | undefined, dtypeSetting: string | undefined): Record<string, string>;
 interface SpawnedSubprocess {
-    proc: Subprocess<"ignore", "inherit", "inherit">;
+    proc: Subprocess<"ignore", "ignore", "ignore">;
     inbound: Set<(message: TinyTitleWorkerOutbound) => void>;
     errors: Set<(error: Error) => void>;
     /**

package/dist/types/tools/todo.d.ts

@@ -40,6 +40,7 @@ declare const todoSchema: z.ZodObject<{
             note: "note";
             rm: "rm";
             start: "start";
+            view: "view";
         }>;
         list: z.ZodOptional<z.ZodArray<z.ZodObject<{
             phase: z.ZodString;
@@ -113,6 +114,7 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
                 note: "note";
                 rm: "rm";
                 start: "start";
+                view: "view";
             }>;
             list: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 phase: z.ZodString;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.10.9",
+	"version": "15.10.10",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,14 +47,14 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.10.9",
-		"@oh-my-pi/omp-stats": "15.10.9",
-		"@oh-my-pi/pi-agent-core": "15.10.9",
-		"@oh-my-pi/pi-ai": "15.10.9",
-		"@oh-my-pi/pi-mnemopi": "15.10.9",
-		"@oh-my-pi/pi-natives": "15.10.9",
-		"@oh-my-pi/pi-tui": "15.10.9",
-		"@oh-my-pi/pi-utils": "15.10.9",
+		"@oh-my-pi/hashline": "15.10.10",
+		"@oh-my-pi/omp-stats": "15.10.10",
+		"@oh-my-pi/pi-agent-core": "15.10.10",
+		"@oh-my-pi/pi-ai": "15.10.10",
+		"@oh-my-pi/pi-mnemopi": "15.10.10",
+		"@oh-my-pi/pi-natives": "15.10.10",
+		"@oh-my-pi/pi-tui": "15.10.10",
+		"@oh-my-pi/pi-utils": "15.10.10",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/list-models.ts

@@ -64,22 +64,16 @@ export async function listModels(modelRegistry: ModelRegistry, searchPattern?: s
 	}
 
 	const filteredCanonical = modelRegistry
-		.getCanonicalModels({ availableOnly: true, candidates: filteredModels })
-		.map(record => {
-			const selected = modelRegistry.resolveCanonicalModel(record.id, {
-				availableOnly: true,
-				candidates: filteredModels,
-			});
-			if (!selected) return undefined;
-			return {
+		.getCanonicalModelSelections({ availableOnly: true, candidates: filteredModels })
+		.map(
+			({ record, model: selected }): CanonicalRow => ({
 				canonical: record.id,
 				selected: `${selected.provider}/${selected.id}`,
 				variants: String(record.variants.length),
 				context: formatNumber(selected.contextWindow),
 				maxOut: formatNumber(selected.maxTokens),
-			} satisfies CanonicalRow;
-		})
-		.filter((row): row is CanonicalRow => row !== undefined)
+			}),
+		)
 		.sort((left, right) => left.canonical.localeCompare(right.canonical));
 
 	if (filteredModels.length === 0 && filteredCanonical.length === 0) {

package/src/config/model-registry.ts

@@ -428,6 +428,12 @@ export interface CanonicalModelQueryOptions {
 	candidates?: readonly Model<Api>[];
 }
 
+/** A canonical record (with query-filtered variants) plus the variant model selected for it. */
+export interface CanonicalModelSelection {
+	record: CanonicalModelRecord;
+	model: Model<Api>;
+}
+
 /** Result of loading custom models from models.json */
 interface CustomModelsResult {
 	models?: CustomModelOverlay[];
@@ -2217,48 +2223,81 @@ export class ModelRegistry {
 		return this.#models;
 	}
 
-	#isModelAvailable(model: Model<Api>): boolean {
+	/**
+	 * Availability predicate with per-provider memoization. Auth lookups
+	 * (`authStorage.hasAuth`) and the disabled-provider set are resolved once
+	 * per provider instead of once per model, which matters when filtering the
+	 * full bundled catalog (thousands of models, ~50 providers).
+	 */
+	#createAvailabilityCheck(): (model: Model<Api>) => boolean {
 		const disabledProviders = getDisabledProviderIdsFromSettings();
-		return (
-			!disabledProviders.has(model.provider) &&
-			(this.#keylessProviders.has(model.provider) || this.authStorage.hasAuth(model.provider))
-		);
+		const byProvider = new Map<string, boolean>();
+		return model => {
+			let available = byProvider.get(model.provider);
+			if (available === undefined) {
+				available =
+					!disabledProviders.has(model.provider) &&
+					(this.#keylessProviders.has(model.provider) || this.authStorage.hasAuth(model.provider));
+				byProvider.set(model.provider, available);
+			}
+			return available;
+		};
+	}
+
+	/**
+	 * Build the shared per-query filter state for canonical model queries.
+	 * Hoisted out of the per-record loop: building the candidate-selector set
+	 * and availability memo once per query instead of once per record is what
+	 * keeps `getCanonicalModelSelections` linear instead of O(records × candidates).
+	 */
+	#canonicalQueryFilters(options: CanonicalModelQueryOptions | undefined): {
+		candidateKeys: Set<string> | undefined;
+		isAvailable: ((model: Model<Api>) => boolean) | undefined;
+	} {
+		return {
+			candidateKeys: options?.candidates
+				? new Set(options.candidates.map(candidate => formatCanonicalVariantSelector(candidate)))
+				: undefined,
+			isAvailable: options?.availableOnly ? this.#createAvailabilityCheck() : undefined,
+		};
 	}
 
 	#filterCanonicalVariants(
 		record: CanonicalModelRecord,
-		options: CanonicalModelQueryOptions | undefined,
+		candidateKeys: ReadonlySet<string> | undefined,
+		isAvailable: ((model: Model<Api>) => boolean) | undefined,
 	): CanonicalModelVariant[] {
-		const candidateKeys = options?.candidates
-			? new Set(options.candidates.map(candidate => formatCanonicalVariantSelector(candidate)))
-			: undefined;
 		return record.variants.filter(variant => {
 			if (candidateKeys && !candidateKeys.has(variant.selector)) {
 				return false;
 			}
-			if (options?.availableOnly && !this.#isModelAvailable(variant.model)) {
+			if (isAvailable && !isAvailable(variant.model)) {
 				return false;
 			}
 			return true;
 		});
 	}
 
+	#buildModelOrder(candidates: readonly Model<Api>[]): Map<string, number> {
+		const modelOrder = new Map<string, number>();
+		for (let index = 0; index < candidates.length; index += 1) {
+			modelOrder.set(formatCanonicalVariantSelector(candidates[index]!), index);
+		}
+		return modelOrder;
+	}
+
 	#providerRank(): Map<string, number> {
 		return buildModelProviderPriorityRank(getConfiguredProviderOrderFromSettings());
 	}
 
 	#resolveCanonicalVariant(
 		variants: readonly CanonicalModelVariant[],
-		allCandidates: readonly Model<Api>[],
+		modelOrder: ReadonlyMap<string, number>,
+		providerRank: ReadonlyMap<string, number>,
 	): CanonicalModelVariant | undefined {
 		if (variants.length === 0) {
 			return undefined;
 		}
-		const providerRank = this.#providerRank();
-		const modelOrder = new Map<string, number>();
-		for (let index = 0; index < allCandidates.length; index += 1) {
-			modelOrder.set(formatCanonicalVariantSelector(allCandidates[index]!), index);
-		}
 		const sourceRank: Record<CanonicalModelVariant["source"], number> = {
 			override: 1,
 			bundled: 1,
@@ -2289,9 +2328,10 @@ export class ModelRegistry {
 	}
 
 	getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[] {
+		const { candidateKeys, isAvailable } = this.#canonicalQueryFilters(options);
 		const records: CanonicalModelRecord[] = [];
 		for (const record of this.#canonicalIndex.records) {
-			const variants = this.#filterCanonicalVariants(record, options);
+			const variants = this.#filterCanonicalVariants(record, candidateKeys, isAvailable);
 			if (variants.length === 0) {
 				continue;
 			}
@@ -2304,12 +2344,43 @@ export class ModelRegistry {
 		return records;
 	}
 
+	/**
+	 * One-pass equivalent of `getCanonicalModels` + `resolveCanonicalModel` per
+	 * record. The per-query state (candidate-selector set, availability memo,
+	 * provider rank, candidate order) is built once, so the whole catalog
+	 * resolves in O(records + candidates) instead of O(records × candidates).
+	 * This is the path the model selector hydrates from synchronously on open.
+	 */
+	getCanonicalModelSelections(options?: CanonicalModelQueryOptions): CanonicalModelSelection[] {
+		const { candidateKeys, isAvailable } = this.#canonicalQueryFilters(options);
+		const candidates = options?.candidates ?? (options?.availableOnly ? this.getAvailable() : this.getAll());
+		const modelOrder = this.#buildModelOrder(candidates);
+		const providerRank = this.#providerRank();
+		const selections: CanonicalModelSelection[] = [];
+		for (const record of this.#canonicalIndex.records) {
+			const variants = this.#filterCanonicalVariants(record, candidateKeys, isAvailable);
+			if (variants.length === 0) {
+				continue;
+			}
+			const resolved = this.#resolveCanonicalVariant(variants, modelOrder, providerRank);
+			if (!resolved) {
+				continue;
+			}
+			selections.push({
+				record: { id: record.id, name: record.name, variants },
+				model: resolved.model,
+			});
+		}
+		return selections;
+	}
+
 	getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[] {
 		const record = this.#canonicalIndex.byId.get(canonicalId.trim().toLowerCase());
 		if (!record) {
 			return [];
 		}
-		return this.#filterCanonicalVariants(record, options);
+		const { candidateKeys, isAvailable } = this.#canonicalQueryFilters(options);
+		return this.#filterCanonicalVariants(record, candidateKeys, isAvailable);
 	}
 
 	resolveCanonicalModel(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined {
@@ -2318,7 +2389,7 @@ export class ModelRegistry {
 			return undefined;
 		}
 		const candidates = options?.candidates ?? (options?.availableOnly ? this.getAvailable() : this.getAll());
-		return this.#resolveCanonicalVariant(variants, candidates)?.model;
+		return this.#resolveCanonicalVariant(variants, this.#buildModelOrder(candidates), this.#providerRank())?.model;
 	}
 
 	getCanonicalId(model: Model<Api>): string | undefined {
@@ -2330,7 +2401,7 @@ export class ModelRegistry {
 	 * This is a fast check that doesn't refresh OAuth tokens.
 	 */
 	getAvailable(): Model<Api>[] {
-		return this.#models.filter(model => this.#isModelAvailable(model));
+		return this.#models.filter(this.#createAvailabilityCheck());
 	}
 
 	/**

package/src/config/settings-schema.ts

@@ -686,16 +686,6 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "appearance", label: "Show Hardware Cursor", description: "Show terminal cursor for IME support" },
 	},
 
-	clearOnShrink: {
-		type: "boolean",
-		default: false,
-		ui: {
-			tab: "appearance",
-			label: "Clear on Shrink",
-			description: "Clear empty rows when content shrinks (may cause flicker)",
-		},
-	},
-
 	// ────────────────────────────────────────────────────────────────────────
 	// Model
 	// ────────────────────────────────────────────────────────────────────────

package/src/debug/terminal-info.ts

@@ -36,7 +36,6 @@ export interface TerminalStateInfo {
 	hyperlinks: boolean;
 	deccara: boolean;
 	screenToScrollback: boolean;
-	eagerEraseScrollbackRisk: boolean;
 	synchronizedOutput: boolean;
 	multiplexer: string | null;
 	env: { TERM?: string; TERM_PROGRAM?: string; TERM_PROGRAM_VERSION?: string; COLORTERM?: string };
@@ -82,7 +81,6 @@ export function collectTerminalState(runtime: TerminalRuntimeState): TerminalSta
 		hyperlinks: TERMINAL.hyperlinks,
 		deccara: TERMINAL.deccara,
 		screenToScrollback: TERMINAL.supportsScreenToScrollback,
-		eagerEraseScrollbackRisk: TERMINAL.eagerEraseScrollbackRisk,
 		synchronizedOutput: runtime.synchronizedOutput,
 		multiplexer: detectMultiplexer(env),
 		env: {
@@ -115,7 +113,6 @@ export function formatTerminalState(info: TerminalStateInfo): string {
 		"",
 		"Scrollback",
 		`  Screen->history clear: ${info.screenToScrollback ? "CSI 22 J" : "CSI 2 J (redraw)"}`,
-		`  Eager-erase risk:      ${yesNo(info.eagerEraseScrollbackRisk)} (ED3 may yank scrolled readers)`,
 		"",
 		"Detection signals",
 		`  TERM:                 ${info.env.TERM ?? "(unset)"}`,

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,12 +67,7 @@ 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 {
@@ -92,7 +84,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 +97,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;
@@ -127,6 +118,16 @@ function insertBracketContextRows(
 	}
 }
 
+/**
+ * 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 +137,48 @@ 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);
 }
 
 /**

package/src/eval/js/shared/rewrite-imports.ts

@@ -82,6 +82,14 @@ function parseProgram(code: string): { program: { body: ReadonlyArray<BabelProgr
 	}
 }
 
+// Callee substituted for dynamic `import(...)` calls. Functions handed to puppeteer
+// (`tab.evaluate`, `page.evaluate`, `waitForFunction`, `$$eval`, ...) are serialized with
+// `Function.prototype.toString()` and re-evaluated inside the browser page, where the
+// worker-injected `__omp_import__` global does not exist. The swap therefore guards on the
+// helper's presence and falls back to native dynamic import, so serialized code keeps
+// working in foreign realms while in-worker code still resolves against the session cwd.
+const DYNAMIC_IMPORT_CALLEE = '(typeof __omp_import__ === "function" ? __omp_import__ : (s, o) => import(s, o))';
+
 function buildOmpImportCall(sourceLiteral: string, optionsLiteral: string | undefined): string {
 	// Route every static import through the worker-injected `__omp_import__` helper so the
 	// specifier resolves against the session cwd (and `with`-attribute imports keep working).
@@ -180,7 +188,7 @@ export function rewriteImports(code: string): string {
 		const call = node as unknown as { callee?: { type?: string; start?: number; end?: number } };
 		const callee = call.callee;
 		if (callee?.type !== "Import" || typeof callee.start !== "number" || typeof callee.end !== "number") return;
-		edits.push({ start: callee.start, end: callee.end, text: "__omp_import__" });
+		edits.push({ start: callee.start, end: callee.end, text: DYNAMIC_IMPORT_CALLEE });
 	});
 
 	if (edits.length === 0) return code;