@code-yeongyu/senpi-codemode 2026.9.5 → 2026.9.7-2

package/CHANGELOG.md

@@ -12,6 +12,80 @@
 
 ### Removed
 
+## [2026.9.7-2] - 2026-09-07
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- The JS kernel's shell capture now pins the worker's environment view for `Bun.spawnSync` as well as `Bun.spawn`, so a cell calling it without an explicit `env` sees the session's `PI_*` values instead of the inherited OS environ.
+- Eval kernels and every child they spawn now see the active session's `PI_*` environment (`PI_SESSION_ID`, `PI_SESSION_FILE`, `PI_PROVIDER`, `PI_MODEL`, `PI_REASONING_LEVEL`) exactly as bash-tool children do: inherited `PI_*` values are dropped before the session values are applied, so subprocesses such as `omo-agent-toolkit ulw-loop` resolve the same session as the `bash` tool instead of a cwd-global one.
+- JavaScript eval cells no longer lose their completion value when a nested function, callback, or try/catch helper contains `return`: the cell wrapper now skips last-expression capture only for a genuine top-level `return`, and a property named `return` no longer primes the statement scanner as the keyword (#1439).
+- Eval output truncation notices now name the real cause: a width-clamped line reports `N line(s) clamped to M columns (… dropped)`, a byte-capped tail reports the actual cap, and a notice never presents the output's own size as a limit.
+
+### Removed
+
+## [2026.9.7] - 2026-09-07
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.6] - 2026-09-06
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- The Bun eval description now tells the model to shell out through `Bun.$` or `Bun.spawn` and never `Bun.spawnSync`, because a synchronous child blocks the worker and a stop or timeout then loses every variable.
+- JavaScript eval cells now interrupt cooperatively: `stop` and kernel timeouts first ask the worker to settle the cell (pending bridge `tool.*` calls are rejected, `Bun.spawn` children are killed) and keep the worker VM and its globals when the cell settles within a 2 s grace; only an unsettled cell restarts the worker.
+
+### Fixed
+
+- `eval({ action: "stop" })` no longer hangs when the JavaScript worker is blocked in a synchronous call such as `Bun.spawnSync`: worker termination is bounded by a 3 s deadline, a fresh worker replaces the blocked one, and the cell output names the blocked synchronous call.
+- `Bun.$` commands run from a JavaScript cell no longer inherit the TUI's terminal as stdin (a stdin reader such as `cat`, an ssh or git credential prompt, or a keychain prompt blocked the cell forever); the shell wrapper isolates stdin while a cell is active without changing output, exit codes, `cwd`, `env`, or explicit stdin redirects.
+- Stop results and detached-cell completion notifications report the real interrupt outcome (variables preserved, worker restarted, or outcome unknown) instead of a hardcoded per-language note.
+
+### Removed
+
+## [2026.9.5-3] - 2026-09-05
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.5-2] - 2026-09-05
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- The GPT eval dialect now routes a wait or a long run through `tool.monitor` inside the cell (the subscription line precedes the detach note, and the `## Tool Guidelines` line says so when `monitor` is reachable), so a GPT model no longer reads "long cells detach" as the way to wait on a `--watch`.
+
+### Fixed
+
+### Removed
+
 ## [2026.9.5] - 2026-09-05
 
 ### Breaking Changes

package/README.md

@@ -54,6 +54,19 @@ task-tool names are known.
 A missing optional interpreter removes that language from the session's `eval`
 schema; it is not an installation failure.
 
+### Session environment
+
+Every kernel starts with the active session's `PI_*` environment — `PI_SESSION_ID`,
+`PI_SESSION_FILE` (when the session is persistent), `PI_PROVIDER`, `PI_MODEL`, and
+`PI_REASONING_LEVEL` (when set) — resolved at session start, mirroring the bash tool's
+session environment contract. The values are visible to `env()`/`process.env`/`os.environ`
+inside cells and are inherited by every child process a cell spawns
+(`Bun.$`, `Bun.spawn`, `child_process`, `subprocess`, ...). Inherited `PI_*` values from
+the launching environment are dropped first, so a child spawned from a cell sees exactly
+what a child spawned from the bash tool sees. The values snapshot at kernel start, so a
+mid-session model switch updates the bash tool's next command but not already-running
+kernels; a new session starts fresh kernels with fresh values.
+
 ## Settings
 
 Configuration is loaded in this order:
