@code-yeongyu/senpi 2026.8.22 → 2026.8.23

package/dist/senpi

@@ -1,13 +1,56 @@
 #!/usr/bin/env node
 import "./valid-cwd.js";
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { processBunRuntimeOptions, resolveBunReexec } from "./bun-runtime.js";
 import { enableStartupCompileCache } from "./compile-cache.js";
 import { APP_NAME, DISPLAY_VERSION, getPackageDir } from "./config.js";
 import { hasInheritedInspectorOption, releaseInheritedInspectorForChild } from "./inspector-policy.js";
 import { handleBootstrapSelfUpdate } from "./self-update-bootstrap.js";
+/**
+ * Hand a Bun-installed CLI to Bun before anything else runs.
+ *
+ * `bun install -g` links this script into `~/.bun/bin`, but the shebang still starts it on Node,
+ * so a user who chose Bun silently gets the Node runtime. Re-exec through the Bun binary when the
+ * script really lives in Bun's global tree (or `SENPI_RUNTIME=bun` asks for it). This runs before
+ * `enableStartupCompileCache()` on purpose: a re-exec must not pay for Node's compile-cache setup.
+ * Node `execArgv` is deliberately dropped — those flags belong to the Node process, not to Bun.
+ */
+function reexecUnderBunIfNeeded() {
+    const options = processBunRuntimeOptions(existsSync, realpathSync);
+    let scriptRealPath = process.argv[1] ?? fileURLToPath(import.meta.url);
+    try {
+        // `~/.bun/bin/<name>` is a symlink into the global tree, so the link target is what has
+        // to be classified and re-executed. A path that cannot be resolved is simply used as-is;
+        // runtime selection must never be the reason startup fails.
+        scriptRealPath = realpathSync(scriptRealPath);
+    }
+    catch { }
+    const decision = resolveBunReexec({
+        scriptRealPath,
+        versions: process.versions,
+        hasInheritedInspectorOption: hasInheritedInspectorOption(),
+        options,
+    });
+    if (decision.action === "stay") {
+        return false;
+    }
+    const result = spawnSync(decision.bunPath, [scriptRealPath, ...process.argv.slice(2)], {
+        stdio: "inherit",
+        windowsHide: true,
+    });
+    if (result.signal) {
+        process.kill(process.pid, result.signal);
+        return true;
+    }
+    process.exitCode = result.status ?? 1;
+    return true;
+}
+if (reexecUnderBunIfNeeded()) {
+    process.exit();
+}
 // Must run before cli-main is loaded, by either path: it caches the engine graph this process
 // imports on the fast path below, and it publishes NODE_COMPILE_CACHE so a spawned cli-main child
 // inherits this process's cache directory instead of resolving and re-filling its own.

package/node_modules/@code-yeongyu/senpi-codemode/CHANGELOG.md

@@ -12,6 +12,38 @@
 
 ### Removed
 
+## [2026.8.23] - 2026-08-23
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Detached eval cell completion notices no longer enter the user-input steering queue. They were delivered via `sendUserMessage`, so hosts projecting that queue (e.g. the OmO desktop composer) rendered the raw `<system-reminder>Detached eval cell …</system-reminder>` notice under the STEERING heading as if the user had typed and queued it. Notices now deliver via `sendMessage` with `customType: "senpi-codemode:notification"` and `display: false` — model-visible, never painted as user input — matching the terminal and monitor notification contract.
+
+### Removed
+
+## [2026.8.22-2] - 2026-08-22
+
+### Breaking Changes
+
+### Added
+
+- Eval headers now display the kernel runtime identity, e.g. `eval py (3.14.7, ~/.venv/bin/python3)` and `eval js (node 26.7.0, /opt/…/bin/node)`; the same `runtime` info rides `EvalToolDetails` and its `cells` so RPC consumers receive it, interpreter detection resolves absolute executable paths from PATH, and the eval prompt host line names the JS runtime (`node`/`bun` with version).
+
+### Changed
+
+- Running eval cell headers now tick their elapsed time in real time (`eval py running · 13s`) instead of freezing between kernel update events; the renderer derives elapsed time from a render-time clock while a cell is pending/running/detached and repaints once per second, while settled cells keep their exact final duration. `EvalCellResult` gains an additive `startedAt` so RPC consumers can compute the same live value.
+
+### Fixed
+
+- A host tool call from inside an eval cell no longer suspends the cell's timeout indefinitely. The idle watchdog previously cleared its timer for the entire duration of a bridge call, so a call that never returned (e.g. an awaited `dag-wait`) left the cell pending — and the agent loop parked, queueing user messages invisibly — until the 1800s hard limit. The pause is now bounded by a max pause grace (default 600s, floored at the cell's own `timeout`): a long bridge call such as a 5-minute build still runs to completion, but a stuck one now trips the cell's `on_timeout` handling and releases the loop.
+
+### Removed
+
 ## [2026.8.22] - 2026-08-22
 
 ### Breaking Changes

