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

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/model-registry.ts

@@ -38,6 +38,45 @@ const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 // "socket connection was closed unexpectedly").
 const DISCOVERY_DEFAULT_MAX_TOKENS = 32_768;
 
+const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
+const OLLAMA_HOST_DEFAULT_PORT = "11434";
+
+function normalizeOllamaHostEnv(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	if (!trimmed) return undefined;
+	const candidate = trimmed.includes("://")
+		? trimmed
+		: trimmed.startsWith("//")
+			? `http:${trimmed}`
+			: trimmed.startsWith(":")
+				? `http://127.0.0.1${trimmed}`
+				: `http://${trimmed}`;
+	try {
+		const parsed = new URL(candidate);
+		if (!parsed.hostname || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) {
+			return undefined;
+		}
+		if (!parsed.port && parsed.protocol === "http:") {
+			parsed.port = OLLAMA_HOST_DEFAULT_PORT;
+		}
+		return `${parsed.protocol}//${parsed.host}`;
+	} catch {
+		return undefined;
+	}
+}
+
+function getImplicitOllamaBaseUrl(): string {
+	const baseUrl = Bun.env.OLLAMA_BASE_URL?.trim();
+	return baseUrl || normalizeOllamaHostEnv(Bun.env.OLLAMA_HOST) || DEFAULT_OLLAMA_BASE_URL;
+}
+
+function getOllamaContextLengthOverride(): number | undefined {
+	const value = Bun.env.OLLAMA_CONTEXT_LENGTH?.trim();
+	if (!value) return undefined;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
 // Anthropic-safe variant of the discovery cap. The Anthropic stream converter
 // in `packages/ai/src/providers/anthropic.ts` derives the request limit as
 // `(model.maxTokens / 3) | 0`, so the 32K default would surface as 10,922
@@ -1220,7 +1259,18 @@ export class ModelRegistry {
 			return models;
 		}
 
-		return models.map(model => (model.api === "openai-completions" ? { ...model, api: "openai-responses" } : model));
+		const contextLengthOverride = getOllamaContextLengthOverride();
+		return models.map(model => {
+			const normalized = model.api === "openai-completions" ? { ...model, api: "openai-responses" as const } : model;
+			if (contextLengthOverride === undefined) {
+				return normalized;
+			}
+			return {
+				...normalized,
+				contextWindow: contextLengthOverride,
+				maxTokens: Math.min(contextLengthOverride, DISCOVERY_DEFAULT_MAX_TOKENS),
+			};
+		});
 	}
 
 	#addImplicitDiscoverableProviders(configuredProviders: Set<string>): void {
@@ -1229,7 +1279,7 @@ export class ModelRegistry {
 			this.#discoverableProviders.push({
 				provider: "ollama",
 				api: "openai-responses",
-				baseUrl: Bun.env.OLLAMA_BASE_URL || "http://127.0.0.1:11434",
+				baseUrl: getImplicitOllamaBaseUrl(),
 				discovery: { type: "ollama" },
 				optional: true,
 			});
@@ -1993,12 +2043,12 @@ export class ModelRegistry {
 		}
 	}
 	#normalizeOllamaBaseUrl(baseUrl?: string): string {
-		const raw = baseUrl || "http://127.0.0.1:11434";
+		const raw = baseUrl || DEFAULT_OLLAMA_BASE_URL;
 		try {
 			const parsed = new URL(raw);
 			return `${parsed.protocol}//${parsed.host}`;
 		} catch {
-			return "http://127.0.0.1:11434";
+			return DEFAULT_OLLAMA_BASE_URL;
 		}
 	}
 

package/src/config/settings-schema.ts

@@ -635,7 +635,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "appearance",
 			label: "Terminal Hyperlinks",
 			description:
-				"Wrap file paths in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
+				"Wrap paths and URLs in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
 		},
 	},
 	// Display rendering
@@ -722,6 +722,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	includeModelInPrompt: {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			label: "Include Model In Prompt",
+			description: "Surface the active model identifier in the system prompt so the agent knows which model it is",
+		},
+	},
+
 	// Sampling
 	temperature: {
 		type: "number",
@@ -892,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",
@@ -1845,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)",
 		},
 	},
 
