@code-yeongyu/senpi-codemode 2026.7.25-2 → 2026.7.26

package/CHANGELOG.md

@@ -12,6 +12,29 @@
 
 ### Removed
 
+## [2026.7.26] - 2026-07-26
+
+### Breaking Changes
+
+- Remove the separate GPT-only `exec`/`wait` runtime; GPT models now compose active tools through the persistent `eval` surface.
+
+### Added
+
+- Detach interactive `eval` cells on timeout, inject completion notifications, and support `peek`/`stop` actions without blocking other language kernels.
+- Report whether Python kernel state survived an interrupt or timeout, with a real-surface QA driver covering the contract.
+
+### Changed
+
+- Bound each cell's retained status history and summarize omitted events ([#334](https://github.com/code-yeongyu/senpi/pull/334) by [@minpeter](https://github.com/minpeter)).
+- Make task-output lookups non-blocking and document detached-cell state, output, and artifact behavior.
+
+### Fixed
+
+- Preserve Python state when interruption succeeds, report truthful state when it does not, and tolerate kernels predating the interrupt-outcome contract.
+- Stop normal bridge-request completion from aborting still-running host tool calls.
+
+### Removed
+
 ## [2026.7.25-2] - 2026-07-25
 
 ### Breaking Changes

package/README.md

@@ -1,15 +1,19 @@
 # @code-yeongyu/senpi-codemode
 
 `@code-yeongyu/senpi-codemode` is Senpi's source-only Code Mode extension. It
-registers persistent-kernel `eval` for every eligible model and GPT-only
-`exec`/`wait` cells for bounded JavaScript orchestration. `eval` owns one
-persistent kernel per enabled language and re-registers at session start after
-configuration, interpreter availability, and active task-tool names are known.
+registers the persistent-kernel `eval` execution surface for every eligible
+model. `eval` owns one persistent kernel per enabled language and re-registers
+at session start after configuration, interpreter availability, and active
+task-tool names are known.
 
 ## Capabilities
 
 - Persistent JavaScript, Python, Ruby, and Julia cells. State survives later
   cells in the same language until reset, restart, or session disposal.
+- Timeout detachment for interactive `eval`: long pure-compute cells return a
+  handle and continue in their existing kernel. Completion is injected with the
+  final value/error and buffered output; use `eval({ action: "peek"|"stop",
+  cell_id })` to inspect or terminate a detached cell.
 - Loopback, bearer-authenticated kernel bridge with bounded JSONL frames.
 - Structured status events for file operations, environment access, phases,
   bridge activity, and delegated task progress.
@@ -20,8 +24,8 @@ configuration, interpreter availability, and active task-tool names are known.
   fallbacks.
 - JavaScript import rewriting for supported local modules and package imports
   in the persistent Node.js worker.
-- GPT Code Mode `exec`/`wait` cells use fresh JavaScript workers, can compose
-  active tools through `tools.<name>(args)`, and never replace `eval`.
+- GPT models receive a terse `eval` prompt dialect that prioritizes composing
+  active tools through `tool.<name>(args)` and documents detach-on-timeout.
 
 ## Kernels
 
@@ -68,13 +72,13 @@ Configuration is loaded in this order:
 | Key | Default | Effect |
 | --- | --- | --- |
 | `languages` | `py`/`js` enabled; `rb`/`jl` disabled | Selects desired languages before interpreter detection. |
-| `cellTimeoutSeconds` | `30` | Idle timeout for one cell unless the call supplies `timeout`. |
+| `cellTimeoutSeconds` | `30` | Idle timeout for one cell unless the call supplies `timeout`; interactive calls detach by default and print/json calls error. |
 | `parallelPoolWidth` | `4` | Maximum concurrent `parallel()` thunks. |
 | `taskTools.task` | `"task"` | Registered tool name used by `agent()`. |
 | `taskTools.output` | `"task_output"` | Registered tool name used by `output()`. |
 | `outputSink.headBytes` | `20480` | Bytes retained from the beginning of a middle-truncated preview; `0` disables it. |
 | `outputSink.maxColumns` | `768` | Maximum rendered output columns; `0` disables column clamping. |
-| `statusEvents` | `true` | Enables kernel status-event forwarding and rendering. |
+| `statusEvents` | `true` | Enables kernel status-event forwarding and rendering. Each cell retains at most 100 status rows; after overflow, one omitted-count row precedes the latest 99 events. |
 
 `SENPI_CODEMODE_PY`, `SENPI_CODEMODE_JS`, `SENPI_CODEMODE_RB`, and
 `SENPI_CODEMODE_JL` override the corresponding file setting. `1` or `true`
