@code-yeongyu/senpi 2026.8.21 → 2026.8.22-2

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,64 @@
 
 ### 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
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Ruby and Julia eval cells now wait for the subprocess `ready` signal before execution timeouts begin, so interpreter startup under load cannot time out a state-setting cell and silently restart the kernel before the next cell runs.
+
+### Removed
+
+## [2026.8.21-3] - 2026-08-21
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.8.21-2] - 2026-08-21
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- `js` eval cells now accept `local://` paths in `read()` and `write()` like every other kernel. The session manager computed the session local root only after its `language === "js"` early return, so the JavaScript kernel was constructed without `localRoots` or `artifactsDir` and every `local://` helper call failed with `Protocol paths are not supported by write()`, even though the JavaScript prelude documents `local://` as the session local root. `py`/`rb`/`jl` behavior is unchanged.
+
+### Removed
+
 ## [2026.8.21] - 2026-08-21
 
 ### 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.21",
+	"version": "2026.8.22-2",
 	"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.21",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.8.22-2",
 		"typebox": "1.3.16"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.8.21"
+		"@code-yeongyu/senpi": "2026.8.22-2"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.8.21"
+		"@code-yeongyu/senpi": "2026.8.22-2"
 	},
 	"keywords": [
 		"senpi",

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/extension/session-manager.ts

@@ -196,19 +196,24 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		if (!bridge) throw new Error("codemode bridge server is not running");
 		const configuredPoolWidth = this.#options.settings.parallelPoolWidth;
 		const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
+		// localRoots must be computed BEFORE the js branch: the JS kernel resolves local://
+		// from its worker init connection exactly like the subprocess kernels resolve it from
+		// theirs. Computing it after the early return left js cells with no local root at all.
+		const localRoots =
+			this.#options.localRoots ??
+			(this.#options.artifactsDir ? { local: join(this.#options.artifactsDir, "local") } : undefined);
 		if (language === "js") {
 			return new JavaScriptKernel({
 				sessionId: this.#options.sessionId,
 				cwd: this.#options.cwd,
 				parallelPoolWidth,
 				onMessage,
+				...(localRoots ? { localRoots: { ...localRoots } } : {}),
+				...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
 			});
 		}
 		const detected = this.#options.availability[language].detected;
 		if (!detected.ok) throw new Error(`No ${language} interpreter is available`);
-		const localRoots =
-			this.#options.localRoots ??
-			(this.#options.artifactsDir ? { local: join(this.#options.artifactsDir, "local") } : undefined);
 		const connection = {
 			port: bridge.port,
 			token: bridge.token,

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";
@@ -119,6 +120,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 +154,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			executionTracker: manager,
 			renderers,
 			hostLine: hostLine(),
+			runtimes: { js: jsRuntimeInfo() },
 		}),
 	);
 	pi.registerRemovedToolHint(
@@ -206,7 +209,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/kernels/shared/subprocess-kernel.ts

@@ -26,6 +26,7 @@ export class SubprocessKernel {
 	private readonly onMessage?: (message: KernelToHostMessage) => void;
 	private readonly runs = new SubprocessRunQueue();
 	private process: SubprocessProcess | null = null;
+	private processReady = false;
 	private retirementPromise: Promise<void> | null = null;
 	private retirementProcess: SubprocessProcess | null = null;
 	private retirementFailure: Error | null = null;
@@ -109,7 +110,7 @@ export class SubprocessKernel {
 
 	private pumpRuns(): void {
 		const process = this.process;
-		if (this.closed || this.runs.active || !process || process.isRetiring) return;
+		if (this.closed || this.runs.active || !process || process.isRetiring || !this.processReady) return;
 		const run = this.runs.startNext(performance.now());
 		if (!run) return;
 		const timeoutMs = run.input.timeoutMs;
@@ -142,6 +143,7 @@ export class SubprocessKernel {
 			},
 		});
 		this.process = process;
+		this.processReady = false;
 		try {
 			process.send(
 				encodeBridgeFrame({ type: "init", sessionId: this.options.sessionId, connection: this.options.connection }),
@@ -165,6 +167,17 @@ export class SubprocessKernel {
 
 	private handleMessage(process: SubprocessProcess, message: KernelToHostMessage): void {
 		if (!this.accepts(process)) return;
+		if (message.type === "ready") {
+			this.processReady = true;
+			this.runs.handleMessage(message, this.onMessage);
+			this.pumpRuns();
+			return;
+		}
+		if (message.type === "init-failed") {
+			this.runs.handleMessage(message, this.onMessage);
+			this.failClosed(new KernelStartupError(message.error.message));
+			return;
+		}
 		if (this.runs.handleMessage(message, this.onMessage)) this.pumpRuns();
 	}
 
@@ -176,6 +189,7 @@ export class SubprocessKernel {
 			return;
 		}
 		this.process = null;
+		this.processReady = false;
 		this.failClosed(new KernelExitedError(signal ?? code ?? "unknown"));
 	}
 

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,