@@ -116,7 +129,7 @@ options object and asynchronous helpers are `await`-able.
 | `print(value, ...)` | Emits text output. |
 | `read(path, offset?, limit?)` | Reads text with 1-indexed line slicing. `local://` paths resolve under the session artifact root. |
 | `write(path, content)` | Creates parent directories and writes text. `local://` paths persist in the session artifact root. |
-| `env(key?, value?)` | Reads all kernel environment values, one value, or sets one value. |
+| `env(key?, value?)` | Reads all kernel environment values, one value, or sets one value. Includes the session's `PI_*` values (see [Session environment](#session-environment)). |
 | `tool.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline and returns `{ text, images?, details?, hasError? }` in every kernel; image blocks arrive as `images[i] = { mimeType, dataBase64 }`. |
 | `tool_schema(name?)` | Returns a tool's parameter schema without calling it; omit `name` to list tool names. |
 | `completion(prompt, model?, system?, schema?)` | Requests a one-shot host completion; `schema` asks the host to parse structured output. |
@@ -166,10 +179,26 @@ when the call had no summary), clearing as soon as the last detached cell settle
 
 Use `eval({ action: "peek", cell_id })` for its state and buffered output, or
 `eval({ action: "stop", cell_id })` to cancel it. Python stop interrupts the
-existing kernel and preserves variables. JavaScript stop kills and restarts its
-worker, so JavaScript VM state is lost. Detached completion messages state when
-kernel variables are available to the next eval cell; oversized buffered output
-is written under the session local root and referenced as `local://…`.
+existing kernel and preserves variables. JavaScript stop is cooperative first:
+the worker rejects the cell's pending bridge `tool.*` calls and kills the
+`Bun.spawn` children it started, and a cell that settles within the 2 s grace
+keeps the worker and every global. Only a cell that stays unsettled (a
+never-resolving promise, an un-abortable `fetch`, a `Bun.$` command) costs the
+worker VM. A worker blocked in a synchronous call (`Bun.spawnSync`,
+`child_process.spawnSync`) cannot be stopped at all; after a 3 s termination
+deadline a fresh worker replaces it, the cell output gains a stderr line naming
+the blocked synchronous call, and the blocked call keeps running until it
+returns. Kernel-level timeouts follow the same path. Stop results and detached
+completion messages report the real outcome - variables preserved, worker
+restarted, or outcome unknown - never a per-language assumption; oversized
+buffered output is written under the session local root and referenced as
+`local://…`.
+
+Commands a cell runs through `Bun.$` never read the host's terminal: the worker
+thread shares the TUI's stdin, so the shell wrapper hands every template an
+empty pipe (`true | ( … )`) while a cell is active. Output, exit codes, `cwd`,
+`env`, and explicit `< ${input}` redirects are unchanged; `Bun.spawn` and
+`Bun.spawnSync` already default stdin to `/dev/null`.
 
 ## Output and artifacts
 

package/package.json

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

package/src/bridge/protocol.ts