@@ -96,7 +100,7 @@ options object and asynchronous helpers are `await`-able.
 | `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. |
-| `tool.<name>(args)` / `tools.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline. `tools` is the GPT Code Mode spelling. |
+| `tool.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline. |
 | `completion(prompt, model?, system?, schema?)` | Requests a one-shot host completion; `schema` asks the host to parse structured output. |
 | `agent(prompt, ...)` | Delegates to the configured active `taskTools.task` tool. Supports background handles and structured JSON results. |
 | `output(ids, format?, offset?, limit?)` | Delegates transcript retrieval to the configured active `taskTools.output` tool. |
@@ -105,13 +109,31 @@ options object and asynchronous helpers are `await`-able.
 | `log(message)` / `phase(title)` | Emits progress text and starts a status phase. |
 
 `agent()` is available only when the configured task tool is active in the
-session. `output()` similarly requires the configured task-output tool. Missing
-tools produce a clear availability error instead of importing an orchestration
-package. `agent()` delegates through the tool contract, so task-engine
-permissions, progress updates, and transcripts remain owned by that engine.
+session. `output()` similarly requires the configured task-output tool and
+returns immediately: a running task reports its current status, while completed
+tasks return the requested transcript. Missing tools produce a clear
+availability error instead of importing an orchestration package. `agent()`
+delegates through the tool contract, so task-engine permissions, progress
+updates, and transcripts remain owned by that engine.
 `isolated`, `apply`, and `merge` are accepted for compatibility but emit a
 warning because this task-engine integration has no isolation model.
 
+## Detached cells
+
+`eval` accepts `on_timeout: "detach"|"error"`. The default is `"detach"` in
+interactive TUI, RPC, and app-server sessions; print and JSON one-shot runs
+default to `"error"` so their result is never silently detached. A detached
+cell keeps only its own language kernel busy. A new same-language call returns
+a busy error with its cell id and output tail; calls in other languages continue
+normally. Do not re-run the cell.
+
+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://…`.
+
 ## Output and artifacts
 
 Cell output is streamed while the cell runs. Large streams spill to an absolute
@@ -139,11 +161,9 @@ Session generations fence retired kernels and callbacks; each cell settles once
 across completion, errors, cancellation, timeout, bridge failure, or a kernel
 crash.
 
-GPT Code Mode is not an additional sandbox: it uses the same Node worker trust
-boundary as JavaScript `eval`. Its separate cell lifecycle exists so a yielded
-`exec` can be observed or terminated with `wait` without affecting persistent
-`eval` kernels. `eval`, `exec`, and `wait` are excluded from the nested tool
-namespace to prevent recursive Code Mode execution.
+GPT models use the same JavaScript `eval` worker trust boundary as other JavaScript cells;
+there is no separate execution runtime. `eval` is excluded from the nested tool
+namespace to prevent recursive execution.
 
 ## Validation
 
@@ -157,5 +177,5 @@ npm run check
 
 Direct real-surface QA drivers live in `scripts/qa-*.ts`: kernel cells
 (`qa-py-cell.ts`, `qa-js-cell.ts`, `qa-rb-cell.ts`, `qa-jl-cell.ts`), end-to-end
