@code-yeongyu/senpi-codemode 2026.10.1-2 → 2026.10.1-3

package/CHANGELOG.md

@@ -12,6 +12,26 @@
 
 ### Removed
 
+## [2026.10.1-3] - 2026-10-01
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- The `eval` tool points at the bun-1-4 skill before a cell that installs a package, spawns a server or PTY, or starts a long run, instead of demanding it before the first JavaScript cell ([#2505](https://github.com/code-yeongyu/senpi/issues/2505)).
+
+### Fixed
+
+- Kernel-originated tool approvals now reach the RPC client that submitted the cell, including approvals requested after a cell detaches and its original turn ends. Reusing a kernel no longer sends permission dialogs to its creation context. ([#2512](https://github.com/code-yeongyu/senpi/issues/2512))
+
+- Python eval startup waits for kernel readiness with advancing stage events instead of a five-second total deadline. Cold Windows imports can complete normally; a hung start identifies its stalled stage. ([#2452](https://github.com/code-yeongyu/senpi/issues/2452))
+
+- Fixed the running eval spinner freezing between output updates. ([#2503](https://github.com/code-yeongyu/senpi/issues/2503))
+
+### Removed
+
 ## [2026.10.1-2] - 2026-10-01
 
 ### Breaking Changes

package/README.md

@@ -18,6 +18,9 @@ task-tool names are known.
 	events, tool-call summaries, elapsed duration, and structured display state;
 	a terminal peek preserves the exact final result.
 - Loopback, bearer-authenticated kernel bridge with bounded JSONL frames.
+- Tool calls retain the submitting cell's host context, including its RPC approval
+  channel, even after detachment or kernel reuse. Headless sessions deny commands
+  that require approval rather than waiting for an absent UI.
 - Structured status events for file operations, environment access, phases,
   bridge activity, and delegated task progress.
 - One versioned `senpi.eval.execution` event at terminal cell settlement. The
@@ -56,6 +59,14 @@ task-tool names are known.
 A missing optional interpreter removes that language from the session's `eval`
 schema; it is not an installation failure.
 
+Python startup waits for the interpreter's `ready` event. It reports progress
+through `stdlib-imports`, `runtime-init`, and `host-init`; advancing to the next
+stage resets an inactivity guard rather than consuming a total startup budget.
+The default guard is 11 seconds per stage, derived from a measured 5.220-second
+Windows fresh-cache bootstrap p99 (30 samples). A stalled or failed start names
+the last stage and retains the interpreter's diagnostic error. The low-level
+`PythonKernel.start({ startupTimeoutMs })` override applies per stage.
+
 ### Session environment
 
 Every kernel starts with the active session's `PI_*` environment — `PI_SESSION_ID`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.10.1-2",
+	"version": "2026.10.1-3",
 	"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.10.1-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.1-3",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.10.1-2"
+		"@code-yeongyu/senpi": "2026.10.1-3"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.10.1-2"
+		"@code-yeongyu/senpi": "2026.10.1-3"
 	},
 	"keywords": [
 		"senpi",

package/src/kernels/py/kernel-contract.ts

@@ -3,6 +3,7 @@ import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/p
 import type { EvalKernelRunInput } from "../../tool/types.ts";
 import type { SessionEnvironment } from "../session-env.ts";
 import type { KernelSpawnProcess } from "./process.ts";
+import type { PythonStartupStage } from "./startup.ts";
 import type { PythonTransportResult } from "./transport.ts";
 
 export interface PythonKernelStartOptions {
@@ -13,7 +14,10 @@ export interface PythonKernelStartOptions {
 	readonly env?: NodeJS.ProcessEnv;
 	/** Per-session PI_* values merged into the interpreter environment at spawn. */
 	readonly sessionEnv?: SessionEnvironment;
+	/** Python bootstrap inactivity guard per advancing stage, not a total readiness deadline. */
 	readonly startupTimeoutMs?: number;
+	/** Observes bootstrap control events without mixing them into cell output callbacks. */
+	readonly onStartupProgress?: (stage: PythonStartupStage) => void;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly spawnProcess?: KernelSpawnProcess;
 	/** Post-cell collection, notice, and ceiling thresholds sent on `init`; absent leaves memory unmanaged. */

package/src/kernels/py/kernel.ts

@@ -1,15 +1,16 @@
+// allow: SIZE_OK — one persistent Python lifecycle state machine owns queue, generation, and retirement.
 import type { KernelInterruptHandle } from "../../tool/types.ts";
 import type { KernelToolsInvokeOptions } from "../js/kernel-tools-types.ts";
 import { rejectKernelToolsUnavailable } from "../kernel-tools-unavailable.ts";
 import { KernelMemoryHost } from "../shared/kernel-memory-host.ts";
 import { KernelPreludeTracker } from "../shared/kernel-prelude-plan.ts";
 import type { PendingRun, PythonKernelRunOptions, PythonKernelStartOptions, ResultMessage } from "./kernel-contract.ts";
+import { pythonStartupHangGuardMs } from "./startup.ts";
 import { failedPythonResult, PythonKernelTransport } from "./transport.ts";
 
 export type { PythonKernelRunOptions, PythonKernelStartOptions } from "./kernel-contract.ts";
 export type { KernelChild, KernelSpawnOptions, KernelSpawnProcess } from "./process.ts";
 
-const startupTimeoutMs = 5_000;
 const interruptEscalationMs = 5_000;
 
 export class PythonKernel {
@@ -229,7 +230,7 @@ export class PythonKernel {
 						: (this.#active?.input.onMessage ?? this.#options.onMessage);
 				callback?.(message);
 			},
-			startupTimeoutMs: this.#options.startupTimeoutMs ?? startupTimeoutMs,
+			startupTimeoutMs: this.#options.startupTimeoutMs ?? pythonStartupHangGuardMs,
 			isOwned: () => !this.#closed && generation === this.#generation,
 			onRetirementFailure: (transport, error) => {
 				if (!this.#transport) this.#transport = transport;

package/src/kernels/py/prelude.py

@@ -1,6 +1,13 @@
 from __future__ import annotations
 
 # noqa: SIZE_OK — this dependency-free subprocess prelude must ship as one file.
+import sys
+
+# Emit before importing the stdlib graph: a cold interpreter can still be making
+# progress after the former five-second total startup deadline.
+sys.__stdout__.write('{"type":"status","event":{"op":"kernel-startup","stage":"stdlib-imports"}}\n')
+sys.__stdout__.flush()
+
 import ast
 import asyncio  # noqa: ANYIO_OK — stdlib-only embedded kernel runner.
 import base64
@@ -15,7 +22,6 @@ import os
 import re
 import signal
 import subprocess
-import sys
 import time
 import traceback
 import types
@@ -29,6 +35,9 @@ from threading import Lock, Thread
 from typing import Any, Callable, Union
 from urllib.parse import unquote
 
+sys.__stdout__.write('{"type":"status","event":{"op":"kernel-startup","stage":"runtime-init"}}\n')
+sys.__stdout__.flush()
+
 CONNECTION: dict[str, Any] = {}
 USER_NS: dict[str, Any] = {"__name__": "__main__", "__doc__": None, "__builtins__": __builtins__}
 LOOP = asyncio.new_event_loop()
@@ -1463,6 +1472,7 @@ def _start_parent_watch() -> None:
 
 
 def main() -> None:
+    emit_status("kernel-startup", force=True, stage="host-init")
     signal.signal(signal.SIGINT, signal.SIG_IGN)
     _start_parent_watch()
     host_closed = False

package/src/kernels/py/startup.ts

@@ -0,0 +1,75 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+
+// Fresh-cache Windows bootstrap: p99 5,220 ms across 30 samples in Actions run
+// 36882163342. Twice that observation, rounded up to a second, is a hang guard,
+// not a total startup budget: only an advancing kernel stage rearms it.
+export const pythonStartupHangGuardMs = 11_000;
+
+const stages = ["interpreter-launch", "stdlib-imports", "runtime-init", "host-init"] as const;
+export type PythonStartupStage = (typeof stages)[number];
+
+export class PythonKernelStartupError extends Error {
+	readonly stage: PythonStartupStage;
+
+	constructor(stage: PythonStartupStage, reason: string, cause?: Error) {
+		super(`Python kernel startup failed at ${stage}: ${reason}`, { cause });
+		this.name = "PythonKernelStartupError";
+		this.stage = stage;
+	}
+}
+
+/** Owns the ready event and a per-stage inactivity watchdog, never a total deadline. */
+export class PythonStartup {
+	readonly #timeoutMs: number;
+	readonly #failureDetail: () => string;
+	readonly #ready = Promise.withResolvers<void>();
+	readonly ready = this.#ready.promise;
+	#timer: NodeJS.Timeout | undefined;
+	#stageIndex = 0;
+	#settled = false;
+
+	constructor(timeoutMs: number, failureDetail: () => string) {
+		this.#timeoutMs = timeoutMs;
+		this.#failureDetail = failureDetail;
+		this.#arm();
+	}
+
+	progress(message: KernelToHostMessage): PythonStartupStage | undefined {
+		if (this.#settled || message.type !== "status" || message.event.op !== "kernel-startup") return;
+		const stage = stages.find((candidate) => candidate === message.event.stage);
+		if (stage === undefined) return;
+		const next = stages.indexOf(stage);
+		if (next <= this.#stageIndex) return;
+		this.#stageIndex = next;
+		this.#arm();
+		return stage;
+	}
+
+	settle(error?: Error): boolean {
+		if (this.#settled) return false;
+		this.#settled = true;
+		clearTimeout(this.#timer);
+		if (error) {
+			const stage = stages[this.#stageIndex] ?? "interpreter-launch";
+			this.#ready.reject(
+				error instanceof PythonKernelStartupError
+					? error
+					: new PythonKernelStartupError(stage, error.message, error),
+			);
+		} else this.#ready.resolve();
+		return true;
+	}
+
+	#arm(): void {
+		clearTimeout(this.#timer);
+		this.#timer = setTimeout(() => {
+			const detail = this.#failureDetail().trim();
+			this.settle(
+				new PythonKernelStartupError(
+					stages[this.#stageIndex] ?? "interpreter-launch",
+					`no progress for ${this.#timeoutMs}ms${detail ? `; ${detail}` : ""}`,
+				),
+			);
+		}, this.#timeoutMs);
+	}
+}

package/src/kernels/py/transport.ts

@@ -23,8 +23,8 @@ import {
 	splitCommand,
 	sweepProcessGroup,
 	waitForExit,
-	withTimeout,
 } from "./process.ts";
+import { PythonStartup, type PythonStartupStage } from "./startup.ts";
 
 export type PythonTransportResult = Extract<KernelToHostMessage, { type: "result" }>;
 
@@ -44,6 +44,7 @@ export interface PythonTransportOptions {
 	/** Per-session PI_* values merged into the interpreter environment at spawn. */
 	readonly sessionEnv?: SessionEnvironment;
 	readonly startupTimeoutMs: number;
+	readonly onStartupProgress?: (stage: PythonStartupStage) => void;
 	readonly memory?: KernelMemoryThresholds;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly spawnProcess?: KernelSpawnProcess;
@@ -73,7 +74,7 @@ export class PythonKernelTransport {
 	readonly #child: KernelChild;
 	#stdoutBuffer = "";
 	#stderrTail = "";
-	#settleReady: ((error?: Error) => void) | null = null;
+	#startup: PythonStartup | null = null;
 	#detachChildListeners: (() => void) | null = null;
 	#active = true;
 	#exited = false;
@@ -173,9 +174,8 @@ export class PythonKernelTransport {
 	}
 
 	async #initialize(): Promise<void> {
-		const ready = new Promise<void>((resolve, reject) => {
-			this.#settleReady = (error) => (error ? reject(error) : resolve());
-		});
+		const startup = new PythonStartup(this.#options.startupTimeoutMs, () => this.#stderrTail);
+		this.#startup = startup;
 		const onStdout = (chunk: unknown) => this.#onStdout(String(chunk));
 		const onStderr = (chunk: unknown) => this.#onStderr(String(chunk));
 		const onError = (error: unknown) => this.#onError(error instanceof Error ? error : new Error(String(error)));
@@ -192,7 +192,7 @@ export class PythonKernelTransport {
 		this.#child.on("exit", onExit);
 		const { sessionId, connection, memory } = this.#options;
 		this.#write({ type: "init", sessionId, connection, ...(memory === undefined ? {} : { memory }) });
-		await withTimeout(ready, this.#options.startupTimeoutMs, "Python kernel did not become ready");
+		await startup.ready;
 	}
 
 	#write(message: HostToKernelMessage): void {
@@ -225,6 +225,11 @@ export class PythonKernelTransport {
 		}
 		if (!isKernelToHostMessage(decoded.message)) return;
 		const message = decoded.message;
+		if (message.type === "status" && message.event.op === "kernel-startup") {
+			const stage = this.#startup?.progress(message);
+			if (stage !== undefined) this.#options.onStartupProgress?.(stage);
+			return;
+		}
 		if (message.type === "ready") this.#settleStartup();
 		else if (message.type === "init-failed") this.#settleStartup(new Error(message.error.message));
 		else if (message.type === "result") this.#options.onResult(this, message);
@@ -258,11 +263,7 @@ export class PythonKernelTransport {
 	}
 
 	#settleStartup(error?: Error): boolean {
-		const settle = this.#settleReady;
-		if (!settle) return false;
-		this.#settleReady = null;
-		settle(error);
-		return true;
+		return this.#startup?.settle(error) ?? false;
 	}
 }
 

package/src/prompt/eval-prompt-template.ts

@@ -29,7 +29,7 @@ Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to it
 A cell that outlives the foreground window detaches and keeps running; further cells on the same language queue behind it in submission order on the same kernel (state is shared, execution is serial) while other languages run at once, up to {{maxDetachedCells}} background cells per session; each detached cell completes as one notification. Do not re-run a detached or queued cell; read, cancel or enumerate them with \`eval({ action: "peek" | "stop", cell_id })\` / \`eval({ action: "list" })\`; list shows live and recently settled cells across languages without consuming notifications. Its own execution time is capped at {{runBudgetSeconds}}s — queue time and time inside host tool calls are not charged; the hard limit stays wall-clock from submission; raise \`timeout\` only for a declared long run — and a killed js cell that cannot settle restarts its kernel with every global lost.
 
 {{#if py}}Python runs on a live event loop: use top-level \`await\`; \`asyncio.run(…)\` raises.{{/if}}
-{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot. Shell out through \`Bun.$\` or \`Bun.spawn\`, never \`Bun.spawnSync\`: a synchronous child blocks the worker and cannot be interrupted.{{#if bunSkillPath}} MUST READ the bun-1-4 skill at {{bunSkillPath}} before your first js cell — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
+{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot. Shell out through \`Bun.$\` or \`Bun.spawn\`, never \`Bun.spawnSync\`: a synchronous child blocks the worker and cannot be interrupted.{{#if bunSkillPath}} Before a cell that installs a package, spawns a server or PTY, or starts a long run, read the bun-1-4 skill at {{bunSkillPath}} — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
 {{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
 {{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
 On error, fix and re-run only the failing step; a normal error keeps state, while a timeout or stop message says whether the kernel restarted.

package/src/skill/bun-1-4/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: bun-1-4
-description: "MUST READ before your first js eval cell: this session's eval js kernel runs Bun 1.4+ (this skill is present only when it does). Also read before any bun -e, script, server, CLI, test, bundle, or package-management work. Bun 1.4 ships builtins that replace 15+ npm deps — check here BEFORE installing sharp, puppeteer/playwright (scraping), marked, node-cron, node-pty, concurrently, serve-static, tar, json5, fast-xml-parser, string-width. Triggers: eval js, bun, Bun.serve, bun test, bun build, bun install, bun run, image resize, headless browser, markdown render, cron, PTY."
+description: "Read before a js eval cell that installs a package, spawns a server or PTY, or starts a long run, and before any bun -e, script, server, CLI, test, bundle, or package-management work: this session's eval js kernel runs Bun 1.4+ (this skill is present only when it does). Bun 1.4 ships builtins that replace 15+ npm deps — check here BEFORE installing sharp, puppeteer/playwright (scraping), marked, node-cron, node-pty, concurrently, serve-static, tar, json5, fast-xml-parser, string-width. Triggers: eval js, bun, Bun.serve, bun test, bun build, bun install, bun run, image resize, headless browser, markdown render, cron, PTY."
 ---
 
 # Bun 1.4 — Use the Builtins First

package/src/tool/cell-handler.ts

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import {
 	type AgentToolResult,
 	type ExtensionContext,
@@ -54,11 +55,18 @@ export class CellHandler {
 	readonly #state: CellState;
 	readonly #runtime: CellBridgeRuntime;
 	readonly #resultBuilder: CellResultBuilder;
+	readonly #dispatchContext: ReturnType<typeof AsyncLocalStorage.snapshot>;
 
 	constructor(kernel: EvalKernel, state: CellState, runtime: CellBridgeRuntime) {
 		this.#kernel = kernel;
 		this.#state = state;
 		this.#runtime = runtime;
+		// Construct in the submitting cell's host context; worker callbacks cannot supply it (#2512).
+		// Bind this cell's capability once; undefined clears any enclosing JS grant for non-JS cells.
+		this.#dispatchContext =
+			runtime.kernelTools === undefined
+				? kernelToolsStorage.exit(() => AsyncLocalStorage.snapshot())
+				: kernelToolsStorage.run(runtime.kernelTools, () => AsyncLocalStorage.snapshot());
 		const settings = runtime.settings.outputSink;
 		this.#resultBuilder = new CellResultBuilder({
 			state,
@@ -89,7 +97,8 @@ export class CellHandler {
 				this.#resultBuilder.display(message);
 				return;
 			case "tool-call": {
-				const pending = this.#dispatchToolCall(message);
+				// A retained worker carries its creation context, not this cell's RPC connection.
+				const pending = this.#dispatchContext(() => this.#handleToolCall(message));
 				this.#state.pendingBridgeCalls.push(pending);
 				await pending;
 				return;
@@ -122,19 +131,6 @@ export class CellHandler {
 		return this.#resultBuilder.liveResult();
 	}
 
-	/**
-	 * The worker's message loop fires outside the async context `run-eval-cell.ts` enters around the
-	 * awaited run chain, so the capability has to be entered here — around the whole dispatch, including
-	 * the reserved agent()/output() bridges where a host task tool resolves the parent's kernel tools —
-	 * for exactly the duration of each host tool call this cell makes (#1754). Without a capability
-	 * (py/rb/jl) the store stays empty and `ctx.kernelTools` remains undefined.
-	 */
-	async #dispatchToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
-		const kernelTools = this.#runtime.kernelTools;
-		if (kernelTools === undefined) return await this.#handleToolCall(message);
-		return await kernelToolsStorage.run(kernelTools, async () => await this.#handleToolCall(message));
-	}
-
 	async #handleToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
 		const startedAt = Date.now();
 		const metric = createToolCallMetric(message.toolName, startedAt);

package/src/tool/render.ts

@@ -73,9 +73,9 @@ 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;
+const LIVE_RENDER_TICK_MS = 100;
 // A live row repaints on every tick, so this many ticks without a render means the row is gone.
-const LIVE_TICKER_MAX_IDLE_TICKS = 60;
+const LIVE_TICKER_MAX_IDLE_TICKS = 600;
 
 class PlainTextComponent implements EvalRenderComponent {
 	#blocks: readonly RenderBlock[] = [];
@@ -92,7 +92,7 @@ class PlainTextComponent implements EvalRenderComponent {
 	 * 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. Detached
+	 * header's spinner and elapsed time advance, with no tool updates or RPC traffic. Detached
 	 * and terminal cards never arm it, and a ticker whose row stopped rendering (transcript
 	 * rebuild, session switch) stops itself after LIVE_TICKER_MAX_IDLE_TICKS and rearms on
 	 * the next render, so dropped rows cannot accumulate intervals.
@@ -115,7 +115,7 @@ class PlainTextComponent implements EvalRenderComponent {
 
 	#armTicker(): void {
 		if (this.#ticker !== undefined || this.#invalidate === undefined) return;
-		this.#ticker = setInterval(() => this.#tick(), LIVE_ELAPSED_TICK_MS);
+		this.#ticker = setInterval(() => this.#tick(), LIVE_RENDER_TICK_MS);
 		this.#ticker.unref?.();
 	}
 
@@ -336,7 +336,10 @@ function cellElapsedMs(cell: EvalCellResult, environment: RenderEnvironment): nu
 }
 
 function cellHeader(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string {
-	const presentation = cellPresentation(cell.status, environment.spinnerFrame);
+	const presentation = cellPresentation(
+		cell.status,
+		environment.spinnerFrame ?? Math.floor((cellElapsedMs(cell, environment) ?? 0) / LIVE_RENDER_TICK_MS),
+	);
 	const runtimeBadge = cell.runtime === undefined ? "" : ` (${formatRuntimeBadge(cell.language, cell.runtime)})`;
 	let header = `eval ${cell.language}${runtimeBadge} ${presentation.label} ${presentation.icon}`;
 	if (cell.queuedBehind !== undefined && cell.queuedBehind.length > 0)

package/src/tool/run-eval-cell.ts

@@ -207,8 +207,8 @@ async function executeCell(
 	};
 	try {
 		const kernel = await execution.wait(options.kernelManager.getKernel(invocation.input.language, onMessage));
-		// Computed before the handler so the cell's capability can be entered per host tool call from the
-		// worker's message loop, which runs outside the `kernelToolsStorage.run` context below (#1754).
+		// Computed before the handler so its construction-time snapshot captures this cell's capability.
+		// Worker messages later restore that snapshot before calling host tools (#1754, #2512).
 		const kernelTools = jsKernelTools(kernel, invocation.input.language);
 		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
 			const queue = kernel.queueSnapshot();