package/node_modules/@code-yeongyu/senpi-codemode/README.md

@@ -30,6 +30,11 @@ task-tool names are known.
 - TUI and HTML-export rendering for syntax-highlighted cells, status rows,
   task progress, structured display values, truncation warnings, and image
   fallbacks.
+- Runtime identity badges in eval headers — `eval py (3.14.7, ~/.venv/bin/python3)`,
+  `eval js (node 26.7.0, /opt/…/bin/node)` — with the same `runtime` info on
+  `EvalToolDetails` and its `cells` for RPC consumers; interpreter detection
+  resolves absolute executable paths, and the eval prompt host line names the
+  JS runtime (`node`/`bun`).
 - JavaScript import rewriting for supported local modules and package imports
   in the persistent Node.js worker.
 - GPT models receive a terse `eval` prompt dialect that prioritizes composing

package/node_modules/@code-yeongyu/senpi-codemode/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.8.22",
+	"version": "2026.8.23",
 	"private": true,
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
@@ -31,14 +31,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.8.22",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.8.23",
 		"typebox": "1.3.16"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.8.22"
+		"@code-yeongyu/senpi": "2026.8.23"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.8.22"
+		"@code-yeongyu/senpi": "2026.8.23"
 	},
 	"keywords": [
 		"senpi",

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/eval-notifier.ts

@@ -3,10 +3,17 @@ import type { EvalDetachedCellNotification, EvalDetachedCellNotifier } from "../
 
 const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
 
+/** Provenance marker for agent-internal detached-cell notices. */
+export const EVAL_NOTIFICATION_CUSTOM_TYPE = "senpi-codemode:notification";
+
 export type EvalNotifyMode = "wake" | "next-turn" | "off";
 
 export interface EvalNotifierDeps {
-	readonly sendUserMessage: (content: string, options?: { deliverAs?: "steer" | "followUp" }) => void;
+	/** Deliver a model-visible notification without rendering synthetic user input. */
+	readonly sendMessage: (
+		message: { customType: string; content: string; display: boolean },
+		options: { triggerTurn: boolean; deliverAs: "steer" | "followUp" },
+	) => void;
 	readonly getContext: () => ExtensionContext | undefined;
 	readonly getMode: () => EvalNotifyMode;
 }
@@ -33,8 +40,13 @@ export class EvalNotifier implements EvalDetachedCellNotifier {
 		const pending = cells.filter((cell) => !this.#notified.has(cell.cellId));
 		if (pending.length === 0) return;
 		for (const cell of pending) this.#notified.add(cell.cellId);
-		this.#deps.sendUserMessage(pending.map((cell) => cell.content).join("\n\n"), {
-			deliverAs: mode === "wake" ? "steer" : "followUp",
-		});
+		this.#deps.sendMessage(
+			{
+				customType: EVAL_NOTIFICATION_CUSTOM_TYPE,
+				content: pending.map((cell) => cell.content).join("\n\n"),
+				display: false,
+			},
+			{ triggerTurn: true, deliverAs: mode === "wake" ? "steer" : "followUp" },
+		);
 	}
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/runtime-factory.ts