-extension execution (`qa-e2e-eval.ts`, `qa-gpt-code-mode.ts`), and renderer output
+extension execution (`qa-e2e-eval.ts`), and renderer output
 (`qa-render-dump.ts`).

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.7.25-2",
+	"version": "2026.7.26",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "7.29.7",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@^2026.7.25-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@^2026.7.26",
 		"typebox": "1.1.38"
 	},
 	"peerDependencies": {
 		"@code-yeongyu/senpi": "*"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.7.25-2"
+		"@code-yeongyu/senpi": "2026.7.26"
 	},
 	"keywords": [
 		"senpi",

package/src/bridge/http-server.ts

@@ -75,7 +75,12 @@ async function handleRequest(
 	options: BridgeServerOptions,
 ): Promise<void> {
 	const abortController = new AbortController();
-	request.on("close", () => abortController.abort());
+	// IncomingMessage "close" fires on normal message completion in Node >= 16,
+	// so premature disconnect must be detected on the response side instead:
+	// its "close" without a finished response means the connection died mid-call.
+	response.on("close", () => {
+		if (!response.writableFinished) abortController.abort();
+	});
 	if (request.method !== "POST") {
 		sendJson(response, 404, { ok: false, error: transportError("not_found", "Bridge route was not found") });
 		return;

package/src/bridges/output-bridge.ts

@@ -62,7 +62,6 @@ export async function runEvalOutput(args: unknown, options: RunEvalOutputOptions
 					{
 						...(id.startsWith("st_") ? { task_id: id } : { name: id }),
 						mode,
-						block: true,
 					},
 					options.signal === undefined ? undefined : { signal: options.signal },
 				);

package/src/extension/eval-notifier.ts

@@ -0,0 +1,40 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { EvalDetachedCellNotification, EvalDetachedCellNotifier } from "../tool/detached-cell-manager.ts";
+
+const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
+
+export type EvalNotifyMode = "wake" | "next-turn" | "off";
+
+export interface EvalNotifierDeps {
+	readonly sendUserMessage: (content: string, options?: { deliverAs?: "steer" | "followUp" }) => void;
+	readonly getContext: () => ExtensionContext | undefined;
+	readonly getMode: () => EvalNotifyMode;
+}
+
+/** Session-scoped completion injector with the same no-spin guards as terminal notifications. */
+export class EvalNotifier implements EvalDetachedCellNotifier {
+	readonly #deps: EvalNotifierDeps;
+	readonly #notified = new Set<string>();
+
+	constructor(deps: EvalNotifierDeps) {
+		this.#deps = deps;
+	}
+
+	/** Starts a fresh session generation without suppressing reused tool-call ids. */
+	reset(): void {
+		this.#notified.clear();
+	}
+
+	notify(cells: readonly EvalDetachedCellNotification[]): void {
+		const mode = this.#deps.getMode();
+		if (mode === "off") return;
+		const ctx = this.#deps.getContext();
+		if (ctx === undefined || NON_INTERACTIVE_MODES.has(ctx.mode) || ctx.model === undefined) return;
+		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",
+		});
+	}
+}

package/src/index.ts

@@ -1,10 +1,9 @@
 import * as os from "node:os";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
-import { CodeModeSessionRuntime } from "./codemode/runtime.ts";
-import { type CodeModeTool, createCodeModeTools, isGptCodeModeModel } from "./codemode/tools.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
 import { defaultCodemodeSettings } from "./config/settings.ts";
+import { EvalNotifier } from "./extension/eval-notifier.ts";
 import {
 	createExecuteTool,
 	createRuntime,
@@ -13,6 +12,7 @@ import {
 } from "./extension/runtime-factory.ts";
 import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from "./extension/session-manager.ts";
 import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
+import { EvalDetachedCellManager } from "./tool/detached-cell-manager.ts";
 import { createEvalTool } from "./tool/eval-tool.ts";
 import { renderEvalCall, renderEvalResult } from "./tool/render.ts";
 
@@ -29,11 +29,11 @@ type CodemodeEvent = SessionLifecycleEvent | "model_select";
 
 export interface CodemodeExtensionAPI {
 	registerTool(tool: ReturnType<typeof createEvalTool>): void;
+	registerRemovedToolHint(name: string, hint: string): void;
 	on(event: CodemodeEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
 	executeTool: AgentExecuteTool;
 	getActiveTools(): string[];
-	setActiveTools?(toolNames: string[]): void | Promise<void>;
-	getAllTools?(): readonly { readonly name: string }[];
+	sendUserMessage(content: string, options?: { deliverAs?: "steer" | "followUp" }): void;
 }
 
 export interface SenpiCodemodeOptions {
@@ -43,19 +43,24 @@ export interface SenpiCodemodeOptions {
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 }
 
-type DynamicCodeModeExtensionAPI = CodemodeExtensionAPI & {
-	registerTool(tool: CodeModeTool): void;
-	setActiveTools(toolNames: string[]): void | Promise<void>;
-	getAllTools(): readonly { readonly name: string }[];
-};
-
 export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
 	const renderers = { renderCall: renderEvalCall, renderResult: renderEvalResult };
-	let activeRuntime: (SessionRuntime & { readonly codeMode?: CodeModeSessionRuntime }) | undefined;
+	let activeRuntime: SessionRuntime | undefined;
 	let activeModelId: string | undefined;
-	const registerEvalForRuntime = (runtime: SessionRuntime, modelId: string | undefined): void => {
+	let activeContext: ExtensionContext | undefined;
+	let activeCells: EvalDetachedCellManager | undefined;
+	const notifier = new EvalNotifier({
+		sendUserMessage: (content, notifyOptions) => pi.sendUserMessage(content, notifyOptions),
+		getContext: () => activeContext,
+		getMode: () => "wake",
+	});
+	const registerEvalForRuntime = (
+		runtime: SessionRuntime,
+		modelId: string | undefined,
+		cellManager: EvalDetachedCellManager,
+	): void => {
 		pi.registerTool(
 			createEvalTool({
 				enabledLanguages: runtime.enabledLanguages,
@@ -65,6 +70,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 				complete,
 				settings: runtime.settings,
 				artifactsDir: runtime.artifactsDir,
+				cellManager,
 				executionTracker: manager,
 				renderers,
 				spawns: runtime.spawns,
@@ -75,21 +81,13 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		);
 	};
 	const dropRuntime = async (): Promise<void> => {
-		const codeMode = activeRuntime?.codeMode;
+		const cells = activeCells;
 		activeRuntime = undefined;
 		activeModelId = undefined;
-		await Promise.all([manager.dispose(), codeMode?.dispose()]);
-	};
-	const activateCodeModeTools = async (runtime: CodeModeSessionRuntime): Promise<void> => {
-		if (!isDynamicCodeModeExtensionAPI(pi)) return;
-		const tools = createCodeModeTools({ runtime });
-		pi.registerTool(tools.exec);
-		pi.registerTool(tools.wait);
-		await pi.setActiveTools([...new Set([...pi.getActiveTools(), "exec", "wait"])]);
-	};
-	const deactivateCodeModeTools = async (): Promise<void> => {
-		if (!isDynamicCodeModeExtensionAPI(pi)) return;
-		await pi.setActiveTools(pi.getActiveTools().filter((name) => name !== "exec" && name !== "wait"));
+		activeCells = undefined;
+		await cells?.dispose();
+		activeContext = undefined;
+		await manager.dispose();
 	};
 	pi.registerTool(
 		createEvalTool({
@@ -99,71 +97,53 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			executeTool: createExecuteTool(pi),
 			complete,
 			settings: defaultCodemodeSettings,
+			cellManager: new EvalDetachedCellManager({ notifier }),
 			executionTracker: manager,
 			renderers,
 			hostLine: hostLine(),
 		}),
 	);
+	pi.registerRemovedToolHint(
+		"exec",
+		'exec was removed; use eval({ language: "js", code }) instead. Long eval cells detach on timeout and notify when complete.',
+	);
+	pi.registerRemovedToolHint(
+		"wait",
+		'wait was removed; detached eval cells notify when complete. Use eval({ action: "peek"|"stop", cell_id }) to inspect or stop one.',
+	);
 
 	pi.on("session_start", async (event, ctx) => {
-		const previousCodeMode = activeRuntime?.codeMode;
+		const previousCells = activeCells;
+		activeCells = undefined;
+		await previousCells?.dispose();
 		const generation = manager.beginReplacement();
 		const runtime = await createRuntime(pi, ctx, event, complete, options);
 		const replaced = await manager.replace(generation, runtime.manager);
 		if (!replaced) return;
-		await previousCodeMode?.dispose();
-		const codeMode = isGptCodeModeModel(ctx.model?.id)
-			? new CodeModeSessionRuntime({
-					sessionId: runtime.sessionId,
-					cwd: runtime.cwd,
-					parallelPoolWidth: runtime.parallelPoolWidth,
-					executeTool: runtime.executeTool,
-				})
-			: undefined;
-		activeRuntime = { ...runtime, ...(codeMode === undefined ? {} : { codeMode }) };
+		notifier.reset();
+		activeContext = ctx;
+		const cellManager = new EvalDetachedCellManager({ artifactsDir: runtime.artifactsDir, notifier });
+		activeCells = cellManager;
+		activeRuntime = runtime;
 		activeModelId = ctx.model?.id;
-		registerEvalForRuntime(activeRuntime, activeModelId);
-		if (codeMode) await activateCodeModeTools(codeMode);
-		else await deactivateCodeModeTools();
+		registerEvalForRuntime(runtime, activeModelId, cellManager);
 	});
 	pi.on("session_shutdown", async () => dropRuntime());
 	pi.on("session_before_switch", async () => dropRuntime());
 	pi.on("session_before_fork", async () => dropRuntime());
-	pi.on("model_select", async (event) => {
+	pi.on("model_select", async (event, ctx) => {
+		activeContext = ctx;
 		const runtime = activeRuntime;
 		if (runtime === undefined) return;
 		const modelId = modelIdFrom(event);
 		if (modelId === undefined || modelId === activeModelId) return;
 		activeModelId = modelId;
-		registerEvalForRuntime(runtime, modelId);
-		if (!isGptCodeModeModel(modelId)) {
-			const { codeMode, ...nextRuntime } = runtime;
-			await codeMode?.dispose();
-			activeRuntime = nextRuntime;
-			await deactivateCodeModeTools();
-			return;
-		}
-		if (runtime.codeMode) {
-			if (isDynamicCodeModeExtensionAPI(pi)) {
-				await pi.setActiveTools([...new Set([...pi.getActiveTools(), "exec", "wait"])]);
-			}
-			return;
-		}
-		const codeMode = new CodeModeSessionRuntime({
-			sessionId: runtime.sessionId,
-			cwd: runtime.cwd,
-			parallelPoolWidth: runtime.parallelPoolWidth,
-			executeTool: runtime.executeTool,
-		});
-		activeRuntime = { ...runtime, codeMode };
-		await activateCodeModeTools(codeMode);
+		const cellManager = activeCells;
+		if (cellManager === undefined) return;
+		registerEvalForRuntime(runtime, modelId, cellManager);
 	});
 }
 
-function isDynamicCodeModeExtensionAPI(pi: CodemodeExtensionAPI): pi is DynamicCodeModeExtensionAPI {
-	return typeof pi.setActiveTools === "function" && typeof pi.getAllTools === "function";
-}
-
 function hostLine(): string {
 	const cpu = os.cpus()[0]?.model?.trim();
 	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`]

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

@@ -1,4 +1,5 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelInterruptHandle } from "../../tool/types.ts";
 import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
 import {
 	assertJavaScriptKernelOpen,
@@ -48,14 +49,16 @@ export class JavaScriptKernel {
 		return await promise;
 	}
 
-	async interrupt(reason = "interrupted"): Promise<void> {
+	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "interrupt");
 		const active = this.#runs.active;
 		const target = this.#runs.takeInterruptTarget();
-		if (!target) return;
+		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) };
 	}
 
 	async reset(): Promise<void> {

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

@@ -29,4 +29,6 @@ export interface PendingRun {
 	timeoutTimer: NodeJS.Timeout | null;
 	escalationTimer?: NodeJS.Timeout;
 	interruptReason?: string;
+	/** Set while an interrupt outcome is pending; resolved once the kernel knows whether state survived. */
+	resolveStateRetained?: (retained: boolean) => void;
 }

package/src/kernels/py/kernel.ts

@@ -1,3 +1,4 @@
+import type { KernelInterruptHandle } from "../../tool/types.ts";
 import type { PendingRun, PythonKernelRunOptions, PythonKernelStartOptions, ResultMessage } from "./kernel-contract.ts";
 import { failedPythonResult, PythonKernelTransport } from "./transport.ts";
 
@@ -41,7 +42,7 @@ export class PythonKernel {
 		});
 	}
 
-	async interrupt(reason = "interrupted"): Promise<void> {
+	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
 		if (this.#failure) throw this.#failure;
 		for (const pending of [...this.#queue]) {
 			pending.interruptReason = reason;
@@ -49,7 +50,8 @@ export class PythonKernel {
 		}
 		const active = this.#active;
 		const transport = this.#transport;
-		if (!active || !transport || active.interruptReason !== undefined) return;
+		if (!active || !transport || active.interruptReason !== undefined)
+			return { stateRetained: Promise.resolve(true) };
 		active.interruptReason = reason;
 		if (active.timeoutTimer) clearTimeout(active.timeoutTimer);
 		active.timeoutTimer = null;
@@ -57,7 +59,11 @@ export class PythonKernel {
 			() => void this.#escalateInterruptedRun(active).catch(() => undefined),
 			interruptEscalationMs,
 		);
+		const stateRetained = new Promise<boolean>((resolve) => {
+			active.resolveStateRetained = resolve;
+		});
 		transport.interrupt(reason);
+		return { stateRetained };
 	}
 
 	async reset(): Promise<void> {
@@ -187,13 +193,18 @@ export class PythonKernel {
 		if (this.#transport !== transport) return;
 		const pending = this.#pending.get(result.cellId);
 		if (pending) this.#settleRun(pending, result);
+		// A result frame from the live runner proves the process survived the interrupt.
+		if (pending?.resolveStateRetained) pending.resolveStateRetained(true);
 	}
 
 	#onExit(transport: PythonKernelTransport, error: Error): void {
 		if (this.#transport !== transport) return;
 		this.#transport = null;
 		const active = this.#active;
-		if (active) this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+		if (active) {
+			if (active.resolveStateRetained) active.resolveStateRetained(false);
+			this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+		}
 		this.#startNext();
 	}
 
@@ -209,7 +220,10 @@ export class PythonKernel {
 			},
 		);
 		const active = this.#active;
-		if (active) this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+		if (active) {
+			if (active.resolveStateRetained) active.resolveStateRetained(false);
+			this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+		}
 	}
 
 	#settleRun(pending: PendingRun, result: ResultMessage): void {
@@ -258,6 +272,7 @@ export class PythonKernel {
 	async #escalateInterruptedRun(pending: PendingRun): Promise<void> {
 		if (this.#active !== pending || pending.interruptReason === undefined) return;
 		const transport = this.#transport;
+		if (pending.resolveStateRetained) pending.resolveStateRetained(false);
 		if (transport) await this.#beginRetirement(transport);
 		if (this.#pending.has(pending.input.cellId))
 			this.#settleRun(pending, failedPythonResult(pending.input.cellId, "Eval interrupted"));

package/src/kernels/py/prelude.py

@@ -12,6 +12,7 @@ import json
 import locale
 import os
 import re
+import signal
 import subprocess
 import sys
 import time
@@ -886,6 +887,9 @@ def run_cell(cell_id: str, code: str) -> None:
     start = time.monotonic()
     stdout = io.StringIO()
     stderr = io.StringIO()
+    # SIGINT must interrupt user code here; the idle baseline (set between
+    # cells) ignores it so a late signal cannot kill the stdin-read loop.
+    signal.signal(signal.SIGINT, signal.default_int_handler)
     try:
         with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
             body, expression = compile_cell(code)
@@ -914,6 +918,8 @@ def run_cell(cell_id: str, code: str) -> None:
                 "durationMs": elapsed(start),
             }
         )
+    finally:
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
 
 
 def elapsed(start: float) -> int:
@@ -942,6 +948,7 @@ def handle(message: dict[str, Any]) -> bool:
 
 
 def main() -> None:
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
     for raw in sys.stdin:
         try:
             if not handle(json.loads(raw)):

package/src/kernels/shared/subprocess-kernel.ts

@@ -1,5 +1,6 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelInterruptHandle } from "../../tool/types.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
 import { SubprocessRunQueue } from "./subprocess-queue.ts";
@@ -44,24 +45,26 @@ export class SubprocessKernel {
 		return run;
 	}
 
-	async interrupt(reason = "interrupted"): Promise<void> {
-		if (this.closed) return;
+	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
+		if (this.closed) return { stateRetained: Promise.resolve(true) };
 		if (!this.runs.active) {
-			if (!this.retirementPromise) return;
+			if (!this.retirementPromise) return { stateRetained: Promise.resolve(true) };
 			const queued = this.runs.takeWaiting();
 			if (queued) this.runs.settle(queued, failureResult(queued, new CellInterruptedError(reason)));
-			return;
+			return { stateRetained: Promise.resolve(true) };
 		}
 		const process = this.process;
 		process?.retire();
 		this.runs.clearToolCalls();
 		const run = this.runs.active;
-		if (!run) return;
+		if (!run) return { stateRetained: Promise.resolve(true) };
 		this.runs.releaseActive(run);
 		this.runs.settle(run, failureResult(run, new CellInterruptedError(reason)));
 		const signal = globalThis.process.platform === "win32" ? "SIGTERM" : "SIGINT";
 		await this.restartProcess(process, signal, 5_000);
 		if (this.failure) throw this.failure;
+		// Restart always spawns a fresh interpreter, so no user global survives.
+		return { stateRetained: Promise.resolve(false) };
 	}
 
 	nextToolCall(): Promise<ToolCallMessage> {