@oh-my-pi/pi-coding-agent 15.7.5 → 15.8.0

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";
@@ -104,6 +106,7 @@ function singleResult(options: ExecutorOptions, overrides: Partial<SingleResult>
 function makeEvalSession(
 	tempDir: TempDir,
 	prefix: string,
+	settings?: Settings,
 ): { session: ToolSession; sessionFile: string; sessionId: string } {
 	const sessionFile = path.join(tempDir.path(), "session.jsonl");
 	const artifactsDir = sessionFile.slice(0, -6);
@@ -111,6 +114,7 @@ function makeEvalSession(
 		cwd: tempDir.path(),
 		sessionFile,
 		artifactsDir,
+		settings,
 		outputManager: new AgentOutputManager(() => artifactsDir),
 	});
 	return { session, sessionFile, sessionId: `${prefix}:${crypto.randomUUID()}` };
@@ -232,6 +236,7 @@ describe("runEvalAgent", () => {
 describe("agent() through eval runtimes", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
+		setBridgeHeartbeatIntervalMs();
 	});
 
 	afterAll(async () => {
@@ -258,9 +263,15 @@ describe("agent() through eval runtimes", () => {
 		expect(JSON.parse(result.output.trim())).toEqual(["hello from agent", { ok: true, n: 3 }]);
 	});
 
-	it("runs JavaScript parallel() with bounded concurrency while preserving order", async () => {
+	it("bounds JavaScript parallel() by the task.maxConcurrency setting while preserving order", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-agent-js-parallel-");
-		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-parallel");
+		const settings = Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+			"task.maxConcurrency": 2,
+		});
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-parallel", settings);
 		mockAgents();
 		let inFlight = 0;
 		let maxInFlight = 0;
@@ -276,7 +287,7 @@ describe("agent() through eval runtimes", () => {
 		});
 
 		const result = await executeJs(
-			'const values = await parallel(["a", "b", "c", "d"].map(name => () => agent(name)), { concurrency: 2 }); return JSON.stringify(values);',
+			'const values = await parallel(["a", "b", "c", "d"].map(name => () => agent(name))); return JSON.stringify(values);',
 			{ cwd: tempDir.path(), sessionId, session, sessionFile },
 		);
 
@@ -297,7 +308,7 @@ describe("agent() through eval runtimes", () => {
 			return singleResult(options, { output: options.assignment ?? "" });
 		});
 
-		const result = await executeJs('await parallel([() => agent("ok"), () => agent("bad")], { concurrency: 2 });', {
+		const result = await executeJs('await parallel([() => agent("ok"), () => agent("bad")]);', {
 			cwd: tempDir.path(),
 			sessionId,
 			session,
@@ -340,6 +351,52 @@ describe("agent() through eval runtimes", () => {
 		expect(result.output.trim()).toBe("hello from python");
 	});
 
+	it("bounds Python parallel() by the task.maxConcurrency setting while preserving order", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-py-parallel-");
+		const settings = Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+			"task.maxConcurrency": 2,
+		});
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "py-agent-parallel", settings);
+		mockAgents();
+		let inFlight = 0;
+		let maxInFlight = 0;
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			inFlight++;
+			maxInFlight = Math.max(maxInFlight, inFlight);
+			try {
+				await Bun.sleep(options.assignment === "a" ? 30 : 10);
+				return singleResult(options, { output: options.assignment ?? "" });
+			} finally {
+				inFlight--;
+			}
+		});
+
+		const probe = await executePython('print("probe")', {
+			cwd: tempDir.path(),
+			sessionId: `${sessionId}:probe`,
+			sessionFile,
+			kernelMode: "per-call",
+		});
+		if (probe.exitCode === undefined && probe.cancelled) {
+			expect(probe.output).toBe("");
+			return;
+		}
+		expect(probe.exitCode).toBe(0);
+
+		const result = await executePython(
+			'import json\nprint(json.dumps(parallel([lambda n=n: agent(n) for n in ["a", "b", "c", "d"]])))',
+			{ cwd: tempDir.path(), sessionId, sessionFile, kernelMode: "per-call", toolSession: session },
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(JSON.parse(result.output.trim())).toEqual(["a", "b", "c", "d"]);
+		expect(maxInFlight).toBeGreaterThan(1);
+		expect(maxInFlight).toBeLessThanOrEqual(2);
+	});
+
 	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");
@@ -430,4 +487,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 =

package/src/eval/concurrency-bridge.ts

@@ -0,0 +1,34 @@
+/**
+ * Host-side handler for the eval `parallel()` / `pipeline()` worker pool.
+ *
+ * The pool ceiling is not a kernel-side knob: it tracks the `task.maxConcurrency`
+ * setting so an eval fan-out runs as wide as a `task` tool batch would. `0` means
+ * unbounded — run every item at once, exactly like `task.maxConcurrency = 0`.
+ */
+import type { ToolSession } from "../tools";
+import type { JsStatusEvent } from "./js/shared/types";
+
+/** Synthetic bridge name reserved for the parallel-pool ceiling across both runtimes. */
+export const EVAL_CONCURRENCY_BRIDGE_NAME = "__concurrency__";
+
+export interface EvalConcurrencyBridgeOptions {
+	session: ToolSession;
+	signal?: AbortSignal;
+	emitStatus?: (event: JsStatusEvent) => void;
+}
+
+export interface EvalConcurrencyResult {
+	/** Worker-pool ceiling; `0` means unbounded (run every item at once). */
+	limit: number;
+}
+
+/**
+ * Resolve the worker-pool ceiling for an eval cell's `parallel()`/`pipeline()`
+ * helpers from the live `task.maxConcurrency` setting. Negative/non-finite
+ * values collapse to `0` (unbounded), matching the `task` tool's own handling.
+ */
+export function runEvalConcurrency(_args: unknown, options: EvalConcurrencyBridgeOptions): EvalConcurrencyResult {
+	const raw = options.session.settings.get("task.maxConcurrency");
+	const limit = Number.isFinite(raw) ? Math.trunc(raw) : 0;
+	return { limit: limit > 0 ? limit : 0 };
+}

package/src/eval/heartbeat.ts

@@ -0,0 +1,74 @@
+/**
+ * Keepalive for in-flight host-side eval bridge calls.
+ *
+ * The eval watchdog ({@link ../tools/eval IdleTimeout}) caps a cell's `timeout`
+ * as a wall-clock budget on the cell's *own* work, but pauses that budget while
+ * a host-side `agent()`/`parallel()` (via `runSubprocess`) or `llm()` (a single
+ * completion) call is in flight. Those calls are the only thing that re-arms the
+ * watchdog — and they can run for long stretches with **no** status of their own
+ * (a subagent's time-to-first-token on a reasoning model, a long quiet nested
+ * tool, or the entire body of a oneshot `llm()` call). Without a keepalive the
+ * watchdog would mistake that delegated work for the cell stalling and abort it
+ * mid-flight, killing the subagent.
+ *
+ * {@link withBridgeHeartbeat} bridges that gap by emitting a synthetic
+ * {@link EVAL_HEARTBEAT_OP} status event immediately when the call begins and
+ * then on a fixed cadence until it settles. The event rides the same
+ * `emitStatus → onStatus` channel both runtimes already forward, so it re-arms
+ * the watchdog without any new plumbing. The heartbeat is the *sole* signal that
+ * extends the budget: consumers MUST treat it as a pure keepalive — bump the
+ * watchdog and drop it (never persist or render it) — see the executor display
+ * sinks and the eval tool's `onStatus` handler. Every other status event
+ * (compute helpers, `log()`/`phase()`, tool results) counts against the budget.
+ */
+import type { JsStatusEvent } from "./js/shared/types";
+
+/**
+ * Synthetic status op emitted purely to keep the eval idle watchdog alive while
+ * a host-side bridge call is in flight. Carries no payload.
+ */
+export const EVAL_HEARTBEAT_OP = "heartbeat";
+
+/**
+ * Heartbeat cadence. Comfortably below the default 30s idle budget (and the
+ * larger budgets long fanouts run under), so a working bridge call always bumps
+ * the watchdog before it expires, while a genuine stall is still bounded once
+ * the call settles and the heartbeat stops.
+ */
+const HEARTBEAT_INTERVAL_MS = 5_000;
+
+let heartbeatIntervalMs = HEARTBEAT_INTERVAL_MS;
+
+/**
+ * Test seam: override the heartbeat cadence so integration tests can exercise
+ * the keepalive within a sub-second idle budget. Pass no value to restore the
+ * production default.
+ */
+export function setBridgeHeartbeatIntervalMs(ms?: number): void {
+	heartbeatIntervalMs = ms === undefined ? HEARTBEAT_INTERVAL_MS : Math.max(1, Math.floor(ms));
+}
+
+/**
+ * Run {@link operation}, pumping {@link EVAL_HEARTBEAT_OP} status events through
+ * {@link emitStatus} — one immediately, then on a fixed cadence — until it
+ * settles. The immediate beat pauses the watchdog the instant the call begins,
+ * so a bridge call that starts close to the budget edge (after the cell already
+ * spent most of it computing) is not aborted before the first interval tick. A
+ * no-op wrapper when no `emitStatus` sink is wired (the heartbeat would reach
+ * nobody).
+ */
+export async function withBridgeHeartbeat<T>(
+	emitStatus: ((event: JsStatusEvent) => void) | undefined,
+	operation: () => Promise<T>,
+): Promise<T> {
+	if (!emitStatus) return operation();
+	emitStatus({ op: EVAL_HEARTBEAT_OP });
+	const timer = setInterval(() => emitStatus({ op: EVAL_HEARTBEAT_OP }), heartbeatIntervalMs);
+	// Never keep the event loop alive for the heartbeat alone.
+	timer.unref?.();
+	try {
+		return await operation();
+	} finally {
+		clearInterval(timer);
+	}
+}

package/src/eval/js/executor.ts

@@ -1,6 +1,7 @@
 import { DEFAULT_MAX_BYTES, OutputSink } from "../../session/streaming-output";
 import type { ToolSession } from "../../tools";
 import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../../tools/output-meta";
+import { EVAL_HEARTBEAT_OP } from "../heartbeat";
 import { executeInVmContext, type JsDisplayOutput } from "./context-manager";
 import type { JsStatusEvent } from "./shared/types";
 
@@ -59,11 +60,10 @@ function isTimeoutReason(reason: unknown): boolean {
 	);
 }
 
-function formatJsTimeoutAnnotation(timeoutMs: number | undefined, idle: boolean): string {
-	const suffix = idle ? " of inactivity" : "";
+function formatJsTimeoutAnnotation(timeoutMs: number | undefined): string {
 	if (timeoutMs === undefined) return "Command timed out";
 	const secs = Math.max(1, Math.round(timeoutMs / 1000));
-	return `Command timed out after ${secs} seconds${suffix}`;
+	return `Command timed out after ${secs} seconds`;
 }
 
 export async function executeJs(code: string, options: JsExecutorOptions): Promise<JsResult> {
@@ -85,10 +85,9 @@ export async function executeJs(code: string, options: JsExecutorOptions): Promi
 		options.signal && timeoutSignal
 			? AbortSignal.any([options.signal, timeoutSignal])
 			: (options.signal ?? timeoutSignal);
-	// Idle mode: the eval tool drives cancellation via an idle-aware `signal` and
-	// passes only an inactivity budget. Use it for worker cold-start headroom and
-	// timeout-annotation text; never derive a competing fixed timer from it.
-	const idleMode = legacyTimeoutMs === undefined && options.idleTimeoutMs !== undefined;
+	// The eval tool drives cancellation via an idle-aware `signal` and passes only
+	// an inactivity budget; use it solely as worker cold-start headroom and never
+	// derive a competing fixed timer from it.
 	const acquireBudgetMs = legacyTimeoutMs ?? options.idleTimeoutMs;
 
 	try {
@@ -105,8 +104,13 @@ export async function executeJs(code: string, options: JsExecutorOptions): Promi
 				signal,
 				onText: chunk => outputSink.push(chunk),
 				onDisplay: output => {
+					if (output.type === "status") {
+						// Heartbeats are pure idle-watchdog keepalives: forward them so
+						// the eval tool re-arms its timer, but never store or render them.
+						options.onStatus?.(output.event);
+						if (output.event.op === EVAL_HEARTBEAT_OP) return;
+					}
 					displayOutputs.push(output);
-					if (output.type === "status") options.onStatus?.(output.event);
 				},
 			},
 		});
@@ -127,7 +131,7 @@ export async function executeJs(code: string, options: JsExecutorOptions): Promi
 		if (signal?.aborted || isAbortError(error)) {
 			const timedOut = Boolean(timeoutSignal?.aborted) || isTimeoutReason(options.signal?.reason);
 			if (timedOut) {
-				outputSink.push(formatJsTimeoutAnnotation(legacyTimeoutMs ?? options.idleTimeoutMs, idleMode));
+				outputSink.push(formatJsTimeoutAnnotation(legacyTimeoutMs ?? options.idleTimeoutMs));
 			}
 			const summary = await outputSink.dump();
 			return {

package/src/eval/js/shared/prelude.txt

@@ -55,15 +55,24 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;
 	};
 
-	const normalizeConcurrency = value => {
-		const number = Number(value ?? 4);
-		if (!Number.isFinite(number)) return 4;
-		return Math.max(1, Math.min(16, Math.trunc(number)));
+	// Pool ceiling mirrors the task tool's `task.maxConcurrency` setting so an
+	// eval fan-out runs as wide as a `task` batch would. 0 (and any non-finite
+	// reply) means unbounded — run every item at once.
+	const __concurrencyLimit = async () => {
+		try {
+			const r = await globalThis.__omp_call_tool__("__concurrency__", {});
+			const n = Math.trunc(Number(r && typeof r === "object" ? r.limit : r));
+			return Number.isFinite(n) && n > 0 ? n : 0;
+		} catch {
+			return 0;
+		}
 	};
 
-	const __pool = async (items, limit, fn) => {
+	const __pool = async (items, fn) => {
 		const list = Array.from(items ?? []);
-		const concurrency = Math.min(normalizeConcurrency(limit), list.length);
+		if (list.length === 0) return [];
+		const limit = await __concurrencyLimit();
+		const concurrency = limit > 0 ? Math.min(limit, list.length) : list.length;
 		const results = new Array(list.length);
 		let next = 0;
 		const worker = async () => {
@@ -77,23 +86,17 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 		return results;
 	};
 
-	const parallel = async (thunks, opts = {}) =>
-		__pool(thunks, toOptions(opts).concurrency, (thunk, index) => {
+	const parallel = async thunks =>
+		__pool(thunks, (thunk, index) => {
 			if (typeof thunk !== "function") throw new TypeError("parallel() expects an iterable of functions");
 			return thunk(index);
 		});
 
-	const pipeline = async (items, ...stagesAndOptions) => {
-		let opts = {};
-		const last = stagesAndOptions.at(-1);
-		if (last && typeof last === "object" && !Array.isArray(last)) {
-			opts = last;
-			stagesAndOptions = stagesAndOptions.slice(0, -1);
-		}
+	const pipeline = async (items, ...stages) => {
 		let current = Array.from(items ?? []);
-		for (const stage of stagesAndOptions) {
+		for (const stage of stages) {
 			if (typeof stage !== "function") throw new TypeError("pipeline() stages must be functions");
-			current = await __pool(current, toOptions(opts).concurrency, stage);
+			current = await __pool(current, stage);
 		}
 		return current;
 	};