@@ -14,7 +14,8 @@ import {
 	type InterpreterAvailability,
 } from "../interpreters/detect.ts";
 import { resolveSessionArtifactsDir } from "../output/streaming-output.ts";
-import type { EnabledEvalLanguages, EvalLanguage } from "../tool/types.ts";
+import type { EnabledEvalLanguages, EvalLanguage, EvalRuntimes } from "../tool/types.ts";
+import { jsRuntimeInfo, runtimesFromAvailability } from "./runtime-info.ts";
 import {
 	type CodemodeSessionManager,
 	type CreateCodemodeSessionManagerOptions,
@@ -39,6 +40,7 @@ export type SessionRuntime = {
 	readonly parallelPoolWidth: number;
 	readonly manager: CodemodeSessionManager;
 	readonly enabledLanguages: EnabledEvalLanguages;
+	readonly runtimes: EvalRuntimes;
 	readonly settings: ResolvedCodemodeSettings;
 	readonly artifactsDir: string;
 	readonly executeTool: AgentExecuteTool;
@@ -82,6 +84,7 @@ export async function createRuntime(
 		parallelPoolWidth,
 		manager,
 		enabledLanguages,
+		runtimes: runtimesFromAvailability(availability, jsRuntimeInfo()),
 		settings,
 		artifactsDir: artifacts.dir,
 		executeTool,

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/runtime-info.ts

@@ -0,0 +1,41 @@
+import type { InterpreterAvailability } from "../interpreters/detect.ts";
+import type { EvalLanguage, EvalRuntimeInfo, EvalRuntimes } from "../tool/types.ts";
+
+export interface JsRuntimeVersions {
+	readonly node: string;
+	readonly bun?: string | undefined;
+}
+
+/** Identity of the in-process JS kernel host: bun when its marker exists, node otherwise. */
+export function jsRuntimeInfo(
+	versions: JsRuntimeVersions = process.versions,
+	execPath: string = process.execPath,
+): EvalRuntimeInfo {
+	const bun = versions.bun;
+	if (bun !== undefined && bun.length > 0) return { name: "bun", version: bun, path: execPath };
+	return { name: "node", version: versions.node, path: execPath };
+}
+
+/** Short host-line segment, e.g. "node 26.7.0" or "bun 1.4.0". */
+export function jsRuntimeLabel(versions: JsRuntimeVersions = process.versions): string {
+	const info = jsRuntimeInfo(versions, "");
+	return `${info.name} ${info.version}`;
+}
+
+const subprocessRuntimeNames = { py: "python", rb: "ruby", jl: "julia" } as const;
+const subprocessLanguages = ["py", "rb", "jl"] as const;
+
+/** Maps detected interpreters to display runtimes, preferring resolved absolute paths. */
+export function runtimesFromAvailability(availability: InterpreterAvailability, js: EvalRuntimeInfo): EvalRuntimes {
+	const runtimes: Partial<Record<EvalLanguage, EvalRuntimeInfo>> = { js };
+	for (const language of subprocessLanguages) {
+		const detected = availability[language].detected;
+		if (!detected.ok) continue;
+		runtimes[language] = {
+			name: subprocessRuntimeNames[language],
+			version: detected.version,
+			path: detected.resolvedPath ?? detected.path,
+		};
+	}
+	return runtimes;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/index.ts

@@ -13,6 +13,7 @@ import {
 	enabledLanguagesFrom,
 	type SessionRuntime,
 } from "./extension/runtime-factory.ts";
+import { jsRuntimeInfo, jsRuntimeLabel } from "./extension/runtime-info.ts";
 import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from "./extension/session-manager.ts";
 import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
 import { WAKE_SOURCE_STATE_EVENT, type WakeSourceState } from "./extension/wake-source-state.ts";
@@ -43,7 +44,10 @@ export interface CodemodeExtensionAPI {
 	executeTool: AgentExecuteTool;
 	getActiveTools(): string[];
 	getAllTools(): readonly EvalSchemaToolInfo[];
-	sendUserMessage(content: string, options?: { deliverAs?: "steer" | "followUp" }): void;
+	sendMessage(
+		message: { customType: string; content: string; display: boolean },
+		options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" | "nextTurn" },
+	): void;
 	/** Optional host event bus; a host without one turns extension event emission into a harmless no-op. */
 	events?: { emit(name: string, data: unknown): void };
 	/** Optional host RPC surface for forwarding extension-owned events to connected clients. */
@@ -68,7 +72,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 	let activeContext: ExtensionContext | undefined;
 	let activeCells: EvalDetachedCellManager | undefined;
 	const notifier = new EvalNotifier({
-		sendUserMessage: (content, notifyOptions) => pi.sendUserMessage(content, notifyOptions),
+		sendMessage: (message, notifyOptions) => pi.sendMessage(message, notifyOptions),
 		getContext: () => activeContext,
 		getMode: () => "wake",
 	});
@@ -119,6 +123,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 				spawns: runtime.spawns,
 				spawnDefaultAgent: runtime.settings.taskTools.task,
 				hostLine: hostLine(),
+				runtimes: runtime.runtimes,
 				...(modelId === undefined ? {} : { modelId }),
 			}),
 		);
@@ -152,6 +157,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			executionTracker: manager,
 			renderers,
 			hostLine: hostLine(),
+			runtimes: { js: jsRuntimeInfo() },
 		}),
 	);
 	pi.registerRemovedToolHint(
@@ -206,7 +212,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 
 function hostLine(): string {
 	const cpu = os.cpus()[0]?.model?.trim();
-	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`]
+	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`, jsRuntimeLabel()]
 		.filter((part): part is string => !!part)
 		.join(" \u00b7 ");
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/interpreters/detect.ts

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { platform as currentPlatform } from "node:os";
 import { promisify } from "node:util";
 import type { CodemodeSettings } from "../config/settings.ts";
+import { resolveCommandPath as defaultResolveCommandPath, type ResolveCommandPath } from "./resolve-command.ts";
 
 const execFileAsync = promisify(execFile);
 const probeTimeoutMs = 3_000;
@@ -10,8 +11,11 @@ export type CodemodeLanguage = "py" | "js" | "rb" | "jl";
 
 export interface InterpreterDetected {
 	readonly ok: true;
+	/** The probe command line that answered, e.g. "python3" or "py -3". */
 	readonly path: string;
 	readonly version: string;
+	/** Absolute executable path resolved from PATH, when resolution succeeded. */
+	readonly resolvedPath?: string;
 }
 
 export interface InterpreterUnavailable {
@@ -34,6 +38,7 @@ export interface CreateInterpreterDetectorOptions {
 	readonly platform?: NodeJS.Platform;
 	readonly execFile?: ExecFileProbe;
 	readonly nodeVersion?: string;
+	readonly resolveCommandPath?: ResolveCommandPath;
 }
 
 export interface InterpreterDetector {
@@ -55,6 +60,7 @@ export function createInterpreterDetector(options: CreateInterpreterDetectorOpti
 	const probe = options.execFile ?? defaultExecFileProbe;
 	const hostPlatform = options.platform ?? currentPlatform();
 	const nodeVersion = options.nodeVersion ?? process.versions.node;
+	const resolveCommand = options.resolveCommandPath ?? defaultResolveCommandPath;
 	const cache = new Map<CodemodeLanguage, Promise<InterpreterDetection>>();
 
 	return {
@@ -64,7 +70,7 @@ export function createInterpreterDetector(options: CreateInterpreterDetectorOpti
 				return cached;
 			}
 
-			const pending = detectUncached(language, hostPlatform, probe, nodeVersion);
+			const pending = detectUncached(language, hostPlatform, probe, nodeVersion, resolveCommand);
 			cache.set(language, pending);
 			return pending;
 		},
@@ -99,13 +105,14 @@ async function detectUncached(
 	hostPlatform: NodeJS.Platform,
 	probe: ExecFileProbe,
 	nodeVersion: string,
+	resolveCommand: ResolveCommandPath,
 ): Promise<InterpreterDetection> {
 	if (language === "js") {
 		return { ok: true, path: "node", version: nodeVersion };
 	}
 
 	for (const candidate of candidatesFor(language, hostPlatform)) {
-		const result = await probeCandidate(candidate, probe);
+		const result = await probeCandidate(candidate, probe, resolveCommand);
 		if (result.ok) {
 			return result;
 		}
@@ -114,12 +121,18 @@ async function detectUncached(
 	return unavailable;
 }
 
-async function probeCandidate(candidate: string, probe: ExecFileProbe): Promise<InterpreterDetection> {
+async function probeCandidate(
+	candidate: string,
+	probe: ExecFileProbe,
+	resolveCommand: ResolveCommandPath,
+): Promise<InterpreterDetection> {
 	const invocation = candidateInvocation(candidate);
 	try {
 		const result = await probe(invocation.command, [...invocation.args, "--version"], { timeoutMs: probeTimeoutMs });
 		const version = parseVersion(`${result.stdout}\n${result.stderr}`);
-		return version === null ? unavailable : { ok: true, path: candidate, version };
+		if (version === null) return unavailable;
+		const resolvedPath = resolveCommand(invocation.command);
+		return { ok: true, path: candidate, version, ...(resolvedPath === undefined ? {} : { resolvedPath }) };
 	} catch {
 		return unavailable;
 	}

package/node_modules/@code-yeongyu/senpi-codemode/src/interpreters/resolve-command.ts

@@ -0,0 +1,68 @@
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, isAbsolute, resolve as resolvePath } from "node:path";
+
+export interface ResolveCommandPathOptions {
+	readonly env?: NodeJS.ProcessEnv;
+	readonly platform?: NodeJS.Platform;
+	readonly cwd?: string;
+}
+
+export type ResolveCommandPath = (command: string, options?: ResolveCommandPathOptions) => string | undefined;
+
+const defaultWindowsPathExt = ".COM;.EXE;.BAT;.CMD";
+
+/**
+ * Resolves a bare command name to the absolute executable path a spawn would
+ * use, by scanning PATH without spawning a process. Returns undefined when the
+ * command cannot be resolved; callers treat that as "no display path known".
+ */
+export function resolveCommandPath(command: string, options: ResolveCommandPathOptions = {}): string | undefined {
+	if (command.length === 0) return undefined;
+	const env = options.env ?? process.env;
+	const platform = options.platform ?? process.platform;
+	const isWindows = platform === "win32";
+	if (command.includes("/") || (isWindows && command.includes("\\"))) {
+		const absolute = isAbsolute(command) ? command : resolvePath(options.cwd ?? process.cwd(), command);
+		return firstExecutable(candidatesFor(absolute, isWindows, env), isWindows);
+	}
+	const pathValue = env.PATH ?? env.Path ?? "";
+	if (pathValue.length === 0) return undefined;
+	for (const directory of pathValue.split(delimiter)) {
+		if (directory.length === 0) continue;
+		const base = `${directory}${directory.endsWith("/") || directory.endsWith("\\") ? "" : pathSeparatorFor(directory, isWindows)}${command}`;
+		const found = firstExecutable(candidatesFor(base, isWindows, env), isWindows);
+		if (found !== undefined) return found;
+	}
+	return undefined;
+}
+
+function pathSeparatorFor(directory: string, isWindows: boolean): string {
+	if (isWindows && directory.includes("\\") && !directory.includes("/")) return "\\";
+	return "/";
+}
+
+function candidatesFor(base: string, isWindows: boolean, env: NodeJS.ProcessEnv): readonly string[] {
+	if (!isWindows) return [base];
+	const extensions = (env.PATHEXT ?? defaultWindowsPathExt)
+		.split(";")
+		.map((extension) => extension.trim())
+		.filter((extension) => extension.startsWith("."));
+	const candidates = [base];
+	for (const extension of extensions) {
+		candidates.push(`${base}${extension.toLowerCase()}`, `${base}${extension}`);
+	}
+	return candidates;
+}
+
+function firstExecutable(candidates: readonly string[], isWindows: boolean): string | undefined {
+	for (const candidate of candidates) {
+		try {
+			if (!statSync(candidate).isFile()) continue;
+			if (!isWindows) accessSync(candidate, constants.X_OK);
+			return candidate;
+		} catch {
+			// Missing or non-executable candidate: keep scanning the remaining ones.
+		}
+	}
+	return undefined;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/timeouts/idle-timeout.ts

@@ -3,9 +3,18 @@ export interface IdleTimeoutEvent {
 	readonly error: Error;
 }
 
+/**
+ * Upper bound on how long a single host bridge call may suspend a cell's idle watchdog.
+ * Generous enough for a long build or a slow model call, short enough that a bridge call which
+ * never returns cannot park the cell — and with it the agent loop — until the 1800s hard limit.
+ */
+export const DEFAULT_MAX_PAUSE_GRACE_MS = 600_000;
+
 export interface IdleTimeoutOptions {
 	readonly cellId: string;
 	readonly timeoutMs: number;
+	/** Defaults to {@link DEFAULT_MAX_PAUSE_GRACE_MS}; floored at `timeoutMs` so a pause never shortens the budget. */
+	readonly maxPauseGraceMs?: number;
 	readonly onTimeout: (event: IdleTimeoutEvent) => void;
 }
 
@@ -20,7 +29,9 @@ export class IdleTimeout implements TimeoutPauseHandle {
 	readonly #controller = new AbortController();
 	readonly signal = this.#controller.signal;
 	readonly timeoutMs: number;
+	readonly maxPauseGraceMs: number;
 	#deadlineMs: number;
+	#pausedDeadlineMs: number | undefined;
 	#timer: ReturnType<typeof setTimeout> | undefined;
 	#pauseDepth = 0;
 	#settled = false;
@@ -28,22 +39,32 @@ export class IdleTimeout implements TimeoutPauseHandle {
 	constructor(options: IdleTimeoutOptions) {
 		this.#cellId = options.cellId;
 		this.timeoutMs = Math.max(1, Math.floor(options.timeoutMs));
+		this.maxPauseGraceMs = Math.max(
+			this.timeoutMs,
+			Math.floor(options.maxPauseGraceMs ?? DEFAULT_MAX_PAUSE_GRACE_MS),
+		);
 		this.#deadlineMs = Date.now() + this.timeoutMs;
 		this.#onTimeout = options.onTimeout;
 		this.#arm(this.timeoutMs);
 	}
 
+	/**
+	 * Suspends the idle deadline for the duration of a host bridge call, but only up to the pause grace:
+	 * the cell still expires if the call never returns. Nested pauses share the outermost pause's deadline.
+	 */
 	pause(): void {
 		if (this.#settled) return;
 		this.#pauseDepth++;
 		if (this.#pauseDepth !== 1) return;
-		this.#clearTimer();
+		this.#pausedDeadlineMs = Date.now() + this.maxPauseGraceMs;
+		this.#arm(this.maxPauseGraceMs);
 	}
 
 	resume(): void {
 		if (this.#settled || this.#pauseDepth === 0) return;
 		this.#pauseDepth--;
 		if (this.#pauseDepth > 0) return;
+		this.#pausedDeadlineMs = undefined;
 		this.#deadlineMs = Date.now() + this.timeoutMs;
 		this.#arm(this.timeoutMs);
 	}
@@ -51,6 +72,7 @@ export class IdleTimeout implements TimeoutPauseHandle {
 	dispose(): void {
 		if (this.#settled) return;
 		this.#settled = true;
+		this.#pausedDeadlineMs = undefined;
 		this.#clearTimer();
 	}
 
@@ -68,15 +90,22 @@ export class IdleTimeout implements TimeoutPauseHandle {
 	}
 
 	#expire(): void {
-		if (this.#settled || this.#pauseDepth > 0) return;
-		const remainingMs = this.#deadlineMs - Date.now();
+		if (this.#settled) return;
+		const pausedDeadlineMs = this.#pausedDeadlineMs;
+		if (this.#pauseDepth > 0 && pausedDeadlineMs === undefined) return;
+		const deadlineMs = pausedDeadlineMs ?? this.#deadlineMs;
+		const remainingMs = deadlineMs - Date.now();
 		if (remainingMs > 0) {
 			this.#arm(remainingMs);
 			return;
 		}
 		this.#settled = true;
+		this.#pausedDeadlineMs = undefined;
 		this.#timer = undefined;
-		const error = new Error(`Cell timed out after ${this.timeoutMs}ms`);
+		const error =
+			pausedDeadlineMs === undefined
+				? new Error(`Cell timed out after ${this.timeoutMs}ms`)
+				: new Error(`Cell timed out after ${this.maxPauseGraceMs}ms waiting on a host tool call`);
 		error.name = "TimeoutError";
 		this.#controller.abort(error);
 		this.#onTimeout({ cellId: this.#cellId, error });

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/cell-runtime.ts

@@ -2,7 +2,7 @@ import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import type { EvalToolCallMetric } from "./call-capture.ts";
 import { type EvalImageResizer, EvalOutputCollector, type EvalOutputResult } from "./image.ts";
-import type { EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
+import type { EvalRuntimeInfo, EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
 
 type KernelResult = Extract<KernelToHostMessage, { type: "result" }>;
 type DisplayMessage = Extract<KernelToHostMessage, { type: "display" }>;
@@ -10,6 +10,7 @@ type ToolCall = EvalToolDetails["toolCalls"] extends readonly (infer Item)[] ? I
 
 export interface CellState {
 	readonly input: EvalToolInput;
+	readonly runtime?: EvalRuntimeInfo;
 	readonly startedAt: number;
 	readonly signal: AbortSignal;
 	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
@@ -125,6 +126,7 @@ export class CellResultBuilder {
 		return {
 			language: this.#state.input.language,
 			languages: [this.#state.input.language],
+			...(this.#state.runtime === undefined ? {} : { runtime: this.#state.runtime }),
 			...(this.#state.input.summary === undefined ? {} : { summary: this.#state.input.summary }),
 			durationMs: this.#state.durationMs,
 			wallDurationMs: Math.max(0, Date.now() - this.#state.startedAt),
@@ -139,9 +141,11 @@ export class CellResultBuilder {
 					...(this.#state.input.summary === undefined ? {} : { summary: this.#state.input.summary }),
 					code: this.#state.input.code,
 					language: this.#state.input.language,
+					...(this.#state.runtime === undefined ? {} : { runtime: this.#state.runtime }),
 					output: this.#state.output,
 					status: this.#state.status,
 					durationMs: this.#state.durationMs,
+					startedAt: this.#state.startedAt,
 					...(statusEvents === undefined ? {} : { statusEvents }),
 					...(output?.hasMarkdown ? { hasMarkdown: true } : {}),
 				},

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-tool-options.ts

@@ -11,6 +11,7 @@ import type {
 	EnabledEvalLanguages,
 	EvalInputSchema,
 	EvalKernelManager,
+	EvalRuntimes,
 	EvalToolDetails,
 	EvalToolInput,
 	ExecuteTool,
@@ -38,6 +39,8 @@ export interface CreateEvalToolOptions {
 	readonly spawnDefaultAgent?: string;
 	readonly modelId?: string;
 	readonly hostLine?: string;
+	/** Display identity of each language's runtime, shown in headers and details. */
+	readonly runtimes?: EvalRuntimes;
 }
 
 export interface EvalCellInvocation {

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-tool.ts

@@ -98,8 +98,10 @@ async function runEvalCell(
 	const bridgeAbortController = new AbortController();
 	const cellSignal = AbortSignal.any([invocation.signal, bridgeAbortController.signal]);
 	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
+	const runtime = options.runtimes?.[invocation.input.language];
 	const state: CellState = {
 		input: invocation.input,
+		...(runtime === undefined ? {} : { runtime }),
 		startedAt: Date.now(),
 		signal: cellSignal,
 		onUpdate: invocation.onUpdate,