@code-yeongyu/senpi 2026.8.22 → 2026.8.24

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/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/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/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/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/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/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/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/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,