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

package/src/tools/eval.ts

@@ -4,7 +4,7 @@ import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import { jsBackend, pythonBackend } from "../eval";
 import type { ExecutorBackend, ExecutorBackendResult } from "../eval/backend";
-import { EVAL_HEARTBEAT_OP } from "../eval/heartbeat";
+import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP } from "../eval/bridge-timeout";
 import { IdleTimeout } from "../eval/idle-timeout";
 import { defaultEvalSessionId } from "../eval/session-id";
 import type { EvalCellResult, EvalDisplayOutput, EvalLanguage, EvalStatusEvent, EvalToolDetails } from "../eval/types";
@@ -313,16 +313,13 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 				for (let i = 0; i < cells.length; i++) {
 					const cell = cells[i];
 					const backend = cell.resolved.backend;
-					// The per-cell `timeout` is a wall-clock budget on the cell's *own*
-					// work, but it is paused while a host-side `agent()`/`llm()` bridge
-					// call is in flight: those calls pump a heartbeat (see
-					// `withBridgeHeartbeat`) that re-arms the watchdog, so a long fanout
-					// or a slow completion runs to completion. Nothing else re-arms it —
-					// compute, stdout, `log()`/`phase()`, and ordinary tool calls all
-					// count against the budget — so a cell that is not delegating to an
-					// agent/llm is bounded by a plain wall-clock timeout. The watchdog
-					// drives `combinedSignal`; we pass no wall-clock deadline downstream
-					// so the backends never arm a competing fixed timer.
+					// The per-cell `timeout` is a budget on the cell runtime's *own*
+					// work. Host-side `agent()`/`parallel()`/`llm()` bridge calls suspend
+					// that budget entirely and restart a fresh timeout window when control
+					// returns to Python/JS. Compute, stdout, `log()`/`phase()`, and
+					// ordinary tool calls all count against the budget. The watchdog drives
+					// `combinedSignal`; we pass no wall-clock deadline downstream so the
+					// backends never arm a competing fixed timer.
 					const idleTimeoutMs = timeoutSecondsFromMs(cell.timeoutMs) * 1000;
 					const idle = new IdleTimeout(idleTimeoutMs);
 					const combinedSignal = signal
@@ -355,14 +352,12 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 								outputSink!.push(chunk);
 							},
 							onStatus: event => {
-								// Only a bridge heartbeat re-arms the watchdog: it is the
-								// keepalive `agent()`/`llm()` pump while a host-side call is
-								// in flight, so those calls effectively pause the budget. It
-								// carries no payload — bump and drop it. Every other event
-								// (compute helpers, log()/phase(), tool results) renders but
-								// counts against the plain wall-clock budget.
-								if (event.op === EVAL_HEARTBEAT_OP) {
-									idle.bump();
+								if (event.op === EVAL_TIMEOUT_PAUSE_OP) {
+									idle.pause();
+									return;
+								}
+								if (event.op === EVAL_TIMEOUT_RESUME_OP) {
+									idle.resume();
 									return;
 								}
 								cellResult.statusEvents ??= [];

package/src/tools/fetch.ts

@@ -14,7 +14,7 @@ import type { ToolSession } from "../sdk";
 import type { AgentStorage } from "../session/agent-storage";
 import { DEFAULT_MAX_BYTES, truncateHead } from "../session/streaming-output";
 import { renderStatusLine, urlHyperlink } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { ensureTool } from "../utils/tools-manager";
 import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
@@ -1488,11 +1488,11 @@ export function renderReadUrlResult(
 		const header = renderStatusLine({ icon: "error", title: "Read", description }, uiTheme);
 		const errorLines = errorText.split("\n").map(line => uiTheme.fg("error", replaceTabs(line)));
 		const outputBlock = new CachedOutputBlock();
-		return {
+		return markFramedBlockComponent({
 			render: (width: number) =>
 				outputBlock.render({ header, state: "error", sections: [{ lines: errorLines }], width }, uiTheme),
 			invalidate: () => outputBlock.invalidate(),
-		};
+		});
 	}
 
 	const description = formatReadUrlDescription(details.finalUrl);
@@ -1542,7 +1542,7 @@ export function renderReadUrlResult(
 	let lastExpanded: boolean | undefined;
 	let contentPreviewLines: string[] | undefined;
 
-	return {
+	return markFramedBlockComponent({
 		render: (width: number) => {
 			const { expanded } = options;
 
@@ -1582,5 +1582,5 @@ export function renderReadUrlResult(
 			contentPreviewLines = undefined;
 			lastExpanded = undefined;
 		},
-	};
+	});
 }

package/src/tools/read.ts

@@ -29,7 +29,7 @@ import {
 	truncateLine,
 } from "../session/streaming-output";
 import { fileHyperlink, renderCodeCell, renderMarkdownCell, renderStatusLine, tryResolveInternalUrlSync } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { ImageInputTooLargeError, loadImageInput, MAX_IMAGE_INPUT_BYTES } from "../utils/image-loading";
 import { convertFileWithMarkit } from "../utils/markit";
@@ -2413,11 +2413,11 @@ export const readToolRenderer = {
 			const header = renderStatusLine({ icon: "error", title }, uiTheme);
 			const errorLines = errorText.split("\n").map(line => uiTheme.fg("error", replaceTabs(line)));
 			const outputBlock = new CachedOutputBlock();
-			return {
+			return markFramedBlockComponent({
 				render: (width: number) =>
 					outputBlock.render({ header, state: "error", sections: [{ lines: errorLines }], width }, uiTheme),
 				invalidate: () => outputBlock.invalidate(),
-			};
+			});
 		}
 		const details = result.details;
 		const rawText = result.content?.find(c => c.type === "text")?.text ?? "";
@@ -2465,7 +2465,7 @@ export const readToolRenderer = {
 			const detailLines = contentText ? contentText.split("\n").map(line => uiTheme.fg("toolOutput", line)) : [];
 			const lines = [...detailLines, ...warningLines];
 			const outputBlock = new CachedOutputBlock();
-			return {
+			return markFramedBlockComponent({
 				render: (width: number) =>
 					outputBlock.render(
 						{
@@ -2482,7 +2482,7 @@ export const readToolRenderer = {
 						uiTheme,
 					),
 				invalidate: () => outputBlock.invalidate(),
-			};
+			});
 		}
 
 		const suffix = details?.suffixResolution;
@@ -2514,7 +2514,7 @@ export const readToolRenderer = {
 		let cachedWidth: number | undefined;
 		let cachedExpanded: boolean | undefined;
 		let cachedLines: string[] | undefined;
-		return {
+		return markFramedBlockComponent({
 			render: (width: number) => {
 				const expanded = options.expanded;
 				if (cachedLines && cachedWidth === width && cachedExpanded === expanded) return cachedLines;
@@ -2551,7 +2551,7 @@ export const readToolRenderer = {
 				cachedExpanded = undefined;
 				cachedLines = undefined;
 			},
-		};
+		});
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/render-utils.ts

@@ -171,6 +171,52 @@ export function formatMoreItems(remaining: number, itemType: string): string {
 	return `… ${safeRemaining} more ${pluralize(itemType, safeRemaining)}`;
 }
 
+/**
+ * Maximum rows a tool's streaming/pending *call* preview may render before it is
+ * capped. This is intentionally conservative: the preview still sits inside a
+ * transcript that already consumed some viewport rows, and tool blocks carry
+ * extra chrome (status/header/border/"more lines"), so a "reasonable" raw code
+ * or command preview like 10-12 lines can still overflow and strand its top
+ * while the block is volatile. Keeping the live call window short avoids that
+ * across terminals without turning the transcript into an interactive scroller.
+ */
+export const CALL_PREVIEW_MAX_LINES = 6;
+
+/**
+ * Cap a pre-rendered pending/call preview to a bounded window. When truncated,
+ * show both the head and the live tail so the user can still see what the tool
+ * is currently writing while the volatile block stays short enough not to strand
+ * its top above the viewport. `Ctrl+O` widens the bounded window, but does not
+ * fully uncap live tool previews for the same reason.
+ *
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the summary line so
+ * nested previews stay aligned.
+ */
+export function capPreviewLines(
+	lines: string[],
+	theme: Theme,
+	options: { max?: number; expanded?: boolean; prefix?: string } = {},
+): string[] {
+	const max = options.max ?? (options.expanded ? PREVIEW_LIMITS.EXPANDED_LINES : CALL_PREVIEW_MAX_LINES);
+	if (lines.length <= max) return lines;
+	if (max <= 1) {
+		const hint = formatExpandHint(theme, options.expanded, true);
+		const moreLine = `${formatMoreItems(lines.length, "line")}${hint ? ` ${hint}` : ""}`;
+		return [`${options.prefix ?? ""}${theme.fg("dim", moreLine)}`];
+	}
+	const bodyBudget = max - 1; // reserve one summary row
+	const headCount = Math.max(1, Math.ceil(bodyBudget / 2));
+	const tailCount = Math.max(1, bodyBudget - headCount);
+	const hidden = Math.max(0, lines.length - headCount - tailCount);
+	const hint = formatExpandHint(theme, options.expanded, true);
+	const moreLine = `${formatMoreItems(hidden, "line")}${hint ? ` ${hint}` : ""}`;
+	return [
+		...lines.slice(0, headCount),
+		`${options.prefix ?? ""}${theme.fg("dim", moreLine)}`,
+		...lines.slice(lines.length - tailCount),
+	];
+}
+
 export function formatMeta(meta: string[], theme: Theme): string {
 	return meta.length > 0 ? ` ${theme.fg("muted", meta.join(theme.sep.dot))}` : "";
 }

package/src/tools/ssh.ts

@@ -13,11 +13,11 @@ import type { SSHHostInfo } from "../ssh/connection-manager";
 import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
 import { renderStatusLine } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
 import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
-import { replaceTabs } from "./render-utils";
+import { capPreviewLines, replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
@@ -244,16 +244,22 @@ export const sshToolRenderer = {
 		const header = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}]` }, uiTheme);
 		const cmdLines = formatSshCommandLines(command, uiTheme);
 		const outputBlock = new CachedOutputBlock();
-		return {
+		return markFramedBlockComponent({
 			render: (width: number): string[] =>
 				outputBlock.render(
-					{ header, state: "pending", sections: [{ lines: cmdLines }], width, animate: true },
+					{
+						header,
+						state: "pending",
+						sections: [{ lines: capPreviewLines(cmdLines, uiTheme, { expanded: _options.expanded }) }],
+						width,
+						animate: true,
+					},
 					uiTheme,
 				),
 			invalidate: () => {
 				outputBlock.invalidate();
 			},
-		};
+		});
 	},
 
 	renderResult(
@@ -273,7 +279,7 @@ export const sshToolRenderer = {
 		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
 		const outputBlock = new CachedOutputBlock();
 
-		return {
+		return markFramedBlockComponent({
 			render: (width: number): string[] => {
 				// REACTIVE: read mutable options at render time
 				const { expanded, renderContext } = options;
@@ -319,7 +325,14 @@ export const sshToolRenderer = {
 					{
 						header,
 						state: "success",
-						sections: [{ lines: cmdLines }, { label: uiTheme.fg("toolTitle", "Output"), lines: outputLines }],
+						sections: [
+							{
+								lines: options.isPartial
+									? capPreviewLines(cmdLines, uiTheme, { expanded: options.expanded })
+									: cmdLines,
+							},
+							{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
+						],
 						width,
 					},
 					uiTheme,
@@ -328,7 +341,7 @@ export const sshToolRenderer = {
 			invalidate: () => {
 				outputBlock.invalidate();
 			},
-		};
+		});
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/write.ts

@@ -58,7 +58,7 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const LOOSE_HASHLINE_HEADER_RE = /^\s*¶\S+#[^ \t\r\n]*\s*$/;
+const LOOSE_HASHLINE_HEADER_RE = /^\s*\[[^#\r\n]+#[^ \t\r\n]*\]\s*$/;
 
 let fflateModulePromise: Promise<typeof import("fflate")> | undefined;
 async function loadFflate(): Promise<typeof import("fflate")> {
@@ -109,7 +109,7 @@ function stripWriteContentWithPotentialLooseHeader(lines: string[]): { text: str
 /**
  * Strip hashline display prefixes from write content.
  *
- * Only active when hashline edit mode is enabled — the model sees `¶PATH#HASH`
+ * Only active when hashline edit mode is enabled — the model sees `[PATH#HASH]`
  * headers plus `LINE:` prefixes in read output and sometimes copies them into write content.
  */
 function stripWriteContent(session: ToolSession, content: string): { text: string; stripped: boolean } {
@@ -122,7 +122,7 @@ function stripWriteContent(session: ToolSession, content: string): { text: strin
 /**
  * Record a snapshot of the freshly-written `content` for `absolutePath`
  * so subsequent hashline edits address the new file with a current tag,
- * and return the matching `¶displayPath#TAG` header. Returns `undefined`
+ * and return the matching `[displayPath#TAG]` header. Returns `undefined`
  * when the session is not in hashline mode so callers can no-op cheaply.
  *
  * Mirrors the post-commit snapshot recording the hashline patcher performs
@@ -770,7 +770,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<WriteToolDetails>> {
 		return untilAborted(signal, async () => {
-			// Strip hashline display prefixes (¶PATH#HASH + LINE:) if the model copied them from read output
+			// Strip hashline display prefixes ([PATH#HASH] + LINE:) if the model copied them from read output
 			const { text: cleanContent, stripped } = stripWriteContent(this.session, content);
 			const internalRouter = InternalUrlRouter.instance();
 			if (internalRouter.canHandle(path)) {
@@ -935,11 +935,20 @@ function normalizeDisplayText(text: string): string {
 	return text.replace(/\r/g, "");
 }
 
-function formatStreamingContent(content: string, language: string | undefined, uiTheme: Theme): string {
+function formatStreamingContent(
+	content: string,
+	expanded: boolean,
+	language: string | undefined,
+	uiTheme: Theme,
+): string {
 	if (!content) return "";
 	const lines = normalizeDisplayText(content).split("\n");
 	const totalLines = lines.length;
-	const startIndex = Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
+	// Collapsed: follow the streaming edge with a bounded tail window so the box
+	// stays short enough not to strand its scrolled-off head above the viewport
+	// while the block is volatile. `Ctrl+O` (expanded) lifts the cap for a
+	// deliberate full view — matching the eval streaming preview.
+	const startIndex = expanded ? 0 : Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
 	const visibleLines = lines.slice(startIndex);
 	const hidden = startIndex;
 	const highlighted = highlightCode(visibleLines.join("\n"), language);
@@ -1005,8 +1014,8 @@ export const writeToolRenderer = {
 			return new Text(text, 0, 0);
 		}
 
-		// Show streaming preview of content (tail)
-		text += formatStreamingContent(args.content, lang, uiTheme);
+		// Show streaming preview of content — bounded tail while collapsed, full on Ctrl+O.
+		text += formatStreamingContent(args.content, Boolean(options?.expanded), lang, uiTheme);
 
 		return new Text(text, 0, 0);
 	},

package/src/tui/code-cell.ts

@@ -25,6 +25,12 @@ export interface CodeCellOptions {
 	output?: string;
 	outputMaxLines?: number;
 	codeMaxLines?: number;
+	/**
+	 * Show the LAST `codeMaxLines` rows (the live streaming edge) instead of the
+	 * first, with a "… N earlier lines" marker on top. Lets a pending preview
+	 * follow code as it is written while staying bounded. Ignored when `expanded`.
+	 */
+	codeTail?: boolean;
 	expanded?: boolean;
 	/** Animate the cell border with a sweeping segment while pending/running. */
 	animate?: boolean;
@@ -102,13 +108,22 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 	const normalizedCode = replaceTabs(code ?? "");
 	const rawCodeLines = sanitizeTerminalLines(normalizedCode);
 	const maxCodeLines = expanded ? rawCodeLines.length : Math.min(rawCodeLines.length, codeMaxLines);
-	const visibleCode = rawCodeLines.slice(0, maxCodeLines).join("\n");
-	const codeLines = highlightCode(visibleCode, language);
 	const hiddenCodeLines = rawCodeLines.length - maxCodeLines;
+	const tail = options.codeTail === true && !expanded && hiddenCodeLines > 0;
+	const startIndex = tail ? rawCodeLines.length - maxCodeLines : 0;
+	const visibleCode = rawCodeLines.slice(startIndex, startIndex + maxCodeLines).join("\n");
+	const codeLines = highlightCode(visibleCode, language);
 	if (hiddenCodeLines > 0) {
 		const hint = formatExpandHint(theme, expanded, hiddenCodeLines > 0);
-		const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
-		codeLines.push(theme.fg("dim", moreLine));
+		if (tail) {
+			// Earlier rows scrolled above the live tail window — mark them on top so
+			// the newest streamed line stays pinned to the bottom of the box.
+			const earlier = `… ${hiddenCodeLines} earlier line${hiddenCodeLines === 1 ? "" : "s"}${hint ? ` ${hint}` : ""}`;
+			codeLines.unshift(theme.fg("dim", earlier));
+		} else {
+			const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
+			codeLines.push(theme.fg("dim", moreLine));
+		}
 	}
 
 	const outputLines: string[] = [];

package/src/tui/output-block.ts

@@ -1,6 +1,7 @@
 /**
  * Bordered output container with optional header and sections.
  */
+import type { Component } from "@oh-my-pi/pi-tui";
 import { ImageProtocol, padding, TERMINAL, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
 import { getSixelLineMask } from "../utils/sixel";
@@ -19,6 +20,19 @@ export interface OutputBlockOptions {
 	animate?: boolean;
 }
 
+const FRAMED_BLOCK_COMPONENT = Symbol("framedBlockComponent");
+
+export type FramedBlockComponent = Component & { [FRAMED_BLOCK_COMPONENT]?: true };
+
+export function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent {
+	(component as T & FramedBlockComponent)[FRAMED_BLOCK_COMPONENT] = true;
+	return component as T & FramedBlockComponent;
+}
+
+export function isFramedBlockComponent(component: Component): boolean {
+	return (component as FramedBlockComponent)[FRAMED_BLOCK_COMPONENT] === true;
+}
+
 const BORDER_SHIMMER_TICK_MS = 16;
 /** Duration of one full left↔right↔left bounce of the bottom-edge segment, in
  * ms. Position is derived from the wall clock against this fixed cycle so a

package/src/web/search/render.ts

@@ -21,7 +21,7 @@ import {
 	truncateToWidth,
 } from "../../tools/render-utils";
 import { renderStatusLine, renderTreeList } from "../../tui";
-import { CachedOutputBlock } from "../../tui/output-block";
+import { CachedOutputBlock, markFramedBlockComponent } from "../../tui/output-block";
 import { getSearchProviderLabel } from "./provider";
 import type { SearchResponse } from "./types";
 
@@ -152,7 +152,7 @@ export function renderSearchResult(
 	const answerMarkdown = contentText ? new Markdown(contentText, 0, 0, getMarkdownTheme()) : undefined;
 	const outputBlock = new CachedOutputBlock();
 
-	return {
+	return markFramedBlockComponent({
 		render(width: number): string[] {
 			// Read mutable state at render time
 			const { expanded } = options;
@@ -246,7 +246,7 @@ export function renderSearchResult(
 		invalidate() {
 			outputBlock.invalidate();
 		},
-	};
+	});
 }
 
 /** Render web search call (query preview) */

package/dist/types/eval/heartbeat.d.ts

@@ -1,45 +0,0 @@
-/**
- * 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 declare const EVAL_HEARTBEAT_OP = "heartbeat";
-/**
- * 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 declare function setBridgeHeartbeatIntervalMs(ms?: number): void;
-/**
- * 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 declare function withBridgeHeartbeat<T>(emitStatus: ((event: JsStatusEvent) => void) | undefined, operation: () => Promise<T>): Promise<T>;

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

@@ -1,84 +0,0 @@
-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/heartbeat.ts

@@ -1,74 +0,0 @@
-/**
- * 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);
-	}
-}