@oh-my-pi/pi-coding-agent 17.2.4 → 17.2.5

package/src/edit/modes/replace.ts

@@ -258,23 +258,41 @@ function formatPreviewWindow(lines: string[], centerIndex: number, options: Prev
 		.join("\n");
 }
 
-function findExactMatchOutcome(content: string, target: string): MatchOutcome | undefined {
-	const exactIndex = content.indexOf(target);
-	if (exactIndex === -1) {
+function findExactMatchOutcome(
+	content: string,
+	target: string,
+	excludedRanges: readonly { startIndex: number; endIndex: number }[],
+): MatchOutcome | undefined {
+	let firstIndex: number | undefined;
+	let occurrences = 0;
+	const recordedIndices: number[] = [];
+	let searchStart = 0;
+
+	while (searchStart <= content.length - target.length) {
+		const index = content.indexOf(target, searchStart);
+		if (index === -1) break;
+
+		const endIndex = index + target.length;
+		if (!excludedRanges.some(range => index < range.endIndex && endIndex > range.startIndex)) {
+			firstIndex ??= index;
+			occurrences++;
+			if (recordedIndices.length < MAX_RECORDED_MATCHES) {
+				recordedIndices.push(index);
+			}
+		}
+		searchStart = endIndex;
+	}
+
+	if (firstIndex === undefined) {
 		return undefined;
 	}
 
-	const occurrences = content.split(target).length - 1;
 	if (occurrences > 1) {
 		const contentLines = content.split("\n");
 		const occurrenceLines: number[] = [];
 		const occurrencePreviews: string[] = [];
-		let searchStart = 0;
-
-		for (let i = 0; i < MAX_RECORDED_MATCHES; i++) {
-			const idx = content.indexOf(target, searchStart);
-			if (idx === -1) break;
-			const lineNumber = content.slice(0, idx).split("\n").length;
+		for (const index of recordedIndices) {
+			const lineNumber = content.slice(0, index).split("\n").length;
 			occurrenceLines.push(lineNumber);
 			occurrencePreviews.push(
 				formatPreviewWindow(contentLines, lineNumber - 1, {
@@ -282,17 +300,16 @@ function findExactMatchOutcome(content: string, target: string): MatchOutcome |
 					maxLen: OCCURRENCE_PREVIEW_MAX_LEN,
 				}),
 			);
-			searchStart = idx + 1;
 		}
 
 		return { occurrences, occurrenceLines, occurrencePreviews };
 	}
 
-	const startLine = content.slice(0, exactIndex).split("\n").length;
+	const startLine = content.slice(0, firstIndex).split("\n").length;
 	return {
 		match: {
 			actualText: target,
-			startIndex: exactIndex,
+			startIndex: firstIndex,
 			startLine,
 			confidence: 1,
 		},
@@ -408,6 +425,7 @@ function findBestFuzzyMatchCore(
 	offsets: number[],
 	threshold: number,
 	includeDepth: boolean,
+	excludedRanges: readonly { startIndex: number; endIndex: number }[],
 ): BestFuzzyMatchResult {
 	const targetNormalized = normalizeLines(targetLines, includeDepth);
 
@@ -417,6 +435,12 @@ function findBestFuzzyMatchCore(
 	let aboveThresholdCount = 0;
 
 	for (let start = 0; start <= contentLines.length - targetLines.length; start++) {
+		const startIndex = offsets[start];
+		const endLine = start + targetLines.length - 1;
+		const endIndex = Math.max(startIndex + 1, offsets[endLine] + contentLines[endLine].length);
+		if (excludedRanges.some(range => startIndex < range.endIndex && endIndex > range.startIndex)) {
+			continue;
+		}
 		const windowLines = contentLines.slice(start, start + targetLines.length);
 		const windowNormalized = normalizeLines(windowLines, includeDepth);
 		let score = 0;
@@ -434,7 +458,7 @@ function findBestFuzzyMatchCore(
 			bestScore = score;
 			best = {
 				actualText: windowLines.join("\n"),
-				startIndex: offsets[start],
+				startIndex,
 				startLine: start + 1,
 				confidence: score,
 			};
@@ -446,7 +470,12 @@ function findBestFuzzyMatchCore(
 	return { best, aboveThresholdCount, secondBestScore };
 }
 
-function findBestFuzzyMatch(content: string, target: string, threshold: number): BestFuzzyMatchResult {
+function findBestFuzzyMatch(
+	content: string,
+	target: string,
+	threshold: number,
+	excludedRanges: readonly { startIndex: number; endIndex: number }[],
+): BestFuzzyMatchResult {
 	const contentLines = content.split("\n");
 	const targetLines = target.split("\n");
 
@@ -458,11 +487,18 @@ function findBestFuzzyMatch(content: string, target: string, threshold: number):
 	}
 
 	const offsets = computeLineOffsets(contentLines);
-	let result = findBestFuzzyMatchCore(contentLines, targetLines, offsets, threshold, true);
+	let result = findBestFuzzyMatchCore(contentLines, targetLines, offsets, threshold, true, excludedRanges);
 
 	// Retry without indent depth if match is close but below threshold
 	if (result.best && result.best.confidence < threshold && result.best.confidence >= FALLBACK_THRESHOLD) {
-		const noDepthResult = findBestFuzzyMatchCore(contentLines, targetLines, offsets, threshold, false);
+		const noDepthResult = findBestFuzzyMatchCore(
+			contentLines,
+			targetLines,
+			offsets,
+			threshold,
+			false,
+			excludedRanges,
+		);
 		if (noDepthResult.best && noDepthResult.best.confidence > result.best.confidence) {
 			result = noDepthResult;
 		}
@@ -473,25 +509,35 @@ function findBestFuzzyMatch(content: string, target: string, threshold: number):
 
 /**
  * Find a match for target text within content.
- * Used primarily for replace-mode edits.
+ * Used primarily for replace-mode edits; excluded ranges remain invisible to exact and fuzzy matching.
  */
 export function findMatch(
 	content: string,
 	target: string,
-	options: { allowFuzzy: boolean; threshold?: number },
+	options: {
+		allowFuzzy: boolean;
+		threshold?: number;
+		excludedRanges?: readonly { startIndex: number; endIndex: number }[];
+	},
 ): MatchOutcome {
 	if (target.length === 0) {
 		return {};
 	}
+	const excludedRanges = options.excludedRanges ?? [];
 
-	const exactMatch = findExactMatchOutcome(content, target);
+	const exactMatch = findExactMatchOutcome(content, target, excludedRanges);
 	if (exactMatch) {
 		return exactMatch;
 	}
 
 	// Try fuzzy match
 	const threshold = options.threshold ?? DEFAULT_FUZZY_THRESHOLD;
-	const { best, aboveThresholdCount, secondBestScore } = findBestFuzzyMatch(content, target, threshold);
+	const { best, aboveThresholdCount, secondBestScore } = findBestFuzzyMatch(
+		content,
+		target,
+		threshold,
+		excludedRanges,
+	);
 
 	if (!best) {
 		return {};
@@ -1012,24 +1058,31 @@ export function findContextLine(
 	return { index: undefined, confidence: bestScore };
 }
 
-export const replaceEditEntrySchema = type({
-	old_text: "string",
-	new_text: "string",
-	"all?": "boolean",
-});
-
 export const replaceEditSchema = type({
 	path: "string",
-	edits: replaceEditEntrySchema.array(),
+	old_string: "string",
+	new_string: "string",
+	"replace_all?": "boolean",
 });
 
-export type ReplaceEditEntry = typeof replaceEditEntrySchema.infer;
 export type ReplaceParams = typeof replaceEditSchema.infer;
 
-export interface ExecuteReplaceSingleOptions {
+/**
+ * Internal batch form of {@link ReplaceParams}, produced only by the Cursor
+ * exec bridge: a `pi_edit` frame carries several replacements against one
+ * path but must run as a single tool lifecycle with one aggregate result.
+ * Never advertised to the model — the agent loop validates model calls
+ * against {@link replaceEditSchema}, which has no `edits` field.
+ */
+export interface ReplaceBatchParams {
+	path: string;
+	edits: Omit<ReplaceParams, "path">[];
+}
+
+export interface ExecuteReplaceOptions {
 	session: ToolSession;
 	path: string;
-	params: ReplaceEditEntry;
+	params: Omit<ReplaceParams, "path">;
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	allowFuzzy: boolean;
@@ -1038,9 +1091,9 @@ export interface ExecuteReplaceSingleOptions {
 	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }
 
-export async function executeReplaceSingle(
-	options: ExecuteReplaceSingleOptions,
-): Promise<AgentToolResult<EditToolDetails, ReplaceEditEntry>> {
+export async function executeReplace(
+	options: ExecuteReplaceOptions,
+): Promise<AgentToolResult<EditToolDetails, ReplaceParams>> {
 	const {
 		session,
 		path,
@@ -1052,12 +1105,12 @@ export async function executeReplaceSingle(
 		writethrough,
 		beginDeferredDiagnosticsForPath,
 	} = options;
-	const { old_text, new_text, all } = params;
+	const { old_string, new_string, replace_all } = params;
 
 	enforcePlanModeWrite(session, path);
 
-	if (old_text.length === 0) {
-		throw new Error("old_text must not be empty.");
+	if (old_string.length === 0) {
+		throw new Error("old_string must not be empty.");
 	}
 
 	const absolutePath = resolvePlanPath(session, path);
@@ -1065,12 +1118,12 @@ export async function executeReplaceSingle(
 	const { bom, text: content } = stripBom(rawContent);
 	const originalEnding = detectLineEnding(content);
 	const normalizedContent = normalizeToLF(content);
-	const normalizedOldText = normalizeToLF(old_text);
-	const normalizedNewText = normalizeToLF(new_text);
+	const normalizedOldText = normalizeToLF(old_string);
+	const normalizedNewText = normalizeToLF(new_string);
 
 	const result = replaceText(normalizedContent, normalizedOldText, normalizedNewText, {
 		fuzzy: allowFuzzy,
-		all: all ?? false,
+		all: replace_all ?? false,
 		threshold: fuzzyThreshold,
 	});
 

package/src/edit/renderer.ts

@@ -115,7 +115,7 @@ interface EditRenderArgs {
 	patch?: string;
 	input?: string;
 	_input?: string;
-	all?: boolean;
+	replace_all?: boolean;
 	// Patch mode fields
 	op?: Operation;
 	rename?: unknown;

package/src/edit/streaming.ts

@@ -30,7 +30,6 @@ import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { computeHashlineDiff, computeHashlineSectionDiff } from "./hashline/diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
-import type { ReplaceEditEntry } from "./modes/replace";
 
 export interface PerFileDiffPreview {
 	path: string;
@@ -333,27 +332,32 @@ function splitApplyPatchPerFile(input: string): EditMatcherEntry[] {
 
 interface ReplaceArgs {
 	path?: string;
-	edits?: ReplaceEditEntry[];
+	old_string?: string;
+	new_string?: string;
+	replace_all?: boolean;
 	__partialJson?: string;
 }
 
 const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 	extractCompleteEdits(args, partialJson) {
-		if (!args?.edits) return args;
-		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
+		// While args are still streaming, `old_string` is only trustworthy once
+		// the parser has moved past it — i.e. the `new_string` key has appeared.
+		// Previewing a half-streamed `old_string` would flash a bogus
+		// "no match" diff error until the rest of the value arrives.
+		if (!partialJson || partialJson.includes('"new_string"')) return args;
+		return { ...args, old_string: undefined, new_string: undefined };
 	},
 	async computeDiffPreview(args, ctx) {
 		if (!args.path) return null;
-		const first = args.edits?.[0];
-		if (!first || first.old_text === undefined || first.new_text === undefined) return null;
+		if (args.old_string === undefined || args.new_string === undefined) return null;
 		ctx.signal.throwIfAborted();
 		const result = await computeEditDiff(
 			args.path,
-			first.old_text,
-			first.new_text,
+			args.old_string,
+			args.new_string,
 			ctx.cwd,
 			ctx.allowFuzzy ?? true,
-			first.all,
+			args.replace_all,
 			ctx.fuzzyThreshold,
 		);
 		ctx.signal.throwIfAborted();
@@ -363,14 +367,7 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 		return "";
 	},
 	matcherDigest(args) {
-		const edits = args?.edits;
-		if (!Array.isArray(edits)) return undefined;
-		let digest: string | undefined;
-		for (const edit of edits) {
-			if (typeof edit?.new_text !== "string") continue;
-			digest = digest === undefined ? edit.new_text : `${digest}\n${edit.new_text}`;
-		}
-		return digest;
+		return typeof args?.new_string === "string" ? args.new_string : undefined;
 	},
 	matcherPaths(args) {
 		return typeof args?.path === "string" && args.path.length > 0 ? [args.path] : undefined;

package/src/eval/py/kernel.ts

@@ -82,8 +82,9 @@ const availabilityCache = new Map<string, Promise<PythonKernelAvailability>>();
 export async function checkPythonKernelAvailability(
 	cwd: string,
 	interpreter?: string,
+	options?: { forceProbe?: boolean },
 ): Promise<PythonKernelAvailability> {
-	if (isBunTestRuntime() || $flag("PI_PYTHON_SKIP_CHECK")) {
+	if (!options?.forceProbe && (isBunTestRuntime() || $flag("PI_PYTHON_SKIP_CHECK"))) {
 		return { ok: true };
 	}
 	const resolvedCwd = path.resolve(cwd);

package/src/eval/py/spawn-options.ts

@@ -1,10 +1,10 @@
 /**
  * Subprocess spawn-option helpers for the Python kernel.
  *
- * Pure helpers (`shouldHideKernelWindow`, `consoleAttachedViaTTY`) live here
- * so they can be unit-tested without dragging in the kernel's runtime
- * dependencies. The effectful `hostHasInheritableConsole` wraps a Win32 FFI
- * probe with a TTY fallback and is the function `kernel.ts` actually calls.
+ * Pure helpers (`shouldHideKernelWindow`, `consoleAttached`) live here so they
+ * can be unit-tested without dragging in the kernel's runtime dependencies.
+ * The effectful `hostHasInheritableConsole` combines a Win32 FFI probe with
+ * TTY evidence and is the function `kernel.ts` actually calls.
  */
 import { dlopen, FFIType } from "bun:ffi";
 
@@ -54,20 +54,21 @@ export function shouldDetachKernel(platform: NodeJS.Platform): boolean {
 }
 
 /**
- * TTY-based fallback used when the Win32 console probe is unavailable.
+ * Combine native Win32 and stdio TTY evidence of an inheritable console.
  *
- * Returns `true` if any of stdin/stdout/stderr is currently a TTY. This
- * correctly detects the common interactive launches and the partial-
- * redirection cases (`omp -p > out.txt`, `< in.txt`, `2> err.log`) where at
- * least one stream stays bound to the terminal. The all-stdio-redirected
- * case (`< in > out 2> err` from a console) is the reason we prefer the
- * Win32 probe over this fallback whenever possible.
+ * `GetConsoleWindow()` detects classic consoles even when every stdio stream
+ * is redirected. TTY detection covers ConPTY-backed terminals, where compiled
+ * hosts can receive a null HWND despite being attached to Windows Terminal.
+ * Either signal must preserve console inheritance: `CREATE_NO_WINDOW` can
+ * deadlock NumPy native-extension loading in the Python child.
  */
-export function consoleAttachedViaTTY(opts: {
+export function consoleAttached(opts: {
+	nativeConsole?: boolean | null;
 	stdinIsTTY: boolean;
 	stdoutIsTTY: boolean;
 	stderrIsTTY: boolean;
 }): boolean {
+	if (opts.nativeConsole === true) return true;
 	return opts.stdinIsTTY || opts.stdoutIsTTY || opts.stderrIsTTY;
 }
 
@@ -75,10 +76,10 @@ export function consoleAttachedViaTTY(opts: {
  * Probe `kernel32.dll!GetConsoleWindow()` to detect whether the current
  * Windows process owns a console window.
  *
- * Returns `true` for a non-NULL HWND, `false` when NULL (no console — true
- * service / `DETACHED_PROCESS` / GUI parent), and `null` when the probe
- * itself fails (off-Windows, FFI disabled, or unexpected kernel32 layout).
- * A `null` return means "don't trust me, use the TTY fallback".
+ * Returns `true` for a non-NULL HWND, `false` when NULL, and `null` when the
+ * probe itself fails (off-Windows, FFI disabled, or unexpected kernel32
+ * layout). A false result is not conclusive for ConPTY-backed terminals, so
+ * callers must also inspect the stdio TTY signals.
  *
  * Cached on first call because in practice the console attachment of a
  * long-lived OMP host never changes for the lifetime of the process, and
@@ -117,21 +118,15 @@ export function __resetWindowsConsoleProbeCache(): void {
 /**
  * Whether the host process owns a console its children can inherit.
  *
- * - On Windows, the authoritative signal is `GetConsoleWindow()`. It returns
- *   a non-NULL HWND whenever the process has a console attached, regardless
- *   of how the standard streams are redirected — so an `omp -p ... < in.txt
- *   > out.txt 2> err.log` launched from a real Windows Terminal session is
- *   correctly classified as console-attached and the kernel keeps its
- *   inheritable console.
- * - On any other platform, or if the FFI probe fails, fall back to the
- *   TTY-OR heuristic. That still catches the common interactive cases.
+ * On Windows, `GetConsoleWindow()` detects classic consoles and all-stdio-
+ * redirected launches while stdio TTYs detect ConPTY-backed terminals. Either
+ * signal is sufficient. Other platforms use the same TTY evidence, although
+ * `windowsHide` is a no-op there.
  */
 export function hostHasInheritableConsole(): boolean {
-	if (process.platform === "win32") {
-		const native = probeWindowsConsoleWindow();
-		if (native !== null) return native;
-	}
-	return consoleAttachedViaTTY({
+	const nativeConsole = process.platform === "win32" ? probeWindowsConsoleWindow() : null;
+	return consoleAttached({
+		nativeConsole,
 		stdinIsTTY: !!process.stdin.isTTY,
 		stdoutIsTTY: !!process.stdout.isTTY,
 		stderrIsTTY: !!process.stderr.isTTY,

package/src/export/html/template.js

@@ -204,7 +204,7 @@
           containsActive.set(node, has);
         }
 
-        // Stack: [node, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild]
+        // Stack: [node, indent, showConnector, isLast, gutters, isVirtualRootChild]
         const stack = [];
 
         // Add roots (prioritize branch containing active leaf)
@@ -213,11 +213,11 @@
         );
         for (let i = orderedRoots.length - 1; i >= 0; i--) {
           const isLast = i === orderedRoots.length - 1;
-          stack.push([orderedRoots[i], multipleRoots ? 1 : 0, multipleRoots, multipleRoots, isLast, [], multipleRoots]);
+          stack.push([orderedRoots[i], multipleRoots ? 1 : 0, multipleRoots, isLast, [], multipleRoots]);
         }
 
         while (stack.length > 0) {
-          const [node, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild] = stack.pop();
+          const [node, indent, showConnector, isLast, gutters, isVirtualRootChild] = stack.pop();
 
           result.push({ node, indent, showConnector, isLast, gutters, isVirtualRootChild, multipleRoots });
 
@@ -229,18 +229,10 @@
             Number(containsActive.get(b)) - Number(containsActive.get(a))
           );
 
-          // Calculate child indent (matches tree-selector.ts)
-          let childIndent;
-          if (multipleChildren) {
-            // Parent branches: children get +1
-            childIndent = indent + 1;
-          } else if (justBranched && indent > 0) {
-            // First generation after a branch: +1 for visual grouping
-            childIndent = indent + 1;
-          } else {
-            // Single-child chain: stay flat
-            childIndent = indent;
-          }
+          // Real branch points add visual depth, and a virtual root's direct
+          // children (the session roots) nest one level under the shared
+          // column-0 root. Linear continuations otherwise stay aligned.
+          const childIndent = multipleChildren || isVirtualRootChild ? indent + 1 : indent;
 
           // Build gutters for children
           const connectorDisplayed = showConnector && !isVirtualRootChild;
@@ -253,7 +245,7 @@
           // Add children in reverse order for stack
           for (let i = orderedChildren.length - 1; i >= 0; i--) {
             const childIsLast = i === orderedChildren.length - 1;
-            stack.push([orderedChildren[i], childIndent, multipleChildren, multipleChildren, childIsLast, childGutters, false]);
+            stack.push([orderedChildren[i], childIndent, multipleChildren, childIsLast, childGutters, false]);
           }
         }
 
@@ -268,13 +260,6 @@
         const displayIndent = multipleRoots ? Math.max(0, indent - 1) : indent;
         const connector = showConnector && !isVirtualRootChild ? (isLast ? '└─ ' : '├─ ') : '';
         const connectorPosition = connector ? displayIndent - 1 : -1;
-        // Chain rows (no connector of their own) under a last-sibling (`└─`)
-        // branch stay anchored by a vertical drawn one level right of the
-        // suppressed gutter — below the branch head's content — never in the
-        // `└─` corner column itself (#2298, #2325). Chains under `├─` heads
-        // are already anchored by the sibling line (`show: true` gutter).
-        const nearestGutter = !connector ? gutters[gutters.length - 1] : undefined;
-        const chainAnchorLevel = nearestGutter && !nearestGutter.show ? nearestGutter.position + 1 : -1;
 
         const totalChars = displayIndent * 3;
         const prefixChars = [];
@@ -287,9 +272,6 @@
             // Standard tree semantics: `│` only while more siblings continue
             // below (`show`), space below a `└─`.
             prefixChars.push(posInLevel === 0 && gutter.show ? '│' : ' ');
-          } else if (level === chainAnchorLevel) {
-            // Chain anchor for rows under a `└─` branch head.
-            prefixChars.push(posInLevel === 0 ? '│' : ' ');
           } else if (connector && level === connectorPosition) {
             if (posInLevel === 0) {
               prefixChars.push(isLast ? '└' : '├');

package/src/extensibility/extensions/wrapper.ts

@@ -239,6 +239,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		// short-circuit above.
 		const resolvedArgs = approvalArgs(effectiveParams, context);
 		const resolved = resolveApproval(this.tool, resolvedArgs, approvalMode, userPolicies);
+		context?.xdevTierResolved?.(resolved.tier);
 		if (resolved.policy === "deny") {
 			throw new Error(
 				`Tool "${this.tool.name}" is blocked by user policy.\n` +

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -19,7 +19,15 @@
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
  * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
-import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import {
+	type Api,
+	type AssistantMessage,
+	type AssistantMessageEventStream,
+	type Context,
+	type Model,
+	type SimpleStreamOptions,
+	streamSimple,
+} from "@oh-my-pi/pi-ai";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
 import {
@@ -121,6 +129,19 @@ export { calculateCost, getBundledModel, getBundledModels, getBundledProviders,
 export const getModel = getBundledModel;
 export const getModels = getBundledModels;
 
+/**
+ * Stream OpenAI Responses through the historical simple-options contract.
+ *
+ * Legacy `/compat` callers pass {@link SimpleStreamOptions}; routing through
+ * `streamSimple` preserves option normalization before provider dispatch.
+ */
+export function streamSimpleOpenAIResponses(
+	model: Model<"openai-responses">,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+	return streamSimple(model, context, options);
+}
 /**
  * Compatibility re-exports for runtime helpers that upstream
  * `@earendil-works/pi-ai` exposed from its package root but omp's

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -1415,12 +1415,13 @@ export function getPackageDir(): string {
 	return getOmpPackageDir() ?? (isCompiledBinary() ? path.dirname(process.execPath) : process.cwd());
 }
 
-// Legacy pi's `@earendil-works/pi-coding-agent` re-exported `estimateTokens`
-// and `compact` from its package root (via `./core/compaction/index.ts`). In
-// omp both live in `@oh-my-pi/pi-agent-core/compaction`, and the coding-agent
-// barrel below does not forward them, so legacy extensions importing either
-// fail Bun's static export check during validation (issues #6583, #7174).
-export { compact, estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
+// Legacy pi's `@earendil-works/pi-coding-agent` re-exported `estimateTokens`,
+// `compact`, and `serializeConversation` from its package root (via
+// `./core/compaction/index.ts`). In omp they live in
+// `@oh-my-pi/pi-agent-core/compaction`, and the coding-agent barrel below does
+// not forward them, so legacy extensions importing them fail Bun's static
+// export check during validation (issues #6583, #7174, #7403).
+export { compact, estimateTokens, serializeConversation } from "@oh-my-pi/pi-agent-core/compaction";
 
 // Same barrel gap for two more legacy package-root exports: pi re-exported the
 // `CONFIG_DIR_NAME` constant and the CLI parser `parseArgs`. In omp