@@ -26,6 +26,7 @@ const hostToKernelMessageSchema = Type.Union([
 		type: Type.Literal("init"),
 		sessionId: Type.String({ minLength: 1 }),
 		connection: connectionConfigSchema,
+		sessionEnv: Type.Optional(Type.Record(Type.String(), Type.String())),
 	}),
 	Type.Object({
 		type: Type.Literal("run"),

package/src/bridge/reserved.ts

@@ -9,3 +9,5 @@ export const RESERVED_SCHEMA_TOOL = "__schema__" as const;
 export const TIMEOUT_PAUSE_OP = "timeout-pause" as const;
 /** Canonical oh-my-pi eval-timeout resume operation. */
 export const TIMEOUT_RESUME_OP = "timeout-resume" as const;
+/** Status op the JS worker emits the moment it receives `interrupt`; proves its event loop is not blocked. */
+export const INTERRUPT_ACK_OP = "interrupt-ack" as const;

package/src/extension/runtime-factory.ts

@@ -13,6 +13,7 @@ import {
 	getInterpreterAvailability,
 	type InterpreterAvailability,
 } from "../interpreters/detect.ts";
+import { sessionEnvironmentFrom } from "../kernels/session-env.ts";
 import { resolveSessionArtifactsDir } from "../output/streaming-output.ts";
 import type { EnabledEvalLanguages, EvalLanguage, EvalRuntimes } from "../tool/types.ts";
 import { jsRuntimeInfo, runtimesFromAvailability } from "./runtime-info.ts";
@@ -66,11 +67,13 @@ export async function createRuntime(
 	const executeTool = createExecuteTool(pi, activeTools);
 	const create = options.createSessionManager ?? createCodemodeSessionManager;
 	const sessionId = sessionIdFrom(event);
+	const sessionEnv = sessionEnvironmentFrom(ctx);
 	const configuredPoolWidth = settings.parallelPoolWidth;
 	const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
 	const manager = await create({
 		sessionId,
 		cwd: ctx.cwd,
+		sessionEnv,
 		settings,
 		availability,
 		artifactsDir: artifacts.dir,

package/src/extension/session-manager.ts

@@ -11,6 +11,7 @@ import { JuliaKernel } from "../kernels/jl/kernel.ts";
 import { JavaScriptKernel } from "../kernels/js/context-manager.ts";
 import { PythonKernel } from "../kernels/py/kernel.ts";
 import { RubyKernel } from "../kernels/rb/kernel.ts";
+import type { SessionEnvironment } from "../kernels/session-env.ts";
 import { marshalToolResult } from "../tool/image.ts";
 import type { EvalKernel, EvalKernelManager, EvalLanguage, ExecuteTool } from "../tool/types.ts";
 
@@ -40,6 +41,8 @@ export interface CreateCodemodeSessionManagerOptions {
 	readonly localRoots?: Readonly<Record<string, string>>;
 	/** Session-adjacent directory used for persisted eval artifacts. */
 	readonly artifactsDir?: string;
+	/** Per-session PI_* values exposed to every kernel and the children it spawns. */
+	readonly sessionEnv?: SessionEnvironment;
 	readonly executeTool: ExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
@@ -212,6 +215,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				cwd: this.#options.cwd,
 				parallelPoolWidth,
 				onMessage,
+				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 				...(localRoots ? { localRoots: { ...localRoots } } : {}),
 				...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
 			});
@@ -230,6 +234,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				interpreterPath: detected.path,
 				sessionId: this.#options.sessionId,
 				cwd: this.#options.cwd,
+				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 				connection,
 				onMessage,
 			});
@@ -239,6 +244,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				command: detected.path,
 				sessionId: this.#options.sessionId,
 				cwd: this.#options.cwd,
+				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 				connection,
 				onMessage,
 			});
@@ -247,6 +253,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 			command: detected.path,
 			sessionId: this.#options.sessionId,
 			cwd: this.#options.cwd,
+			...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 			connection,
 			onMessage,
 		});

package/src/kernels/AGENTS.md

