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

package/src/cursor.ts

@@ -69,7 +69,7 @@ interface CursorExecBridgeOptions {
 	 *
 	 * `PiEditExecArgs` is that mode's schema verbatim, and the session's own
 	 * `edit` may be in any mode — `hashline` by default — whose schema rejects
-	 * `old_text`/`new_text` outright. {@link tools} therefore cannot be trusted
+	 * `old_string`/`new_string` outright. {@link tools} therefore cannot be trusted
 	 * for this one frame: a session that starts on another provider keeps its
 	 * configured instance in the map (only Cursor sessions move `edit` out), and
 	 * switching to Cursor later does not rebuild the roster.
@@ -641,25 +641,21 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 	}
 
 	/**
-	 * `PiEditExecArgs` is the local `edit` tool's replace mode verbatim: a path
-	 * plus `old_text`/`new_text` pairs. The tool's schema is snake_case, so the
-	 * proto's camelCase accessors are mapped back on the way in.
+	 * `PiEditExecArgs` carries a path plus `oldText`/`newText` replacement
+	 * pairs. A single replacement maps onto the model-facing single-edit
+	 * `replace` schema verbatim; a multi-replacement frame still runs as ONE
+	 * tool lifecycle (one start/end event pair, one aggregate diff), so it is
+	 * sent in the tool's internal `edits` batch form (`ReplaceBatchParams`),
+	 * which only this bridge produces.
 	 *
 	 * The replace-mode instance is requested explicitly rather than resolved
 	 * from {@link CursorExecBridgeOptions.tools}: the registry's `edit` is in
 	 * the session's configured mode, whose schema rejects these arguments.
 	 */
 	async piEdit(call: Parameters<NonNullable<ICursorExecHandlers["piEdit"]>>[0]) {
-		return await executeTool(
-			this.options,
-			"edit",
-			call.toolCallId,
-			{
-				path: call.args.path,
-				edits: call.args.edits.map(edit => ({ old_text: edit.oldText, new_text: edit.newText })),
-			},
-			this.options.getEditReplaceTool?.(),
-		);
+		const edits = call.args.edits.map(edit => ({ old_string: edit.oldText, new_string: edit.newText }));
+		const args = edits.length === 1 ? { path: call.args.path, ...edits[0] } : { path: call.args.path, edits };
+		return await executeTool(this.options, "edit", call.toolCallId, args, this.options.getEditReplaceTool?.());
 	}
 
 	async piWrite(call: Parameters<NonNullable<ICursorExecHandlers["piWrite"]>>[0]) {

package/src/edit/diff.ts

@@ -855,7 +855,6 @@ export function replaceText(content: string, oldText: string, newText: string, o
 	let normalizedContent = normalizeToLF(content);
 	const normalizedOldText = normalizeToLF(oldText);
 	const normalizedNewText = normalizeToLF(newText);
-	let count = 0;
 
 	if (options.all) {
 		// Check for exact matches first
@@ -867,11 +866,13 @@ export function replaceText(content: string, oldText: string, newText: string, o
 			};
 		}
 
-		// No exact matches - try fuzzy matching iteratively
+		// Match against the immutable source so inserted replacement text cannot become a later candidate.
+		const replacements: Array<{ startIndex: number; endIndex: number; text: string }> = [];
 		while (true) {
 			const matchOutcome = findMatch(normalizedContent, normalizedOldText, {
 				allowFuzzy: options.fuzzy,
 				threshold,
+				excludedRanges: replacements,
 			});
 
 			const shouldUseClosest =
@@ -888,14 +889,22 @@ export function replaceText(content: string, oldText: string, newText: string, o
 			if (adjustedNewText === match.actualText) {
 				break;
 			}
-			normalizedContent =
-				normalizedContent.substring(0, match.startIndex) +
-				adjustedNewText +
-				normalizedContent.substring(match.startIndex + match.actualText.length);
-			count++;
+			replacements.push({
+				startIndex: match.startIndex,
+				endIndex: match.startIndex + Math.max(match.actualText.length, 1),
+				text: adjustedNewText,
+			});
 		}
 
-		return { content: normalizedContent, count };
+		replacements.sort((a, b) => a.startIndex - b.startIndex);
+		const parts: string[] = [];
+		let sourceIndex = 0;
+		for (const replacement of replacements) {
+			parts.push(normalizedContent.substring(sourceIndex, replacement.startIndex), replacement.text);
+			sourceIndex = replacement.endIndex;
+		}
+		parts.push(normalizedContent.substring(sourceIndex));
+		return { content: parts.join(""), count: replacements.length };
 	}
 
 	// Single replacement mode

package/src/edit/index.ts

@@ -19,7 +19,7 @@ import { executeHashlineSingle, hashlineEditParamsSchema } from "./hashline";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
-import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
+import { executeReplace, type ReplaceBatchParams, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 import { pruneOversizedEditSnapshots } from "./snapshot-details";
 import { EDIT_MODE_STRATEGIES } from "./streaming";
@@ -46,7 +46,7 @@ type TInput =
 
 type HashlineParams = typeof hashlineEditParamsSchema.infer;
 
-type EditParams = ReplaceParams | PatchParams | HashlineParams | ApplyPatchParams;
+type EditParams = ReplaceParams | ReplaceBatchParams | PatchParams | HashlineParams | ApplyPatchParams;
 
 type EditModeDefinition = {
 	description: (session: ToolSession) => string;
@@ -402,7 +402,7 @@ export class EditTool implements AgentTool<TInput> {
 	/**
 	 * `mode` pins the edit variant for this instance, for callers whose protocol
 	 * fixes the shape of an edit. The Cursor `pi_edit` frame carries
-	 * `old_text`/`new_text` pairs, which only `replace` accepts — under the
+	 * `old_string`/`new_string` args, which only `replace` accepts — under the
 	 * default `hashline` mode those args do not match the schema at all. Left
 	 * unset, the env/settings resolution applies as before.
 	 */
@@ -662,11 +662,24 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits, path } = params as ReplaceParams;
-					const targetPath = await resolveEditPath(tool.session, path, { mustExist: true, signal });
-					const runs = (edits as ReplaceEditEntry[]).map(
+					// `edits` is the internal `ReplaceBatchParams` form only the Cursor
+					// exec bridge produces (multi-replacement `pi_edit` frames run as one
+					// lifecycle); model calls always arrive in the single-edit schema shape.
+					const replaceParams = params as ReplaceParams | ReplaceBatchParams;
+					const entries =
+						"edits" in replaceParams
+							? replaceParams.edits
+							: [
+									{
+										old_string: replaceParams.old_string,
+										new_string: replaceParams.new_string,
+										replace_all: replaceParams.replace_all,
+									},
+								];
+					const targetPath = await resolveEditPath(tool.session, replaceParams.path, { mustExist: true, signal });
+					const runs = entries.map(
 						entry => (br: LspBatchRequest | undefined) =>
-							executeReplaceSingle({
+							executeReplace({
 								session: tool.session,
 								path: targetPath,
 								params: entry,

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/index.ts

@@ -181,10 +181,17 @@ export interface SessionData {
 	subSessions?: Record<string, SubSession>;
 }
 
+function sessionHeaderForExport(header: SessionHeader | null): SessionHeader | null {
+	if (!header) return null;
+	const exported = { ...header };
+	delete exported.previousSessionFiles;
+	return exported;
+}
+
 /** Snapshot the session (plus optional agent state) into the JSON shape the viewer renders. */
 export function buildSessionData(sm: SessionManager, state?: AgentState): SessionData {
 	return {
-		header: sm.getHeader(),
+		header: sessionHeaderForExport(sm.getHeader()),
 		entries: sm.getEntries(),
 		leafId: sm.getLeafId(),
 		systemPrompt: state?.systemPrompt.join("\n\n"),
@@ -231,7 +238,7 @@ async function collectSubSessionsFromDir(
 			out[key] = {
 				agentId,
 				parent: parentKey,
-				header,
+				header: sessionHeaderForExport(header),
 				entries,
 				leafId: entries.length > 0 ? entries[entries.length - 1].id : null,
 			};
@@ -295,7 +302,7 @@ export async function exportFromFile(inputPath: string, options?: ExportOptions
 	}
 
 	const sessionData: SessionData = {
-		header: sm.getHeader(),
+		header: sessionHeaderForExport(sm.getHeader()),
 		entries: sm.getEntries(),
 		leafId: sm.getLeafId(),
 	};