@@ -2483,13 +2502,13 @@ export const SETTINGS_SCHEMA = {
 	// Tool Discovery
 	"tools.discoveryMode": {
 		type: "enum",
-		values: ["off", "mcp-only", "all"] as const,
-		default: "off",
+		values: ["auto", "off", "mcp-only", "all"] as const,
+		default: "auto",
 		ui: {
 			tab: "tools",
 			label: "Tool Discovery",
 			description:
-				"Hide tools behind a search tool to save tokens. 'mcp-only' hides MCP tools; 'all' hides all non-essential built-ins too.",
+				"Hide tools behind a search tool to save tokens. 'auto' hides MCP tools once the tool set has more than 40 tools; 'mcp-only' always hides MCP tools; 'all' hides all non-essential built-ins too.",
 		},
 	},
 
@@ -3297,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 () => {
@@ -397,6 +396,78 @@ describe("agent() through eval runtimes", () => {
 		expect(maxInFlight).toBeLessThanOrEqual(2);
 	});
 
+	it("interrupting a Python parallel() fan-out settles the kernel cleanly and preserves session state", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-py-interrupt-");
+		const settings = Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+			"task.maxConcurrency": 6,
+		});
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "py-agent-interrupt", settings);
+		mockAgents();
+		// Subagents that ignore the abort for far longer than the kernel's SIGINT
+		// escalation window. Each kernel worker thread blocks in a synchronous
+		// `urllib` bridge call, joined by `parallel()`'s ThreadPoolExecutor exit.
+		// The host must respond the instant the cell aborts so the kernel can
+		// unwind via KeyboardInterrupt instead of being hard-killed (which used to
+		// surface "[kernel] Python kernel shutdown" and lose all session state).
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			await Bun.sleep(9000); // deliberately ignores options.signal
+			return singleResult(options, { output: options.assignment ?? "" });
+		});
+
+		// Seed persistent session state and confirm the kernel is reusable.
+		const seed = await executePython("PREP_MARKER = 4242", {
+			cwd: tempDir.path(),
+			sessionId,
+			sessionFile,
+			kernelMode: "session",
+			toolSession: session,
+		});
+		if (seed.exitCode === undefined && seed.cancelled) {
+			expect(seed.output).toBe("");
+			return; // kernel unavailable in this environment
+		}
+		expect(seed.exitCode).toBe(0);
+
+		const ac = new AbortController();
+		// Abort ~1s in, after the worker threads are blocked in their bridge calls.
+		setTimeout(() => ac.abort(new Error("external interrupt")), 1000);
+
+		const start = Date.now();
+		const result = await executePython(
+			"import json\nprint(json.dumps(parallel([lambda n=n: agent(str(n)) for n in range(12)])))",
+			{
+				cwd: tempDir.path(),
+				sessionId,
+				sessionFile,
+				kernelMode: "session",
+				toolSession: session,
+				idleTimeoutMs: 60_000,
+				signal: ac.signal,
+			},
+		);
+		const elapsed = Date.now() - start;
+
+		// Cancelled, but cleanly: no hard-kill, settled well within the kernel's 5s
+		// SIGINT escalation window rather than ~6s after it.
+		expect(result.cancelled).toBe(true);
+		expect(result.output).not.toContain("Python kernel shutdown");
+		expect(elapsed).toBeLessThan(4000);
+
+		// The persistent kernel survived the interrupt: prior state is intact.
+		const after = await executePython("print(PREP_MARKER)", {
+			cwd: tempDir.path(),
+			sessionId,
+			sessionFile,
+			kernelMode: "session",
+			toolSession: session,
+		});
+		expect(after.exitCode).toBe(0);
+		expect(after.output.trim()).toBe("4242");
+	}, 30_000);
+
 	it("streams enriched agent progress through onStatus before the cell finishes", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-agent-progress-");
 		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-progress");
@@ -488,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" },
@@ -513,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?.({
@@ -557,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);
 	});
 });