@@ -15,6 +15,7 @@ runner/prelude assets).
 | 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` |
+| Session environment | `session-env.ts` (PI_* contract shared by all kernels; mirrors the core bash tool) |
 
 ## CONVENTIONS
 
@@ -29,6 +30,12 @@ runner/prelude assets).
   framed subprocesses through `shared/`.
 - Subprocess retirement/restart, worker recovery, timeout, and interrupt
   semantics live here, never in the tool layer.
+- Every kernel exposes the active session's `PI_*` environment (`session-env.ts`):
+  inherited values are deleted before the session's values are applied, so any
+  child spawned from a cell sees the same session environment a bash-tool child
+  sees. The JS worker applies it at init (`worker-core.js`; shell capture pins
+  the env view under Bun because `delete process.env.X` does not unsetenv),
+  and py/rb/jl spawn with it merged into the interpreter environment.
 
 ## ANTI-PATTERNS
 

package/src/kernels/jl/kernel.ts

@@ -1,12 +1,15 @@
 import { join } from "node:path";
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
-import { type CodemodeRuntimeAssetEnvironment, resolveCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
+import type { SessionEnvironment } from "../session-env.ts";
+import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { SubprocessKernel, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
 
 export interface JuliaKernelStartOptions {
 	readonly cwd: string;
 	readonly sessionId: string;
 	readonly connection: BridgeConnectionConfig;
+	/** Per-session PI_* values merged into the interpreter environment at spawn. */
+	readonly sessionEnv?: SessionEnvironment;
 	readonly command?: string;
 	readonly spawn?: SubprocessSpawn;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
@@ -17,7 +20,7 @@ export interface JuliaRunnerPathOptions extends CodemodeRuntimeAssetEnvironment
 }
 
 export function resolveJuliaRunnerPath(options: JuliaRunnerPathOptions = {}): string {
-	return resolveCodemodeRuntimeAsset(
+	return requireCodemodeRuntimeAsset(
 		options.localPath ?? join(import.meta.dirname, "runner.jl"),
 		join("kernels", "jl", "runner.jl"),
 		options,
@@ -42,6 +45,7 @@ export class JuliaKernel extends SubprocessKernel {
 			],
 			cwd: options.cwd,
 			sessionId: options.sessionId,
+			sessionEnv: options.sessionEnv,
 			connection: options.connection,
 			spawn: options.spawn,
 			onMessage: options.onMessage,

package/src/kernels/js/context-manager.ts

@@ -1,9 +1,7 @@
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { INTERRUPT_ACK_OP } from "../../bridge/reserved.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
-import { type CodemodeRuntimeAssetEnvironment, resolveCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
-import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
+import { abandonedWorkerNote, awaitCooperativeSettlement, type WorkerRetirement } from "./interrupt-bounds.ts";
 import {
 	assertJavaScriptKernelOpen,
 	type JavaScriptKernelMode,
@@ -12,31 +10,20 @@ import {
 	type ResultMessage,
 	type ToolCallMessage,
 } from "./kernel-contract.ts";
-import { type JavaScriptKernelOptions, LocalModuleLoader, localBridgeConnection } from "./local-module-loader.ts";
+import { type JavaScriptKernelOptions, LocalModuleLoader } from "./local-module-loader.ts";
 import { JavaScriptRunQueue, type PendingJavaScriptRun, stoppedResult } from "./run-queue.ts";
-import { bridgeError, spawnNodeWorker, WorkerStartupCancelledError, waitForReady } from "./worker-host.ts";
+import { bridgeError, WorkerStartupCancelledError } from "./worker-host.ts";
+import { WorkerSlot } from "./worker-slot.ts";
 
 export { JavaScriptKernelClosedError, type JavaScriptKernelMode, type JavaScriptRunInput } from "./kernel-contract.ts";
 export type { JavaScriptKernelOptions } from "./local-module-loader.ts";
-
-export interface JavaScriptWorkerEntryUrlOptions extends CodemodeRuntimeAssetEnvironment {
-	readonly localPath?: string;
-}
-
-export function resolveJsWorkerEntryUrl(options: JavaScriptWorkerEntryUrlOptions = {}): URL {
-	const localPath = options.localPath ?? join(dirname(fileURLToPath(import.meta.url)), "worker-entry.js");
-	return pathToFileURL(resolveCodemodeRuntimeAsset(localPath, join("kernels", "js", "worker-entry.js"), options));
-}
+export { type JavaScriptWorkerEntryUrlOptions, resolveJsWorkerEntryUrl } from "./worker-startup.ts";
 
 export class JavaScriptKernel {
 	readonly #options: JavaScriptKernelOptions;
 	readonly #moduleLoader: LocalModuleLoader;
-	#worker: WorkerLike | null = null;
-	#mode: JavaScriptKernelMode = "worker";
+	readonly #slot: WorkerSlot;
 	#lifecycle: LifecycleState = "open";
-	#ready: Promise<void> | null = null;
-	#startupAbort: AbortController | null = null;
-	#generation = 0;
 	#activation: Promise<void> | null = null;
 	#recovery: Promise<void> | null = null;
 	#closePromise: Promise<void> | null = null;
@@ -48,10 +35,15 @@ export class JavaScriptKernel {
 	constructor(options: JavaScriptKernelOptions) {
 		this.#options = options;
 		this.#moduleLoader = new LocalModuleLoader(options);
+		this.#slot = new WorkerSlot(options, {
+			isOpen: () => this.#lifecycle === "open",
+			onMessage: (message) => this.#handleMessage(message),
+			onCrash: (error) => this.#handleCrash(error),
+		});
 	}
 
 	get mode(): JavaScriptKernelMode {
-		return this.#mode;
+		return this.#slot.mode;
 	}
 
 	async run(input: JavaScriptRunInput): Promise<ResultMessage> {
@@ -64,13 +56,16 @@ export class JavaScriptKernel {
 	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "interrupt");
 		const active = this.#runs.active;
-		const target = this.#runs.takeInterruptTarget();
-		if (!target) return { stateRetained: Promise.resolve(true) };
-		if (target === active) this.#clearTimeout();
-		this.#runs.settle(target, stoppedResult(target.input.cellId, `JS cell interrupted: ${reason}`));
-		await this.#restartAfterStop();
-		// A restart always replaces the worker VM, so no user global survives.
-		return { stateRetained: Promise.resolve(false) };
+		if (!active) {
+			const queued = this.#runs.takeInterruptTarget();
+			if (!queued) return { stateRetained: Promise.resolve(true) };
+			this.#runs.settle(queued, stoppedResult(queued.input.cellId, `JS cell interrupted: ${reason}`));
+			await this.#restartAfterStop();
+			return { stateRetained: Promise.resolve(false) };
+		}
+		this.#clearTimeout();
+		const stop = await this.#stopActive(active, reason, `JS cell interrupted: ${reason}`);
+		return { stateRetained: Promise.resolve(stop.retained), ...(stop.note === undefined ? {} : { note: stop.note }) };
 	}
 
 	async reset(): Promise<void> {
@@ -82,7 +77,7 @@ export class JavaScriptKernel {
 	}
 
 	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void {
-		if (this.#lifecycle === "open") this.#worker?.postMessage(message);
+		if (this.#lifecycle === "open") this.#slot.postMessage(message);
 	}
 
 	async nextToolCall(): Promise<ToolCallMessage> {
@@ -93,7 +88,7 @@ export class JavaScriptKernel {
 
 	async close(): Promise<void> {
 		if (this.#closePromise) return await this.#closePromise;
-		this.#worker?.postMessage({ type: "close" });
+		this.#slot.postMessage({ type: "close" });
 		this.#lifecycle = "closing";
 		this.#runs.settleAll("JS kernel closed");
 		const recovery = this.#recovery;
@@ -129,92 +124,17 @@ export class JavaScriptKernel {
 
 	async #ensureReady(): Promise<void> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "run");
-		if (!this.#ready) {
-			const generation = ++this.#generation;
-			const controller = new AbortController();
-			this.#startupAbort = controller;
-			const ready = this.#startWorker(generation, controller.signal);
-			this.#ready = ready;
-			void ready.then(
-				() => {
-					if (this.#ready === ready) this.#startupAbort = null;
-				},
-				() => {
-					if (this.#ready === ready) {
-						this.#ready = null;
-						this.#startupAbort = null;
-					}
-				},
-			);
-		}
-		return await this.#ready;
-	}
-
-	async #startWorker(generation: number, signal: AbortSignal): Promise<void> {
-		let worker = this.#spawnWorker();
-		this.#publishWorker(worker, generation);
-		try {
-			await this.#initializeWorker(worker, signal);
-			return;
-		} catch (error) {
-			if (!this.#isCurrent(worker, generation) || error instanceof WorkerStartupCancelledError) {
-				await worker.terminate();
-				throw new WorkerStartupCancelledError();
-			}
-			if (worker.mode === "inline") throw error;
-			this.#worker = null;
-			await worker.terminate();
-		}
-		if (this.#lifecycle !== "open" || generation !== this.#generation) throw new WorkerStartupCancelledError();
-		worker = createInlineWorker(this.#options.cwd, this.#options.parallelPoolWidth);
-		this.#publishWorker(worker, generation);
-		await this.#initializeWorker(worker, signal);
-	}
-
-	#spawnWorker(): WorkerLike {
-		try {
-			const url = this.#options.workerEntryUrl ?? resolveJsWorkerEntryUrl();
-			return spawnNodeWorker(url, this.#options.cwd, this.#options.parallelPoolWidth);
-		} catch (error) {
-			if (!(error instanceof Error)) throw error;
-			return createInlineWorker(this.#options.cwd, this.#options.parallelPoolWidth);
-		}
-	}
-
-	#publishWorker(worker: WorkerLike, generation: number): void {
-		if (this.#lifecycle !== "open" || generation !== this.#generation) throw new WorkerStartupCancelledError();
-		this.#worker = worker;
-		this.#mode = worker.mode;
-		worker.onMessage((message) => {
-			if (this.#isCurrent(worker, generation)) this.#handleMessage(message);
-		});
-		worker.onError((error) => {
-			if (this.#isCurrent(worker, generation)) this.#handleCrash(error);
-		});
-	}
-
-	async #initializeWorker(worker: WorkerLike, signal: AbortSignal): Promise<void> {
-		const ready = waitForReady(worker, signal);
-		worker.postMessage({
-			type: "init",
-			sessionId: this.#options.sessionId,
-			connection: localBridgeConnection(this.#options),
-		});
-		await ready;
-	}
-
-	#isCurrent(worker: WorkerLike, generation: number): boolean {
-		return this.#lifecycle === "open" && this.#worker === worker && this.#generation === generation;
+		await this.#slot.ensureReady();
 	}
 
 	#startNext(): void {
-		if (this.#lifecycle !== "open" || this.#runs.active || !this.#worker) return;
+		if (this.#lifecycle !== "open" || this.#runs.active || !this.#slot.present) return;
 		const next = this.#runs.startNext(performance.now());
 		if (!next) return;
 		if (next.input.timeoutMs) {
 			this.#timeout = setTimeout(() => void this.#timeoutActive(next), next.input.timeoutMs);
 		}
-		this.#worker.postMessage({
+		this.#slot.postMessage({
 			type: "run",
 			cellId: next.input.cellId,
 			code: this.#moduleLoader.prepareCell(next.input.code),
@@ -223,21 +143,46 @@ export class JavaScriptKernel {
 	}
 
 	async #timeoutActive(run: PendingJavaScriptRun): Promise<void> {
-		if (!this.#runs.releaseActive(run)) return;
+		if (this.#runs.active !== run || run.settled) return;
 		const durationMs = run.input.timeoutMs ?? 0;
-		this.#runs.settle(run, {
-			type: "result",
-			cellId: run.input.cellId,
-			ok: false,
-			error: { message: `JS cell timed out after ${durationMs}ms` },
+		await this.#stopActive(
+			run,
+			`timed out after ${durationMs}ms`,
+			`JS cell timed out after ${durationMs}ms`,
 			durationMs,
-		});
-		await this.#restartAfterStop();
+		);
+	}
+
+	/**
+	 * Asks the worker to settle the active cell cooperatively (rejecting its bridge calls and killing its
+	 * children); only a cell that stays unsettled past the grace costs the worker VM. Reports whether the
+	 * worker state survived and, when a blocked worker had to be abandoned, the note that explains it.
+	 */
+	async #stopActive(
+		run: PendingJavaScriptRun,
+		reason: string,
+		message: string,
+		durationMs = 0,
+	): Promise<{ readonly retained: boolean; readonly note?: string }> {
+		run.interruptResult = { type: "result", cellId: run.input.cellId, ok: false, error: { message }, durationMs };
+		run.interruptAck ??= Promise.withResolvers<void>();
+		this.#slot.postMessage({ type: "interrupt", reason });
+		if ((await awaitCooperativeSettlement(run)) === "settled") return { retained: run.settledByWorker };
+		if (!this.#runs.releaseActive(run)) return { retained: run.settledByWorker };
+		const retirement = await this.#terminate();
+		this.#runs.settle(run, run.interruptResult ?? stoppedResult(run.input.cellId, message));
+		void this.#recover(() => Promise.resolve());
+		return retirement === "abandoned" ? { retained: false, note: abandonedWorkerNote() } : { retained: false };
 	}
 
 	async #restartAfterStop(): Promise<void> {
+		await this.#recover(() => this.#terminate());
+	}
+
+	/** One recovery at a time: retire through `retire` (a no-op when the worker is already gone), then bring a fresh worker up. */
+	async #recover(retire: () => Promise<unknown>): Promise<void> {
 		if (this.#recovery) return await this.#recovery;
-		const recovery = this.#performRestartAfterStop();
+		const recovery = this.#performRecovery(retire);
 		this.#recovery = recovery;
 		try {
 			await recovery;
@@ -246,9 +191,9 @@ export class JavaScriptKernel {
 		}
 	}
 
-	async #performRestartAfterStop(): Promise<void> {
+	async #performRecovery(retire: () => Promise<unknown>): Promise<void> {
 		try {
-			await this.#terminate();
+			await retire();
 			if (this.#lifecycle !== "open") return;
 			await this.#ensureReady();
 			if (this.#lifecycle === "open") this.#startNext();
@@ -259,6 +204,10 @@ export class JavaScriptKernel {
 	}
 
 	#handleMessage(message: KernelToHostMessage): void {
+		if (message.type === "status" && message.event.op === INTERRUPT_ACK_OP) {
+			this.#runs.active?.interruptAck?.resolve();
+			return;
+		}
 		this.#options.onMessage?.(message);
 		this.#runs.active?.input.onMessage?.(message);
 		if (message.type === "tool-call") {
@@ -272,13 +221,14 @@ export class JavaScriptKernel {
 		if (!active || active.input.cellId !== message.cellId) return;
 		this.#clearTimeout();
 		this.#runs.releaseActive(active);
-		this.#runs.settle(active, message);
+		active.settledByWorker = true;
+		this.#runs.settle(active, active.interruptResult ?? message);
 		this.#startNext();
 	}
 
 	#handleCrash(error: Error): void {
 		const active = this.#runs.active;
-		if (!active && this.#startupAbort) return;
+		if (!active && this.#slot.startingUp) return;
 		this.#clearTimeout();
 		if (active) {
 			this.#runs.releaseActive(active);
@@ -298,14 +248,8 @@ export class JavaScriptKernel {
 		this.#timeout = null;
 	}
 
-	async #terminate(): Promise<void> {
+	async #terminate(): Promise<WorkerRetirement> {
 		this.#clearTimeout();
-		this.#generation += 1;
-		this.#startupAbort?.abort();
-		this.#startupAbort = null;
-		this.#ready = null;
-		const worker = this.#worker;
-		this.#worker = null;
-		if (worker) await worker.terminate();
+		return await this.#slot.retire();
 	}
 }

package/src/kernels/js/inline-worker.ts

@@ -1,7 +1,7 @@
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
-import { type CodemodeRuntimeAssetEnvironment, resolveCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
+import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import type { JavaScriptKernelMode } from "./kernel-contract.ts";
 import { spawnNodeWorker } from "./worker-host.ts";
 
@@ -12,7 +12,7 @@ export interface JavaScriptInlineWorkerEntryUrlOptions extends CodemodeRuntimeAs
 export function resolveInlineWorkerEntryUrl(options: JavaScriptInlineWorkerEntryUrlOptions = {}): URL {
 	const localPath = options.localPath ?? join(dirname(fileURLToPath(import.meta.url)), "inline-worker-entry.js");
 	return pathToFileURL(
-		resolveCodemodeRuntimeAsset(localPath, join("kernels", "js", "inline-worker-entry.js"), options),
+		requireCodemodeRuntimeAsset(localPath, join("kernels", "js", "inline-worker-entry.js"), options),
 	);
 }