@oh-my-pi/pi-coding-agent 15.7.3 → 15.7.6

package/src/config/model-registry.ts

@@ -27,6 +27,32 @@ import {
 // any provider module at startup. Must match `DEFAULT_LOCAL_TOKEN` in oauth/lm-studio.ts.
 const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 
+// Default cap on `max_tokens` for auto-discovered models that do not advertise
+// their own output limit (OpenAI-models-list, Ollama, llama.cpp, new-api/
+// one-api proxies). 32K matches the upper end of what mainstream
+// OpenAI-compatible providers (DeepSeek, MiMo, OpenRouter, etc.) actually
+// accept and keeps `min(contextWindow, …)` honoring smaller local windows.
+// Conservative caps below this caused providers to drop the connection
+// mid-stream when models hit the cap on legitimate large tool calls (see
+// issue #1528: `write` payloads >~5KB on deepseek-v4-pro surfaced as
+// "socket connection was closed unexpectedly").
+const DISCOVERY_DEFAULT_MAX_TOKENS = 32_768;
+
+// 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
+// requested output tokens — above the 8,192 hard cap on classic Claude 3.x
+// Sonnet/Haiku/Opus endpoints. Discovered models routed through
+// `anthropic-messages` (proxy `supported_endpoint_types: ["anthropic"]` or a
+// custom provider with `api: anthropic-messages` + openai-models-list
+// discovery) fall back to this conservative value.
+const DISCOVERY_DEFAULT_MAX_TOKENS_ANTHROPIC = 8_192;
+
+/** Routes discovered-model `maxTokens` defaults around Anthropic's 3× output divisor. */
+function discoveryDefaultMaxTokens(api: Api | undefined): number {
+	return api === "anthropic-messages" ? DISCOVERY_DEFAULT_MAX_TOKENS_ANTHROPIC : DISCOVERY_DEFAULT_MAX_TOKENS;
+}
+
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { isRecord, logger } from "@oh-my-pi/pi-utils";
@@ -1690,7 +1716,7 @@ export class ModelRegistry {
 				input: metadata?.input ?? ["text"],
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 				contextWindow: metadata?.contextWindow ?? 128000,
-				maxTokens: Math.min(metadata?.contextWindow ?? Number.POSITIVE_INFINITY, 8192),
+				maxTokens: Math.min(metadata?.contextWindow ?? Number.POSITIVE_INFINITY, DISCOVERY_DEFAULT_MAX_TOKENS),
 				headers: providerConfig.headers,
 			});
 		});
