@oh-my-pi/pi-coding-agent 15.9.5 → 15.9.67

package/src/cli/claude-trace-cli.ts

@@ -380,6 +380,18 @@ function isMessagesRequest(message: ParsedHttpMessage): boolean {
 	return pathNameFromRequestTarget(message.path ?? "") === "/v1/messages";
 }
 
+// Claude Code fires a background warmup/classification call on its small fast
+// model (a haiku variant, ANTHROPIC_SMALL_FAST_MODEL) before sending the user's
+// real message. Skip it so the capture lands on the actual prompt.
+function isBackgroundModelRequest(message: ParsedHttpMessage): boolean {
+	try {
+		const parsed = JSON.parse(decodeBody(message.headers, message.body)) as { model?: unknown };
+		return typeof parsed.model === "string" && parsed.model.toLowerCase().includes("haiku");
+	} catch {
+		return false;
+	}
+}
+
 function decodeBody(headers: readonly HeaderEntry[], body: Buffer): string {
 	const encoding = headerValue(headers, "content-encoding")?.toLowerCase().trim();
 	try {
@@ -636,7 +648,7 @@ export class ClaudeMessagesProxy {
 			upstreamTls.write(data);
 			const messages = requestParser.push(data);
 			for (const message of messages) {
-				if (!isMessagesRequest(message)) {
+				if (!isMessagesRequest(message) || isBackgroundModelRequest(message)) {
 					responseQueue.push(null);
 					continue;
 				}

package/src/config/keybindings.ts

@@ -119,7 +119,10 @@ export const KEYBINDINGS = {
 		description: "Open external editor",
 	},
 	"app.message.followUp": {
-		defaultKeys: "ctrl+enter",
+		// Ctrl+Enter is preserved for terminals that deliver it (Kitty/iTerm2/WezTerm/Ghostty),
+		// but Windows Terminal does not emit a distinct event for Ctrl+Enter — Ctrl+Q is listed
+		// first so the default binding works there without remapping (#1903).
+		defaultKeys: ["ctrl+q", "ctrl+enter"],
 		description: "Send follow-up message",
 	},
 	"app.message.dequeue": {
@@ -439,16 +442,51 @@ function migrateKeybindingsConfigFile(agentDir: string): void {
 	loadKeybindingsConfig(readPath, writeBackPath);
 }
 
+const FOLLOW_UP_KEYBINDING: AppKeybinding = "app.message.followUp";
+const WINDOWS_FOLLOW_UP_FALLBACK_KEY: KeyId = "ctrl+q";
+
+function keyListIncludes(keys: KeyId | KeyId[] | undefined, target: KeyId): boolean {
+	if (keys === undefined) return false;
+	const keyList = Array.isArray(keys) ? keys : [keys];
+	for (const key of keyList) {
+		if (key.toLowerCase() === target) return true;
+	}
+	return false;
+}
+
+function userBindingClaimsKey(config: KeybindingsConfig, target: KeyId, except: Keybinding): boolean {
+	for (const [keybinding, keys] of Object.entries(config)) {
+		if (!(keybinding in KEYBINDINGS)) continue;
+		if (keybinding === except) continue;
+		if (keyListIncludes(keys, target)) return true;
+	}
+	return false;
+}
+
+function removeKey(keys: KeyId[], target: KeyId): KeyId[] {
+	return keys.filter(key => key !== target);
+}
+
+function keyConfigValue(keys: KeyId[]): KeyId | KeyId[] {
+	if (keys.length === 1) {
+		const key = keys[0];
+		if (key !== undefined) return key;
+	}
+	return [...keys];
+}
+
 /**
  * Manages all keybindings (app + TUI).
  * Extends the TUI KeybindingsManager with app-specific functionality.
  */
 export class KeybindingsManager extends TuiKeybindingsManager {
 	#configPath: string | undefined;
+	#userBindings: KeybindingsConfig;
 
 	constructor(userBindings: KeybindingsConfig = {}, configPath?: string) {
 		super(KEYBINDINGS, userBindings);
 		this.#configPath = configPath;
+		this.#userBindings = userBindings;
 	}
 
 	/**
@@ -480,6 +518,25 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 		this.setUserBindings(config);
 	}
 
+	setUserBindings(userBindings: KeybindingsConfig): void {
+		this.#userBindings = userBindings;
+		super.setUserBindings(userBindings);
+	}
+
+	getKeys(keybinding: Keybinding): KeyId[] {
+		const keys = super.getKeys(keybinding);
+		if (keybinding !== FOLLOW_UP_KEYBINDING) return keys;
+		if (this.#userBindings[FOLLOW_UP_KEYBINDING] !== undefined) return keys;
+		if (!userBindingClaimsKey(this.#userBindings, WINDOWS_FOLLOW_UP_FALLBACK_KEY, FOLLOW_UP_KEYBINDING)) return keys;
+		return removeKey(keys, WINDOWS_FOLLOW_UP_FALLBACK_KEY);
+	}
+
+	getResolvedBindings(): KeybindingsConfig {
+		const resolved = super.getResolvedBindings();
+		resolved[FOLLOW_UP_KEYBINDING] = keyConfigValue(this.getKeys(FOLLOW_UP_KEYBINDING));
+		return resolved;
+	}
+
 	/**
 	 * Get the effective resolved bindings (defaults + user overrides).
 	 */

package/src/config/settings-schema.ts

@@ -902,6 +902,15 @@ export const SETTINGS_SCHEMA = {
 				"Maximum wait between retries, in ms. When the provider asks us to wait longer than this and no credential or model fallback succeeds, the request fails fast instead of sleeping (e.g. 3-hour Anthropic rate-limit windows).",
 		},
 	},
+	"retry.modelFallback": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			label: "Retry Model Fallback",
+			description: "Allow retry recovery to switch to configured fallback models",
+		},
+	},
 	"retry.fallbackChains": { type: "record", default: {} as Record<string, string[]> },
 	"retry.fallbackRevertPolicy": {
 		type: "enum",
@@ -1855,7 +1864,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "editing",
 			label: "Hash Lines",
 			description:
-				"Include snapshot-tag headers and line numbers in read output for hashline edit mode (¶PATH#tag plus LINE:content)",
+				"Include snapshot-tag headers and line numbers in read output for hashline edit mode ([PATH#TAG] plus LINE:content)",
 		},
 	},
 
@@ -3307,6 +3316,7 @@ export interface RetrySettings {
 	maxRetries: number;
 	baseDelayMs: number;
 	maxDelayMs: number;
+	modelFallback: boolean;
 }
 
 export interface MemoriesSettings {

package/src/debug/raw-sse.ts

@@ -1,4 +1,12 @@
-import { type Component, matchesKey, padding, replaceTabs, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import {
+	type Component,
+	matchesKey,
+	padding,
+	replaceTabs,
+	ScrollView,
+	truncateToWidth,
+	visibleWidth,
+} from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { theme } from "../modes/theme/theme";
 import { copyToClipboard } from "../utils/clipboard";
@@ -146,14 +154,20 @@ export class RawSseViewerComponent implements Component {
 		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
 		const bodyHeight = this.#bodyHeight();
 		const rawLines = this.#renderRawLines(innerWidth);
-		const body = rawLines.slice(this.#scrollOffset, this.#scrollOffset + bodyHeight);
-		while (body.length < bodyHeight) body.push("");
+		const sv = new ScrollView(rawLines.slice(this.#scrollOffset, this.#scrollOffset + bodyHeight), {
+			height: bodyHeight,
+			scrollbar: "auto",
+			totalRows: rawLines.length,
+			theme: { track: t => theme.fg("muted", t), thumb: t => theme.fg("accent", t) },
+		});
+		sv.setScrollOffset(this.#scrollOffset);
+		const bodyRows = sv.render(innerWidth);
 
 		return [
 			this.#frameTop(innerWidth),
 			this.#frameLine(this.#summaryText(), innerWidth),
 			this.#frameSeparator(innerWidth),
-			...body.map(line => this.#frameLine(line, innerWidth)),
+			...bodyRows.map(line => this.#frameLine(line, innerWidth)),
 			this.#frameLine(this.#statusText(), innerWidth),
 			this.#frameBottom(innerWidth),
 		];

package/src/edit/file-snapshot-store.ts

@@ -14,7 +14,7 @@ import { normalizeToLF } from "./normalize";
 /**
  * Upper bound on the file size we snapshot. A section tag is a content hash of
  * the *whole* file, so minting one means holding the full normalized text in
- * the store. Files above this cap emit no `¶path#tag` header — line-anchored
+ * the store. Files above this cap emit no `[path#tag]` header — line-anchored
  * editing of multi-megabyte files is out of scope under the full-content model.
  */
 export const SNAPSHOT_MAX_BYTES = 4 * 1024 * 1024;

package/src/edit/index.ts

@@ -275,7 +275,7 @@ function extractApprovalPath(args: unknown): string {
 	const record = args && typeof args === "object" ? (args as Record<string, unknown>) : {};
 	const input = typeof record.input === "string" ? record.input : undefined;
 	if (input) {
-		const hashlineMatch = /^(?:¶|§|@)([^\s#]+)/m.exec(input);
+		const hashlineMatch = /^\[([^#\r\n]+)(?:#[0-9a-fA-F]{4})?\]/m.exec(input);
 		if (hashlineMatch?.[1]) return hashlineMatch[1];
 
 		const applyPatchMatch = /^\*\*\* (?:Add|Update|Delete) File:\s*(.+)$/m.exec(input);

package/src/edit/renderer.ts

@@ -2,7 +2,7 @@
  * Edit tool renderer and LSP batching helpers.
  */
 
-import { HL_FILE_PREFIX } from "@oh-my-pi/hashline";
+import { HL_FILE_PREFIX, HL_FILE_SUFFIX } from "@oh-my-pi/hashline";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
@@ -328,12 +328,12 @@ function normalizeHashlineInputPreviewPath(rawPath: string): string {
 }
 
 function parseHashlineInputPreviewHeader(line: string): string | null {
-	if (!line.startsWith(HL_FILE_PREFIX)) return null;
-	// Mirror hashline/input.ts: strip every leading file marker so canonical
-	// `¶ PATH` headers and stray `¶¶ PATH` / `¶¶¶PATH` runs render clean paths.
-	let prefixEnd = 0;
-	while (prefixEnd < line.length && line[prefixEnd] === HL_FILE_PREFIX) prefixEnd++;
-	const body = line.slice(prefixEnd).trim();
+	const trimmed = line.trimEnd();
+	if (!trimmed.startsWith(HL_FILE_PREFIX)) return null;
+	// Keep streaming previews tolerant while the closing bracket is still
+	// being generated; the parser enforces the final `[path#TAG]` shape.
+	const bodyEnd = trimmed.endsWith(HL_FILE_SUFFIX) ? trimmed.length - HL_FILE_SUFFIX.length : trimmed.length;
+	const body = trimmed.slice(HL_FILE_PREFIX.length, bodyEnd).trim();
 	const previewPath = normalizeHashlineInputPreviewPath(body);
 	return previewPath.length > 0 ? previewPath : null;
 }

package/src/edit/streaming.ts

@@ -424,7 +424,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		return previews.length > 0 ? previews : null;
 	},
 	renderStreamingFallback() {
-		// Never leak raw hashline syntax (`64:`, `|payload`, `¶path#hash`)
+		// Never leak raw hashline syntax (`64:`, `|payload`, `[path#hash]`)
 		// to the user — the streaming preview already projects every
 		// parseable op onto the real file via applyPartialTo, and an
 		// unparseable trailing chunk renders as "no preview yet" rather

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

@@ -10,7 +10,7 @@ import { AgentOutputManager } from "../../task/output-manager";
 import type { AgentDefinition, AgentProgress, SingleResult } from "../../task/types";
 import type { ToolSession } from "../../tools";
 import { EVAL_AGENT_MAX_DEPTH, runEvalAgent } from "../agent-bridge";
-import { EVAL_HEARTBEAT_OP, setBridgeHeartbeatIntervalMs } from "../heartbeat";
+import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP } from "../bridge-timeout";
 import { IdleTimeout } from "../idle-timeout";
 import { disposeAllVmContexts } from "../js/context-manager";
 import { executeJs } from "../js/executor";
@@ -236,7 +236,6 @@ describe("runEvalAgent", () => {
 describe("agent() through eval runtimes", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
-		setBridgeHeartbeatIntervalMs();
 	});
 
 	afterAll(async () => {
@@ -560,24 +559,20 @@ describe("agent() through eval runtimes", () => {
 		expect(displayAgentEvents.length).toBe(2);
 	});
 
-	it("keeps the idle watchdog armed while a quiet agent() runs past the budget", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-agent-heartbeat-");
-		const { session } = makeEvalSession(tempDir, "js-agent-heartbeat");
+	it("pauses the idle watchdog while a quiet agent() runs past the budget", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-timeout-pause-");
+		const { session } = makeEvalSession(tempDir, "js-agent-timeout-pause");
 		mockAgents();
-		// Heartbeat cadence well under the idle budget so a working-but-silent
-		// subagent re-arms the watchdog several times before it could expire.
-		setBridgeHeartbeatIntervalMs(15);
 
-		// runSubprocess runs far past the budget and emits NO progress of its own
-		// — the only thing standing between the subagent and a spurious idle abort
-		// is the heartbeat keepalive the bridge pumps while it awaits.
+		// runSubprocess runs far past the eval timeout budget and emits NO progress
+		// of its own. The bridge pause must make that delegated time invisible to
+		// the watchdog.
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
 			await Bun.sleep(200);
 			return singleResult(options, { output: "done" });
 		});
 
-		// Mirror the eval tool's wiring: an IdleTimeout drives cancellation and
-		// ONLY a bridge heartbeat re-arms it.
+		const ops: string[] = [];
 		using idle = new IdleTimeout(60);
 		const result = await runEvalAgent(
 			{ prompt: "investigate" },
@@ -585,25 +580,29 @@ describe("agent() through eval runtimes", () => {
 				session,
 				signal: idle.signal,
 				emitStatus: event => {
-					if (event.op === EVAL_HEARTBEAT_OP) idle.bump();
+					ops.push(event.op);
+					if (event.op === EVAL_TIMEOUT_PAUSE_OP) idle.pause();
+					if (event.op === EVAL_TIMEOUT_RESUME_OP) idle.resume();
 				},
 			},
 		);
 
-		expect(idle.signal.aborted).toBe(false);
 		expect(result.text).toBe("done");
+		expect(ops).toEqual([EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP]);
+		expect(idle.signal.aborted).toBe(false);
+
+		await Bun.sleep(90);
+		expect(idle.signal.aborted).toBe(true);
 	});
 
-	it("does not let agent() progress snapshots re-arm the watchdog without a heartbeat", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-agent-progress-no-rearm-");
-		const { session } = makeEvalSession(tempDir, "js-agent-progress-no-rearm");
+	it("keeps timeout paused despite agent() progress snapshots", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-progress-timeout-pause-");
+		const { session } = makeEvalSession(tempDir, "js-agent-progress-timeout-pause");
 		mockAgents();
-		// Heartbeat slower than the budget: only the immediate beat at call start
-		// fires, so after the budget elapses nothing re-arms the watchdog.
-		setBridgeHeartbeatIntervalMs(10_000);
 
 		// Stream frequent progress snapshots (op:"agent") for well past the budget.
-		// Progress is rendered but MUST NOT count as activity — only heartbeats do.
+		// They render as status, but timeout accounting is controlled only by the
+		// bridge pause/resume events.
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
 			for (let i = 0; i < 40; i++) {
 				options.onProgress?.({
@@ -629,21 +628,23 @@ describe("agent() through eval runtimes", () => {
 
 		const ops: string[] = [];
 		using idle = new IdleTimeout(80);
-		await runEvalAgent(
+		const result = await runEvalAgent(
 			{ prompt: "investigate" },
 			{
 				session,
 				signal: idle.signal,
 				emitStatus: event => {
 					ops.push(event.op);
-					if (event.op === EVAL_HEARTBEAT_OP) idle.bump();
+					if (event.op === EVAL_TIMEOUT_PAUSE_OP) idle.pause();
+					if (event.op === EVAL_TIMEOUT_RESUME_OP) idle.resume();
 				},
 			},
 		);
 
-		// Progress streamed, but the watchdog still fired: agent snapshots never
-		// re-armed it, and the lone start heartbeat lapsed before the call ended.
+		expect(result.text).toBe("done");
+		expect(ops[0]).toBe(EVAL_TIMEOUT_PAUSE_OP);
 		expect(ops).toContain("agent");
-		expect(idle.signal.aborted).toBe(true);
+		expect(ops.at(-1)).toBe(EVAL_TIMEOUT_RESUME_OP);
+		expect(idle.signal.aborted).toBe(false);
 	});
 });

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

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "bun:test";
+import {
+	EVAL_TIMEOUT_PAUSE_OP,
+	EVAL_TIMEOUT_RESUME_OP,
+	isEvalTimeoutControlEvent,
+	withBridgeTimeoutPause,
+} from "../bridge-timeout";
+import type { JsStatusEvent } from "../js/shared/types";
+
+describe("withBridgeTimeoutPause", () => {
+	it("emits one pause before the operation and one resume after it settles", async () => {
+		const events: JsStatusEvent[] = [];
+
+		const value = await withBridgeTimeoutPause(
+			event => events.push(event),
+			async () => {
+				await Bun.sleep(80);
+				return "done";
+			},
+		);
+
+		expect(value).toBe("done");
+		expect(events.map(event => event.op)).toEqual([EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP]);
+
+		const settledCount = events.length;
+		await Bun.sleep(40);
+		expect(events.length).toBe(settledCount);
+	});
+
+	it("resumes timeout accounting even when the operation throws", async () => {
+		const events: JsStatusEvent[] = [];
+
+		await expect(
+			withBridgeTimeoutPause(
+				event => events.push(event),
+				async () => {
+					await Bun.sleep(20);
+					throw new Error("boom");
+				},
+			),
+		).rejects.toThrow("boom");
+
+		expect(events.map(event => event.op)).toEqual([EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP]);
+	});
+
+	it("runs the operation without emitting when no status sink is wired", async () => {
+		let ran = 0;
+
+		const value = await withBridgeTimeoutPause(undefined, async () => {
+			ran++;
+			await Bun.sleep(20);
+			return 42;
+		});
+
+		expect(value).toBe(42);
+		expect(ran).toBe(1);
+	});
+
+	it("identifies timeout-control events as non-renderable status", () => {
+		expect(isEvalTimeoutControlEvent({ op: EVAL_TIMEOUT_PAUSE_OP })).toBe(true);
+		expect(isEvalTimeoutControlEvent({ op: EVAL_TIMEOUT_RESUME_OP })).toBe(true);
+		expect(isEvalTimeoutControlEvent({ op: "agent", id: "subagent-1" })).toBe(false);
+	});
+});

package/src/eval/__tests__/idle-timeout.test.ts

@@ -32,21 +32,34 @@ describe("IdleTimeout", () => {
 		expect((idle.signal.reason as DOMException).name).toBe("TimeoutError");
 	});
 
-	it("re-arms on every bump and only fires after activity stops", async () => {
-		using idle = new IdleTimeout(150);
-		// Bump well past a single window; each bump must push the deadline forward
-		// so the watchdog never trips while activity continues.
-		for (let i = 0; i < 6; i++) {
-			await Bun.sleep(40);
-			idle.bump();
-		}
+	it("ignores elapsed time while paused and resumes with a fresh window", async () => {
+		using idle = new IdleTimeout(80);
+		idle.pause();
+		await Bun.sleep(160);
 		expect(idle.signal.aborted).toBe(false);
 
-		// Activity stopped — the watchdog should now fire within roughly one window.
-		const fired = await abortedWithin(idle.signal, 800);
+		idle.resume();
+		const firedEarly = await abortedWithin(idle.signal, 30);
+		expect(firedEarly).toBe(false);
+		const fired = await abortedWithin(idle.signal, 500);
 		expect(fired).toBe(true);
 	});
 
+	it("reference-counts overlapping pauses", async () => {
+		using idle = new IdleTimeout(60);
+		idle.pause();
+		idle.pause();
+		await Bun.sleep(120);
+		expect(idle.signal.aborted).toBe(false);
+
+		idle.resume();
+		await Bun.sleep(90);
+		expect(idle.signal.aborted).toBe(false);
+
+		idle.resume();
+		const fired = await abortedWithin(idle.signal, 500);
+		expect(fired).toBe(true);
+	});
 	it("never fires after dispose()", async () => {
 		const idle = new IdleTimeout(30);
 		idle.dispose();
@@ -55,12 +68,13 @@ describe("IdleTimeout", () => {
 		expect(idle.signal.aborted).toBe(false);
 	});
 
-	it("ignores bump() after the watchdog has already fired", async () => {
+	it("ignores pause/resume after the watchdog has already fired", async () => {
 		using idle = new IdleTimeout(30);
 		await abortedWithin(idle.signal, 500);
 		expect(idle.signal.aborted).toBe(true);
 		// Late activity must not un-abort or rearm a settled watchdog.
-		idle.bump();
+		idle.pause();
+		idle.resume();
 		expect(idle.signal.aborted).toBe(true);
 	});
 });

package/src/eval/__tests__/kernel-spawn.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import {
+	__resetWindowsConsoleProbeCache,
+	consoleAttachedViaTTY,
+	hostHasInheritableConsole,
+	shouldHideKernelWindow,
+} from "../py/spawn-options";
+
+/**
+ * `shouldHideKernelWindow` decides whether the long-lived Python kernel
+ * subprocess is spawned with `windowsHide: true`. On Windows, Bun maps that
+ * option to `CREATE_NO_WINDOW`, which detaches the child from any inherited
+ * console — breaking both (a) `LoadLibraryExW` for NumPy/pandas native
+ * extensions and (b) SIGINT delivery via `GenerateConsoleCtrlEvent`. See
+ * issue #1960. The tests below pin the three layered concerns the PR review
+ * surfaced:
+ *
+ * 1. `shouldHideKernelWindow` — pure predicate over a single boolean.
+ * 2. `consoleAttachedViaTTY` — the TTY-OR fallback used when the Win32 FFI
+ *    probe is unavailable; covers the partial-redirection cases.
+ * 3. `hostHasInheritableConsole` — the integration boundary. Off-Windows it
+ *    short-circuits to the TTY fallback; on Windows it is expected to
+ *    consult `kernel32!GetConsoleWindow()` first, which is the authoritative
+ *    signal even for the all-stdio-redirected case.
+ */
+describe("shouldHideKernelWindow", () => {
+	it("inherits the host console on Windows when one is attached", () => {
+		// Reporter's repro: omp launched in Windows Terminal, host has a
+		// console, kernel must inherit so `import pandas` doesn't deadlock in
+		// `_multiarray_umath` and SIGINT can recover the cell.
+		expect(shouldHideKernelWindow({ platform: "win32", hostHasInheritableConsole: true })).toBe(false);
+	});
+
+	it("hides on Windows only when the host has no console at all (true service / daemon)", () => {
+		// CREATE_NO_WINDOW here suppresses the console window Windows would
+		// otherwise auto-allocate for the console-app Python kernel.
+		expect(shouldHideKernelWindow({ platform: "win32", hostHasInheritableConsole: false })).toBe(true);
+	});
+
+	it("never sets windowsHide off-Windows (the option is a Win32-only flag)", () => {
+		// On POSIX `windowsHide` is a no-op; the predicate must return false
+		// everywhere off-Windows so the spawn site matches pre-fix behavior.
+		expect(shouldHideKernelWindow({ platform: "linux", hostHasInheritableConsole: true })).toBe(false);
+		expect(shouldHideKernelWindow({ platform: "linux", hostHasInheritableConsole: false })).toBe(false);
+		expect(shouldHideKernelWindow({ platform: "darwin", hostHasInheritableConsole: true })).toBe(false);
+		expect(shouldHideKernelWindow({ platform: "darwin", hostHasInheritableConsole: false })).toBe(false);
+	});
+});
+
+describe("consoleAttachedViaTTY (FFI fallback heuristic)", () => {
+	// The OR of three TTY signals correctly classifies the realistic shell
+	// redirection scenarios that motivated widening the check beyond stdout
+	// in the first review pass (PR #1961). The all-three-redirected case
+	// (false here) is the gap that the Win32 FFI probe in
+	// `hostHasInheritableConsole` is meant to close — this fallback is best-
+	// effort.
+
+	it("treats a fully interactive launch as console-attached", () => {
+		expect(consoleAttachedViaTTY({ stdinIsTTY: true, stdoutIsTTY: true, stderrIsTTY: true })).toBe(true);
+	});
+
+	it("treats `omp -p '...' > out.txt` (stdout-only redirect) as console-attached", () => {
+		// The reviewer's first-pass repro: stdout off the terminal, stdin
+		// and stderr still attached. OR keeps the console.
+		expect(consoleAttachedViaTTY({ stdinIsTTY: true, stdoutIsTTY: false, stderrIsTTY: true })).toBe(true);
+	});
+
+	it("treats stdin-only redirects (`< in.txt`) as console-attached", () => {
+		expect(consoleAttachedViaTTY({ stdinIsTTY: false, stdoutIsTTY: true, stderrIsTTY: true })).toBe(true);
+	});
+
+	it("treats stderr-only redirects (`2> err.log`) as console-attached", () => {
+		expect(consoleAttachedViaTTY({ stdinIsTTY: true, stdoutIsTTY: true, stderrIsTTY: false })).toBe(true);
+	});
+
+	it("returns false only when none of stdin/stdout/stderr is a TTY", () => {
+		// This is the gap: a real Windows Terminal session with all three
+		// streams redirected (`omp ... < in > out 2> err`) lands here.
+		// `hostHasInheritableConsole` uses the Win32 FFI probe to recover
+		// the right answer in that scenario; this helper is the fallback.
+		expect(consoleAttachedViaTTY({ stdinIsTTY: false, stdoutIsTTY: false, stderrIsTTY: false })).toBe(false);
+	});
+});
+
+describe("hostHasInheritableConsole", () => {
+	afterEach(() => {
+		__resetWindowsConsoleProbeCache();
+	});
+
+	if (process.platform !== "win32") {
+		it("matches the TTY-OR fallback off-Windows", () => {
+			// Off-Windows, `windowsHide` is a no-op anyway, but we still
+			// expose `hostHasInheritableConsole` symmetrically. Confirm it
+			// degrades to the same OR the call site would compute by hand.
+			const tty = consoleAttachedViaTTY({
+				stdinIsTTY: !!process.stdin.isTTY,
+				stdoutIsTTY: !!process.stdout.isTTY,
+				stderrIsTTY: !!process.stderr.isTTY,
+			});
+			expect(hostHasInheritableConsole()).toBe(tty);
+		});
+	}
+});

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

@@ -8,7 +8,7 @@ import type { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
 import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
-import { EVAL_HEARTBEAT_OP, setBridgeHeartbeatIntervalMs } from "../heartbeat";
+import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP } from "../bridge-timeout";
 import { IdleTimeout } from "../idle-timeout";
 import { disposeAllVmContexts } from "../js/context-manager";
 import { executeJs } from "../js/executor";
@@ -99,7 +99,6 @@ function assistant(opts: {
 describe("runEvalLlm", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
-		setBridgeHeartbeatIntervalMs();
 	});
 
 	it("resolves each tier to its expected model", async () => {
@@ -217,31 +216,32 @@ describe("runEvalLlm", () => {
 		);
 	});
 
-	it("keeps the idle watchdog armed while a slow llm() request is in flight", async () => {
-		// A oneshot completion emits no status until it returns; a slow request
-		// must not look like a stalled cell. The bridge pumps a heartbeat while it
-		// awaits, re-arming the watchdog through emitStatus.
-		setBridgeHeartbeatIntervalMs(15);
+	it("pauses the idle watchdog while a slow llm() request is in flight", async () => {
+		// A oneshot completion emits no status until it returns; delegated model
+		// time must be invisible to the eval timeout budget.
 		vi.spyOn(ai, "completeSimple").mockImplementation(async () => {
 			await Bun.sleep(200);
 			return assistant({ text: "the answer" });
 		});
 
+		const ops: string[] = [];
 		using idle = new IdleTimeout(60);
 		const result = await runEvalLlm(
 			{ prompt: "q", model: "smol" },
 			{
 				session: makeSession(),
 				signal: idle.signal,
-				// Mirror the eval tool: only a bridge heartbeat re-arms the watchdog.
 				emitStatus: event => {
-					if (event.op === EVAL_HEARTBEAT_OP) idle.bump();
+					ops.push(event.op);
+					if (event.op === EVAL_TIMEOUT_PAUSE_OP) idle.pause();
+					if (event.op === EVAL_TIMEOUT_RESUME_OP) idle.resume();
 				},
 			},
 		);
 
-		expect(idle.signal.aborted).toBe(false);
 		expect(result.text).toBe("the answer");
+		expect(ops).toEqual([EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP, "llm"]);
+		expect(idle.signal.aborted).toBe(false);
 	});
 });