@code-yeongyu/senpi-codemode 2026.8.22 → 2026.8.24

package/CHANGELOG.md

@@ -12,6 +12,52 @@
 
 ### Removed
 
+## [2026.8.24] - 2026-08-24
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Detached eval cell overflow notices now point at the absolute spill file path (`…/local/detached-eval-<id>.log`) instead of a `local://detached-eval-<id>.log` URI. `local://` is resolved only by the in-cell kernel helpers, not by the agent `read` tool, so following the old notice failed with `ENOENT …/local:/detached-eval-<id>.log`. This restores the documented contract that spill notices carry plain absolute paths.
+
+### 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/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.8.22",
+	"version": "2026.8.24",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.8.22",
-		"typebox": "1.3.16"
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.8.24",
+		"typebox": "1.3.18"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.8.22"
+		"@code-yeongyu/senpi": "2026.8.24"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.8.22"
+		"@code-yeongyu/senpi": "2026.8.24"
 	},
 	"keywords": [
 		"senpi",

package/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/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/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/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/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/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/src/kernels/AGENTS.md

@@ -0,0 +1,40 @@
+# src/kernels
+
+Persistent kernels for four runtimes plus shared subprocess lifecycle. Earned
+by score 13 — distinct multi-runtime domain (31 files, TS hosts plus embedded
+runner/prelude assets).
+
+## WHERE TO LOOK
+
+| Task | Path |
+| --- | --- |
+| JavaScript host API | `js/context-manager.ts` (`JavaScriptKernel`), `js/worker-host.ts` |
+| JS worker runtime, entries | `js/worker-runtime.js`, `js/worker-entry.js`, `js/inline-worker-entry.js`, `js/inline-worker.ts`, `js/worker-core.js` (+ `worker-core.d.ts`) |
+| JS import rewriting, queueing | `js/rewrite-imports.ts`, `js/run-queue.ts`, `js/prelude.ts`, `js/local-module-loader.ts` |
+| Python kernel | `py/kernel.ts`, `py/transport.ts`, `py/process.ts`, `py/prelude.py` |
+| Ruby kernel | `rb/kernel.ts` + `rb/prelude.rb`, `rb/runner.rb` |
+| Julia kernel | `jl/kernel.ts` + `jl/prelude.jl`, `jl/runner.jl` |
+| Shared subprocess layer | `shared/subprocess-kernel.ts`, `subprocess-{contract,process,queue,run}.ts`, `runtime-asset.ts` |
+
+## CONVENTIONS
+
+- Each language dir pairs a typed TS host/controller with an embedded runner or
+  prelude asset; `shared/runtime-asset.ts` ships them.
+- Transport messages are discriminated by string `type` (`ready`, `result`,
+  `tool-call`, `closed`, `init-failed`, ...) exchanged as framed bridge
+  messages, one JSON line per frame.
+- JS persistent cell bindings are rewritten onto `globalThis`; imports are
+  AST-parsed (Babel) and rewritten to bridge-compatible dynamic imports.
+- JS runs on worker threads with an inline-worker fallback; py/rb/jl run as
+  framed subprocesses through `shared/`.
+- Subprocess retirement/restart, worker recovery, timeout, and interrupt
+  semantics live here, never in the tool layer.
+
+## ANTI-PATTERNS
+
+- Never treat arbitrary objects as bridge messages without discriminant
+  validation.
+- Never rewrite imports by filename/regex — `rewrite-imports.ts` applies
+  source-position edits from the parsed program.
+- An optional interpreter being absent (py/rb/jl not installed) is a capability
+  gap, not an installation failure or error path.

package/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/src/tool/AGENTS.md

@@ -0,0 +1,40 @@
+# src/tool
+
+Eval tool core: input schema, cell execution lifecycle, detached-cell state
+machine, status events, and all call/result rendering. Earned by score 12 —
+highest reference density in the package (`createEvalTool` and `EvalToolDetails`
+anchor most suites).
+
+## WHERE TO LOOK
+
+| Task | Path |
+| --- | --- |
+| Tool registration, options | `eval-tool.ts`, `eval-tool-options.ts`, `eval-request.ts` |
+| Wire contract, TypeBox schemas | `types.ts` (`createEvalInputSchema`, `fullEvalInputSchema`) |
+| Cell execution, settlement | `cell-handler.ts`, `cell-execution.ts`, `cell-runtime.ts` |
+| Detached cells | `detached-cell-manager.ts` + `detached-cell-{state,snapshot,notification}.ts`, `detached-notification-queue.ts`, `detached-eval-result.ts` |
+| Call/result rendering | `render.ts`, `runtime-label.ts`, `json-tree.ts`, `image.ts`, `tool-widgets.ts` |
+| Status events, execution events | `status-events.ts`, `eval-execution-event.ts` |
+| Interrupt, capture | `interrupt-note.ts`, `call-capture.ts` |
+
+## CONVENTIONS
+
+- Wire/schema fields are snake_case (`cell_id`, `on_timeout`); internal TS
+  fields are camelCase. Schemas and shared eval types live only in `types.ts`.
+- Rendering is bounded by explicit line/code-point budgets with an injectable
+  render clock; nothing here depends on wall-clock luck.
+- Detached execution is a first-class state machine — snapshot, notification
+  queue, spill-file notice, result conversion — never folded into ordinary
+  cell execution.
+- Unicode tree glyphs and status icons are intentional UI conventions.
+
+## ANTI-PATTERNS
+
+- Never add unbounded output: previews, JSON tree depth/lines/scalar length,
+  widget lines, and collapsed errors all cap.
+- Never bypass the kernel bridge message contract with ad-hoc return values;
+  kernels import `KernelInterruptHandle` from `types.ts`, so discriminants and
+  lifecycle state are cross-runtime contracts — change them only with all four
+  runtimes and the detached path in mind.
+- `render.ts` (1,030 LOC) is the package's largest file and the highest-risk
+  hotspot for regressions; changes there need render contracts first.

package/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/src/tool/detached-cell-manager.ts

@@ -93,7 +93,7 @@ export class EvalDetachedCellManager {
 		this.#artifactsDir = options.artifactsDir;
 		this.#onStatusChange = options.onStatusChange;
 		this.#onWakeSourceState = options.onWakeSourceState;
-		this.#notificationQueue = new DetachedNotificationQueue(options.notifier, options.artifactsDir);
+		this.#notificationQueue = new DetachedNotificationQueue(options.notifier);
 		this.#now = options.now ?? Date.now;
 		this.#hardLimitSeconds = options.hardLimitSeconds ?? DEFAULT_HARD_LIMIT_SECONDS;
 	}

package/src/tool/detached-cell-notification.ts

@@ -12,7 +12,6 @@ export function detachedNotificationSpillPath(artifactsDir: string | undefined,
 export async function buildDetachedCellNotification(
 	snapshot: EvalDetachedCellSnapshot,
 	spillPath: string | undefined,
-	artifactsDir: string | undefined,
 ): Promise<EvalDetachedCellNotification> {
 	const body = notificationBody(snapshot);
 	const overflow = Buffer.byteLength(body, "utf8") > NOTIFICATION_TAIL_BYTES;
@@ -21,7 +20,9 @@ export async function buildDetachedCellNotification(
 		try {
 			await mkdir(dirname(spillPath), { recursive: true });
 			await writeFile(spillPath, body, "utf8");
-			spillNotice = `\nBuffered output overflowed; full output: ${localUri(spillPath, artifactsDir)}`;
+			// The agent read tool resolves plain paths only, so the notice must carry
+			// the absolute spill path, never the kernel-helper local:// scheme.
+			spillNotice = `\nBuffered output overflowed; full output: ${spillPath}`;
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			spillNotice = `\nBuffered output overflow could not be spilled: ${message}`;
@@ -84,12 +85,6 @@ function safeCellId(cellId: string): string {
 	return cellId.replace(/[^a-zA-Z0-9_-]/gu, "_");
 }
 
-function localUri(path: string, artifactsDir: string | undefined): string {
-	if (artifactsDir === undefined) return `local://${path}`;
-	const root = join(artifactsDir, "local");
-	return path.startsWith(`${root}/`) ? `local://${path.slice(root.length + 1)}` : `local://${path}`;
-}
-
 function truncateTailUtf8(text: string, maxBytes: number): string {
 	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
 	const bytes = Buffer.from(text, "utf8");

package/src/tool/detached-notification-queue.ts

@@ -7,14 +7,12 @@ export interface PendingDetachedNotification {
 }
 
 export class DetachedNotificationQueue {
-	readonly #artifactsDir: string | undefined;
 	readonly #notifier: EvalDetachedCellNotifier | undefined;
 	#pending: PendingDetachedNotification[] = [];
 	#flush: Promise<void> | undefined;
 
-	constructor(notifier: EvalDetachedCellNotifier | undefined, artifactsDir: string | undefined) {
+	constructor(notifier: EvalDetachedCellNotifier | undefined) {
 		this.#notifier = notifier;
-		this.#artifactsDir = artifactsDir;
 	}
 
 	enqueue(notification: PendingDetachedNotification): void {
@@ -32,9 +30,7 @@ export class DetachedNotificationQueue {
 		const flush = Promise.resolve().then(async () => {
 			const pending = this.#pending.splice(0);
 			const notifications = await Promise.all(
-				pending.map(
-					async (item) => await buildDetachedCellNotification(item.snapshot(), item.spillPath, this.#artifactsDir),
-				),
+				pending.map(async (item) => await buildDetachedCellNotification(item.snapshot(), item.spillPath)),
 			);
 			this.#notifier?.notify(notifications);
 		});

package/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/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,

package/src/tool/render.ts

@@ -19,6 +19,7 @@ import {
 	JSON_TREE_SCALAR_LEN_EXPANDED,
 	renderJsonTreeLines,
 } from "./json-tree.ts";
+import { formatRuntimeBadge } from "./runtime-label.ts";
 import { codePointPrefix, formatDuration, renderToolCallWidget } from "./tool-widgets.ts";
 import type {
 	EvalCellResult,
@@ -69,14 +70,38 @@ const TOOL_CALL_PREVIEW_COUNT = 5;
 const TOOL_CALL_COLLAPSED_VISUAL_LINES = 4;
 const TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS = 512;
 const TOOL_ERROR_OMISSION_MARKER = "[tool error omitted]";
+const LIVE_ELAPSED_TICK_MS = 1_000;
 
 class PlainTextComponent implements EvalRenderComponent {
 	#blocks: readonly RenderBlock[] = [];
+	#ticker: ReturnType<typeof setInterval> | undefined;
 
 	setBlocks(blocks: readonly RenderBlock[]): void {
 		this.#blocks = blocks;
 	}
 
+	/**
+	 * The host only animates tool rows for streaming args, `task`, and results carrying
+	 * `details.progress`; an eval row matches none of them, so nothing repaints it between
+	 * update events. While a cell is non-terminal this drives the repaint itself so the
+	 * header's elapsed time advances, and it emits no tool updates or RPC traffic.
+	 */
+	syncLiveTicker(isLive: boolean, invalidate: () => void): void {
+		if (!isLive) {
+			this.stopLiveTicker();
+			return;
+		}
+		if (this.#ticker !== undefined) return;
+		this.#ticker = setInterval(invalidate, LIVE_ELAPSED_TICK_MS);
+		this.#ticker.unref?.();
+	}
+
+	stopLiveTicker(): void {
+		if (this.#ticker === undefined) return;
+		clearInterval(this.#ticker);
+		this.#ticker = undefined;
+	}
+
 	render(width: number): string[] {
 		const lines: string[] = [];
 		for (const block of this.#blocks) {
@@ -109,6 +134,16 @@ function componentFor(context: RenderContext | ResultRenderContext): PlainTextCo
 	return new PlainTextComponent();
 }
 
+/** Render-time clock; tests inject a fixed value so elapsed output never depends on wall time. */
+function renderNow(context: RenderContext | ResultRenderContext): number {
+	const injected: unknown = Reflect.get(context, "now");
+	return typeof injected === "number" && Number.isFinite(injected) ? injected : Date.now();
+}
+
+function hasLiveCell(details: EvalToolDetails | undefined): boolean {
+	return (details?.cells ?? []).some((cell) => isLiveCellStatus(cell.status) && cell.startedAt !== undefined);
+}
+
 function style(theme: Theme | undefined, color: ThemeColor, text: string): string {
 	return theme ? theme.fg(color, text) : text;
 }
@@ -187,6 +222,8 @@ type RenderEnvironment = {
 	readonly spinnerFrame: number | undefined;
 	readonly width: number;
 	readonly meta: TruncationMeta | undefined;
+	/** Render-time clock, injected so elapsed time is deterministic under test. */
+	readonly now: number;
 };
 type CellBadges = {
 	readonly reset: boolean;
@@ -231,6 +268,10 @@ function spinner(frame: number | undefined): string {
 	return SPINNER_FRAMES.at((frame ?? 0) % SPINNER_FRAMES.length) ?? SPINNER_FRAMES[0];
 }
 
+function isLiveCellStatus(status: CellStatus): boolean {
+	return status === "pending" || status === "running" || status === "detached";
+}
+
 function cellPresentation(status: CellStatus, spinnerFrame: number | undefined): StatusPresentation {
 	switch (status) {
 		case "pending":
@@ -259,12 +300,21 @@ function renderPrefixed(text: string, environment: RenderEnvironment, prefixStyl
 	);
 }
 
+// A running cell only receives updates on output/status events, so a stored duration
+// freezes between them. Non-terminal cells therefore derive elapsed time from the
+// render-time clock; terminal cells keep their settled duration verbatim.
+function cellElapsedMs(cell: EvalCellResult, environment: RenderEnvironment): number | undefined {
+	if (!isLiveCellStatus(cell.status) || cell.startedAt === undefined) return cell.durationMs;
+	return Math.max(0, environment.now - cell.startedAt);
+}
+
 function cellHeader(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string {
 	const presentation = cellPresentation(cell.status, environment.spinnerFrame);
-	let header = `eval ${cell.language} ${presentation.label} ${presentation.icon}`;
+	const runtimeBadge = cell.runtime === undefined ? "" : ` (${formatRuntimeBadge(cell.language, cell.runtime)})`;
+	let header = `eval ${cell.language}${runtimeBadge} ${presentation.label} ${presentation.icon}`;
 	const throughputBadge = badges.throughput === undefined ? undefined : formatThroughputBadge(badges.throughput);
 	if (throughputBadge !== undefined) header += ` · ${throughputBadge}`;
-	const elapsedMs = badges.throughput?.wallDurationMs ?? cell.durationMs;
+	const elapsedMs = badges.throughput?.wallDurationMs ?? cellElapsedMs(cell, environment);
 	if (elapsedMs !== undefined) header += ` · ${formatDuration(elapsedMs)}`;
 	if (badges.reset) header += " · reset";
 	if (badges.timeout !== undefined) header += ` · timeout ${badges.timeout}s`;
@@ -780,7 +830,9 @@ function resultHeader(
 			color = "error";
 			break;
 	}
-	return style(theme, color, `eval ${details?.language ?? "?"} ${status}`);
+	const runtimeBadge =
+		details?.runtime === undefined ? "" : ` (${formatRuntimeBadge(details.language, details.runtime)})`;
+	return style(theme, color, `eval ${details?.language ?? "?"}${runtimeBadge} ${status}`);
 }
 
 function resultMetadata(
@@ -843,6 +895,7 @@ export function renderEvalCall(
 					spinnerFrame: context.spinnerFrame,
 					width,
 					meta: undefined,
+					now: renderNow(context),
 				};
 				const cell: EvalCellResult = {
 					index: 0,
@@ -873,6 +926,7 @@ export function renderEvalResult(
 	const details = result.details;
 	const expanded = options.expanded || context.expanded;
 	const imageProtocol = context.imageProtocol ?? null;
+	component.syncLiveTicker(hasLiveCell(details), context.invalidate);
 	if (details?.cells !== undefined && details.cells.length > 0) {
 		const blocks: RenderBlock[] = [
 			{
@@ -885,6 +939,7 @@ export function renderEvalResult(
 							spinnerFrame: context.spinnerFrame,
 							width,
 							meta: details.meta,
+							now: renderNow(context),
 						},
 						args: context.args,
 						showImageFallback: context.showImages && imageProtocol === null,
@@ -936,6 +991,7 @@ export function renderEvalResult(
 						spinnerFrame: context.spinnerFrame,
 						width,
 						meta: details?.meta,
+						now: renderNow(context),
 					};
 					return [
 						...renderStatusEvents(nonAgentEvents, environment),
@@ -957,6 +1013,7 @@ export function renderEvalResult(
 						spinnerFrame: context.spinnerFrame,
 						width,
 						meta: details?.meta,
+						now: renderNow(context),
 					}),
 			},
 		);

package/src/tool/runtime-label.ts

@@ -0,0 +1,49 @@
+import { homedir } from "node:os";
+import type { EvalLanguage, EvalRuntimeInfo } from "./types.ts";
+
+const MAX_BADGE_PATH_CODE_POINTS = 40;
+const ELLIPSIS = "\u2026";
+
+/**
+ * One-line runtime badge for eval headers, e.g. "3.14.7, ~/.venv/bin/python3"
+ * or "node 26.7.0, /opt/…/bin/node". The js language always carries the
+ * runtime name because node and bun are otherwise indistinguishable.
+ */
+export function formatRuntimeBadge(language: EvalLanguage, runtime: EvalRuntimeInfo, home: string = homedir()): string {
+	const label = language === "js" ? `${runtime.name} ${runtime.version}` : runtime.version;
+	if (runtime.path === undefined || runtime.path.length === 0) return label;
+	return `${label}, ${minifyPath(runtime.path, home)}`;
+}
+
+/** Home-contracts and middle-truncates a path so header badges stay short. */
+export function minifyPath(path: string, home: string = homedir()): string {
+	const contracted = contractHome(path, home);
+	if (codePointLength(contracted) <= MAX_BADGE_PATH_CODE_POINTS) return contracted;
+	const separator = contracted.includes("/") ? "/" : "\\";
+	const segments = contracted.split(separator).filter((segment) => segment.length > 0);
+	const head = contracted.startsWith(separator) ? `${separator}${segments[0] ?? ""}` : (segments[0] ?? "");
+	const tail: string[] = [];
+	for (let index = segments.length - 1; index >= 1; index -= 1) {
+		const attempt = joinTruncated(head, [segments[index] ?? "", ...tail], separator);
+		if (codePointLength(attempt) > MAX_BADGE_PATH_CODE_POINTS) break;
+		tail.unshift(segments[index] ?? "");
+	}
+	if (tail.length > 0) return joinTruncated(head, tail, separator);
+	const suffix = [...contracted].slice(-(MAX_BADGE_PATH_CODE_POINTS - 1)).join("");
+	return `${ELLIPSIS}${suffix}`;
+}
+
+function joinTruncated(head: string, tail: readonly string[], separator: string): string {
+	return `${head}${separator}${ELLIPSIS}${separator}${tail.join(separator)}`;
+}
+
+function contractHome(path: string, home: string): string {
+	if (home.length === 0) return path;
+	if (path === home) return "~";
+	if (path.startsWith(`${home}/`) || path.startsWith(`${home}\\`)) return `~${path.slice(home.length)}`;
+	return path;
+}
+
+function codePointLength(text: string): number {
+	return [...text].length;
+}

package/src/tool/types.ts

@@ -140,6 +140,15 @@ export interface EvalToolCallSummary {
 
 export type EvalStatusEvent = { readonly op: string } & Readonly<Record<string, unknown>>;
 
+/** Identity of the runtime executing a kernel: interpreter or JS host. */
+export interface EvalRuntimeInfo {
+	readonly name: string;
+	readonly version: string;
+	readonly path?: string;
+}
+
+export type EvalRuntimes = Readonly<Partial<Record<EvalLanguage, EvalRuntimeInfo>>>;
+
 export type EvalDisplayOutput =
 	| { readonly type: "json"; readonly data: unknown }
 	| { readonly type: "image"; readonly data: string; readonly mimeType: string }
@@ -152,9 +161,12 @@ export type EvalCellResult = {
 	readonly code: string;
 	readonly language: EvalLanguage;
 	readonly output: string;
+	readonly runtime?: EvalRuntimeInfo;
 	readonly status: "pending" | "running" | "detached" | "complete" | "error" | "cancelled";
 	readonly exitCode?: number;
 	readonly durationMs?: number;
+	/** Epoch ms when the cell started; lets renderers tick elapsed time between update events. */
+	readonly startedAt?: number;
 	readonly statusEvents?: readonly EvalStatusEvent[];
 	readonly hasMarkdown?: boolean;
 };
@@ -162,6 +174,7 @@ export type EvalCellResult = {
 export interface EvalToolDetails {
 	readonly language: EvalLanguage;
 	readonly languages?: readonly EvalLanguage[];
+	readonly runtime?: EvalRuntimeInfo;
 	readonly summary?: string;
 	readonly durationMs: number;
 	/** True wall-clock elapsed time since the cell started; `durationMs` stays kernel-reported. */