@@ -1760,7 +1786,10 @@ export class ModelRegistry {
 					input: serverMetadata?.input ?? ["text"],
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 					contextWindow: serverMetadata?.contextWindow ?? 128000,
-					maxTokens: Math.min(serverMetadata?.contextWindow ?? Number.POSITIVE_INFINITY, 8192),
+					maxTokens: Math.min(
+						serverMetadata?.contextWindow ?? Number.POSITIVE_INFINITY,
+						DISCOVERY_DEFAULT_MAX_TOKENS,
+					),
 					headers,
 					compat: {
 						supportsStore: false,
@@ -1807,7 +1836,7 @@ export class ModelRegistry {
 					input: ["text"],
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 					contextWindow: 128000,
-					maxTokens: 8192,
+					maxTokens: discoveryDefaultMaxTokens(providerConfig.api),
 					headers,
 					compat: {
 						supportsStore: false,
@@ -1890,7 +1919,7 @@ export class ModelRegistry {
 					// we successfully recover the upstream model identity.
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 					contextWindow: reference?.contextWindow ?? 128000,
-					maxTokens: reference?.maxTokens ?? 8192,
+					maxTokens: reference?.maxTokens ?? discoveryDefaultMaxTokens(api),
 					headers,
 					// OpenAI-compat fields are no-ops on anthropic models; the
 					// Anthropic SDK ignores them. Provider-level disableStrictTools

package/src/config/settings-schema.ts

@@ -14,12 +14,9 @@ import {
 import {
 	AUTO_THINKING_MODEL_OPTIONS,
 	AUTO_THINKING_MODEL_VALUES,
-	DEFAULT_SHAKE_SUMMARY_MODEL_KEY,
 	ONLINE_AUTO_THINKING_MODEL_KEY,
 	ONLINE_MEMORY_MODEL_KEY,
 	ONLINE_TINY_TITLE_MODEL_KEY,
-	SHAKE_SUMMARY_MODEL_OPTIONS,
-	SHAKE_SUMMARY_MODEL_VALUES,
 	TINY_MEMORY_MODEL_OPTIONS,
 	TINY_MEMORY_MODEL_VALUES,
 	TINY_TITLE_MODEL_OPTIONS,
@@ -1139,13 +1136,13 @@ export const SETTINGS_SCHEMA = {
 
 	"compaction.strategy": {
 		type: "enum",
-		values: ["context-full", "handoff", "shake", "shake-summary", "off"] as const,
+		values: ["context-full", "handoff", "shake", "off"] as const,
 		default: "context-full",
 		ui: {
 			tab: "context",
 			label: "Compaction Strategy",
 			description:
-				"Choose in-place context-full maintenance, auto-handoff, surgical shake (drop heavy content), shake with local-model summaries, or disable auto maintenance (off)",
+				"Choose in-place context-full maintenance, auto-handoff, surgical shake (drop heavy content), or disable auto maintenance (off)",
 			options: [
 				{
 					value: "context-full",
@@ -1158,11 +1155,6 @@ export const SETTINGS_SCHEMA = {
 					label: "Shake",
 					description: "Drop heavy content (tool results + large blocks) in place; recover via artifact",
 				},
-				{
-					value: "shake-summary",
-					label: "Shake (summary)",
-					description: "Shake, but compress heavy regions with a local on-device model instead of dropping",
-				},
 				{
 					value: "off",
 					label: "Off",
@@ -1974,6 +1966,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"lsp.diagnosticsDeduplicate": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "editing",
+			label: "Deduplicate Diagnostics",
+			description: "Suppress post-edit LSP diagnostics already shown for a file; only surface new or changed ones",
+		},
+	},
+
 	// Bash interceptor
 	"bashInterceptor.enabled": {
 		type: "boolean",
@@ -3018,19 +3020,6 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	"providers.shakeSummaryModel": {
-		type: "enum",
-		values: SHAKE_SUMMARY_MODEL_VALUES,
-		default: DEFAULT_SHAKE_SUMMARY_MODEL_KEY,
-		ui: {
-			tab: "context",
-			label: "Shake Summary Model",
-			description:
-				"Local on-device model used by /shake summary and the shake-summary compaction strategy to compress heavy regions. Runs entirely on-device; downloads on first use. Falls back to plain elide when unavailable.",
-			options: SHAKE_SUMMARY_MODEL_OPTIONS,
-		},
-	},
-
 	"providers.kimiApiFormat": {
 		type: "enum",
 		values: ["openai", "anthropic"] as const,
@@ -3319,7 +3308,7 @@ export type TreeFilterMode = SettingValue<"treeFilterMode">;
 
 export interface CompactionSettings {
 	enabled: boolean;
-	strategy: "context-full" | "handoff" | "shake" | "shake-summary" | "off";
+	strategy: "context-full" | "handoff" | "shake" | "off";
 	thresholdPercent: number;
 	thresholdTokens: number;
 	reserveTokens: number;

package/src/config/settings.ts

@@ -663,6 +663,16 @@ export class Settings {
 			raw["edit.mode"] = "hashline";
 		}
 
+		// compaction.strategy: removed local-model shake-summary mode; plain shake
+		// keeps the same mechanical artifact-backed reduction without background CPU.
+		const compactionObj = raw.compaction as Record<string, unknown> | undefined;
+		if (compactionObj?.strategy === "shake-summary") {
+			compactionObj.strategy = "shake";
+		}
+		if (raw["compaction.strategy"] === "shake-summary") {
+			raw["compaction.strategy"] = "shake";
+		}
+
 		// statusLine: rename "plan_mode" segment to "mode"
 		const statusLineObj = raw.statusLine as Record<string, unknown> | undefined;
 		if (statusLineObj) {

package/src/discovery/claude.ts

@@ -269,6 +269,29 @@ function readClaudeCommandToggles(): { enableUser: boolean; enableProject: boole
 	}
 }
 
+function getClaudeRelativeCommandName(commandsDir: string, filePath: string): string {
+	return path.relative(commandsDir, filePath).replace(/\.md$/, "");
+}
+
+function addClaudeCommandNamespaceAliases(commands: SlashCommand[], commandsDir: string): SlashCommand[] {
+	const rootCommands: SlashCommand[] = [];
+	const nestedCommands: SlashCommand[] = [];
+	const aliases: SlashCommand[] = [];
+
+	for (const command of commands) {
+		const relativeName = getClaudeRelativeCommandName(commandsDir, command.path);
+		if (!/[\\/]/.test(relativeName)) {
+			rootCommands.push(command);
+			continue;
+		}
+
+		nestedCommands.push(command);
+		aliases.push({ ...command, name: relativeName.replace(/[\\/]+/g, ":") });
+	}
+
+	return nestedCommands.length === 0 ? commands : [...rootCommands, ...nestedCommands, ...aliases];
+}
+
 async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
 	const items: SlashCommand[] = [];
 	const warnings: string[] = [];
@@ -280,19 +303,17 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 		const userResult = await loadFilesFromDir<SlashCommand>(ctx, userCommandsDir, PROVIDER_ID, "user", {
 			extensions: ["md"],
-			transform: (name, content, path, source) => {
-				const cmdName = name.replace(/\.md$/, "");
-				return {
-					name: cmdName,
-					path,
-					content,
-					level: "user",
-					_source: source,
-				};
-			},
+			recursive: true,
+			transform: (name, content, filePath, source) => ({
+				name: name.replace(/\.md$/, ""),
+				path: filePath,
+				content,
+				level: "user",
+				_source: source,
+			}),
 		});
 
-		items.push(...userResult.items);
+		items.push(...addClaudeCommandNamespaceAliases(userResult.items, userCommandsDir));
 		if (userResult.warnings) warnings.push(...userResult.warnings);
 	}
 
@@ -301,19 +322,17 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 		const projectResult = await loadFilesFromDir<SlashCommand>(ctx, projectCommandsDir, PROVIDER_ID, "project", {
 			extensions: ["md"],
-			transform: (name, content, path, source) => {
-				const cmdName = name.replace(/\.md$/, "");
-				return {
-					name: cmdName,
-					path,
-					content,
-					level: "project",
-					_source: source,
-				};
-			},
+			recursive: true,
+			transform: (name, content, filePath, source) => ({
+				name: name.replace(/\.md$/, ""),
+				path: filePath,
+				content,
+				level: "project",
+				_source: source,
+			}),
 		});
 
-		items.push(...projectResult.items);
+		items.push(...addClaudeCommandNamespaceAliases(projectResult.items, projectCommandsDir));
 		if (projectResult.warnings) warnings.push(...projectResult.warnings);
 	}
 

package/src/edit/index.ts

@@ -10,6 +10,7 @@ import {
 	type WritethroughDeferredHandle,
 	writethroughNoop,
 } from "../lsp";
+import { getDiagnosticsLedger } from "../lsp/diagnostics-ledger";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
@@ -102,7 +103,16 @@ function createEditWritethrough(session: ToolSession): WritethroughCallback {
 	const enableLsp = session.enableLsp ?? true;
 	const enableDiagnostics = enableLsp && session.settings.get("lsp.diagnosticsOnEdit");
 	const enableFormat = enableLsp && session.settings.get("lsp.formatOnWrite");
-	return enableLsp ? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics }) : writethroughNoop;
+	const dedup = enableDiagnostics && session.settings.get("lsp.diagnosticsDeduplicate");
+	return enableLsp
+		? createLspWritethrough(session.cwd, {
+				enableFormat,
+				enableDiagnostics,
+				transformDiagnostics: dedup
+					? (path, result) => getDiagnosticsLedger(session).reduce(path, result)
+					: undefined,
+			})
+		: writethroughNoop;
 }
 
 /** Run apply_patch file operations and aggregate their multi-file result. */
@@ -294,6 +304,7 @@ export class EditTool implements AgentTool<TInput> {
 	readonly #fuzzyThreshold: number;
 	readonly #writethrough: WritethroughCallback;
 	readonly #editMode?: EditMode;
+	readonly #dedupDiagnostics: boolean;
 	readonly #pendingDeferredFetches = new Map<string, AbortController>();
 
 	constructor(private readonly session: ToolSession) {
@@ -306,6 +317,10 @@ export class EditTool implements AgentTool<TInput> {
 		this.#editMode = resolveConfiguredEditMode(envEditVariant);
 		this.#allowFuzzy = resolveAllowFuzzy(session, editFuzzy);
 		this.#fuzzyThreshold = resolveFuzzyThreshold(session, editFuzzyThreshold);
+		this.#dedupDiagnostics =
+			(session.enableLsp ?? true) &&
+			session.settings.get("lsp.diagnosticsOnEdit") &&
+			session.settings.get("lsp.diagnosticsDeduplicate");
 		this.#writethrough = createEditWritethrough(session);
 	}
 
@@ -495,8 +510,13 @@ export class EditTool implements AgentTool<TInput> {
 	}
 
 	#injectLateDiagnostics(path: string, diagnostics: FileDiagnosticsResult): void {
-		const summary = diagnostics.summary ?? "";
-		const lines = diagnostics.messages ?? [];
+		const effective = this.#dedupDiagnostics
+			? getDiagnosticsLedger(this.session).reduce(path, diagnostics)
+			: diagnostics;
+		if (this.#dedupDiagnostics && effective.messages.length === 0) return;
+
+		const summary = effective.summary ?? "";
+		const lines = effective.messages ?? [];
 		const body = [`Late LSP diagnostics for ${path} (arrived after the edit tool returned):`, summary, ...lines]
 			.filter(Boolean)
 			.join("\n");

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

@@ -10,6 +10,8 @@ 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 { IdleTimeout } from "../idle-timeout";
 import { disposeAllVmContexts } from "../js/context-manager";
 import { executeJs } from "../js/executor";
 import { disposeAllKernelSessions, executePython } from "../py/executor";
@@ -232,6 +234,7 @@ describe("runEvalAgent", () => {
 describe("agent() through eval runtimes", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
+		setBridgeHeartbeatIntervalMs();
 	});
 
 	afterAll(async () => {
@@ -430,4 +433,91 @@ 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");
+		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.
+		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.
+		using idle = new IdleTimeout(60);
+		const result = await runEvalAgent(
+			{ prompt: "investigate" },
+			{
+				session,
+				signal: idle.signal,
+				emitStatus: event => {
+					if (event.op === EVAL_HEARTBEAT_OP) idle.bump();
+				},
+			},
+		);
+
+		expect(idle.signal.aborted).toBe(false);
+		expect(result.text).toBe("done");
+	});
+
+	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");
+		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.
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			for (let i = 0; i < 40; i++) {
+				options.onProgress?.({
+					index: options.index,
+					id: options.id,
+					agent: options.agent.name,
+					agentSource: options.agent.source,
+					status: "running",
+					task: options.task,
+					assignment: options.assignment,
+					description: options.description,
+					recentTools: [],
+					recentOutput: [],
+					toolCount: i,
+					tokens: 0,
+					cost: 0,
+					durationMs: i * 10,
+				});
+				await Bun.sleep(10);
+			}
+			return singleResult(options, { output: "done" });
+		});
+
+		const ops: string[] = [];
+		using idle = new IdleTimeout(80);
+		await runEvalAgent(
+			{ prompt: "investigate" },
+			{
+				session,
+				signal: idle.signal,
+				emitStatus: event => {
+					ops.push(event.op);
+					if (event.op === EVAL_HEARTBEAT_OP) idle.bump();
+				},
+			},
+		);
+
+		// Progress streamed, but the watchdog still fired: agent snapshots never
+		// re-armed it, and the lone start heartbeat lapsed before the call ended.
+		expect(ops).toContain("agent");
+		expect(idle.signal.aborted).toBe(true);
+	});
 });

package/src/eval/__tests__/heartbeat.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { EVAL_HEARTBEAT_OP, setBridgeHeartbeatIntervalMs, withBridgeHeartbeat } from "../heartbeat";
+import type { JsStatusEvent } from "../js/shared/types";
+
+describe("withBridgeHeartbeat", () => {
+	afterEach(() => {
+		setBridgeHeartbeatIntervalMs();
+	});
+
+	it("pumps heartbeat events on cadence while the operation is pending, then stops", async () => {
+		setBridgeHeartbeatIntervalMs(20);
+		const events: JsStatusEvent[] = [];
+
+		const value = await withBridgeHeartbeat(
+			event => events.push(event),
+			async () => {
+				await Bun.sleep(130);
+				return "done";
+			},
+		);
+
+		expect(value).toBe("done");
+		// ~6 ticks fit in 130ms at a 20ms cadence; assert it ticked repeatedly
+		// without pinning the exact count (scheduler jitter).
+		expect(events.length).toBeGreaterThanOrEqual(3);
+		expect(events.every(event => event.op === EVAL_HEARTBEAT_OP)).toBe(true);
+
+		// The interval is cleared once the operation settles: no further ticks.
+		const settledCount = events.length;
+		await Bun.sleep(80);
+		expect(events.length).toBe(settledCount);
+	});
+
+	it("emits a heartbeat immediately so a bridge call extends the budget at once", async () => {
+		// Interval far longer than the operation: the only beat that can fire is
+		// the immediate one at call start. It must still reach the sink.
+		setBridgeHeartbeatIntervalMs(10_000);
+		const events: JsStatusEvent[] = [];
+
+		await withBridgeHeartbeat(
+			event => events.push(event),
+			async () => {
+				await Bun.sleep(30);
+				return "done";
+			},
+		);
+
+		expect(events.length).toBe(1);
+		expect(events[0]?.op).toBe(EVAL_HEARTBEAT_OP);
+	});
+
+	it("runs the operation without emitting when no status sink is wired", async () => {
+		setBridgeHeartbeatIntervalMs(5);
+		let ran = 0;
+
+		const value = await withBridgeHeartbeat(undefined, async () => {
+			ran++;
+			await Bun.sleep(40);
+			return 42;
+		});
+
+		expect(value).toBe(42);
+		expect(ran).toBe(1);
+	});
+
+	it("clears the heartbeat even when the operation throws", async () => {
+		setBridgeHeartbeatIntervalMs(15);
+		const events: JsStatusEvent[] = [];
+
+		await expect(
+			withBridgeHeartbeat(
+				event => events.push(event),
+				async () => {
+					await Bun.sleep(60);
+					throw new Error("boom");
+				},
+			),
+		).rejects.toThrow("boom");
+
+		const afterThrow = events.length;
+		await Bun.sleep(60);
+		expect(events.length).toBe(afterThrow);
+	});
+});

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

@@ -8,6 +8,8 @@ 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 { IdleTimeout } from "../idle-timeout";
 import { disposeAllVmContexts } from "../js/context-manager";
 import { executeJs } from "../js/executor";
 import { runEvalLlm } from "../llm-bridge";
@@ -97,6 +99,7 @@ function assistant(opts: {
 describe("runEvalLlm", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
+		setBridgeHeartbeatIntervalMs();
 	});
 
 	it("resolves each tier to its expected model", async () => {
@@ -213,6 +216,33 @@ describe("runEvalLlm", () => {
 			ToolError,
 		);
 	});
+
+	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);
+		vi.spyOn(ai, "completeSimple").mockImplementation(async () => {
+			await Bun.sleep(200);
+			return assistant({ text: "the answer" });
+		});
+
+		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();
+				},
+			},
+		);
+
+		expect(idle.signal.aborted).toBe(false);
+		expect(result.text).toBe("the answer");
+	});
 });
 
 describe("llm() through eval runtimes", () => {

package/src/eval/agent-bridge.ts

@@ -16,6 +16,7 @@ import { AgentOutputManager } from "../task/output-manager";
 import type { AgentDefinition, AgentProgress } from "../task/types";
 import type { ToolSession } from "../tools";
 import { ToolError } from "../tools/tool-errors";
+import { withBridgeHeartbeat } from "./heartbeat";
 import type { JsStatusEvent } from "./js/shared/types";
 // Import review tools for side effects (registers subagent tool handlers).
 import "../tools/review";
@@ -231,44 +232,49 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 	const id = await outputManager.allocate(outputIdBase(parsed.label, agentName));
 	const assignment = parsed.prompt.trim();
 	const context = trimToUndefined(parsed.context);
-	const result = await taskExecutor.runSubprocess({
-		cwd: options.session.cwd,
-		agent: effectiveAgent,
-		task: renderSubagentPrompt(assignment),
-		assignment,
-		context,
-		description: trimToUndefined(parsed.label),
-		index: 0,
-		id,
-		taskDepth: options.session.taskDepth ?? 0,
-		modelOverride,
-		parentActiveModelPattern,
-		thinkingLevel: effectiveAgent.thinkingLevel,
-		outputSchema: structured ? parsed.schema : undefined,
-		sessionFile,
-		persistArtifacts: Boolean(sessionFile),
-		artifactsDir,
-		contextFile,
-		enableLsp: (options.session.enableLsp ?? true) && options.session.settings.get("task.enableLsp"),
-		signal: options.signal,
-		eventBus: options.session.eventBus,
-		onProgress: progress => emitProgressStatus(options.emitStatus, progress),
-		authStorage: options.session.authStorage,
-		modelRegistry: options.session.modelRegistry,
-		settings: options.session.settings,
-		mcpManager,
-		contextFiles,
-		skills: availableSkills,
-		autoloadSkills: resolvedAutoloadSkills,
-		workspaceTree: options.session.workspaceTree,
-		promptTemplates: options.session.promptTemplates,
-		localProtocolOptions,
-		parentArtifactManager,
-		parentHindsightSessionState: options.session.getHindsightSessionState?.(),
-		parentMnemopiSessionState: options.session.getMnemopiSessionState?.(),
-		parentTelemetry: options.session.getTelemetry?.(),
-		parentEvalSessionId,
-	});
+	// Pump a heartbeat while the subagent runs so the eval idle watchdog stays
+	// armed across quiet stretches (time-to-first-token, long nested tools)
+	// where `onProgress` would otherwise emit no status to re-arm it.
+	const result = await withBridgeHeartbeat(options.emitStatus, () =>
+		taskExecutor.runSubprocess({
+			cwd: options.session.cwd,
+			agent: effectiveAgent,
+			task: renderSubagentPrompt(assignment),
+			assignment,
+			context,
+			description: trimToUndefined(parsed.label),
+			index: 0,
+			id,
+			taskDepth: options.session.taskDepth ?? 0,
+			modelOverride,
+			parentActiveModelPattern,
+			thinkingLevel: effectiveAgent.thinkingLevel,
+			outputSchema: structured ? parsed.schema : undefined,
+			sessionFile,
+			persistArtifacts: Boolean(sessionFile),
+			artifactsDir,
+			contextFile,
+			enableLsp: (options.session.enableLsp ?? true) && options.session.settings.get("task.enableLsp"),
+			signal: options.signal,
+			eventBus: options.session.eventBus,
+			onProgress: progress => emitProgressStatus(options.emitStatus, progress),
+			authStorage: options.session.authStorage,
+			modelRegistry: options.session.modelRegistry,
+			settings: options.session.settings,
+			mcpManager,
+			contextFiles,
+			skills: availableSkills,
+			autoloadSkills: resolvedAutoloadSkills,
+			workspaceTree: options.session.workspaceTree,
+			promptTemplates: options.session.promptTemplates,
+			localProtocolOptions,
+			parentArtifactManager,
+			parentHindsightSessionState: options.session.getHindsightSessionState?.(),
+			parentMnemopiSessionState: options.session.getMnemopiSessionState?.(),
+			parentTelemetry: options.session.getTelemetry?.(),
+			parentEvalSessionId,
+		}),
+	);
 
 	if (result.exitCode !== 0 || result.error) {
 		const failureMessage =