@code-yeongyu/senpi-codemode 2026.10.3 → 2026.10.5

package/CHANGELOG.md

@@ -12,6 +12,38 @@
 
 ### Removed
 
+## [2026.10.5] - 2026-10-03
+
+### Breaking Changes
+
+### Added
+
+- Eval kernels expose the session's `OMO_BROWSER_ENGINE` and clear a value inherited from the host process for a session that chose no engine ([#2611](https://github.com/code-yeongyu/senpi/issues/2611)).
+- A Python, Ruby, or Julia eval kernel whose interpreter dies is replaced once instead of failing every later cell: Ruby and Julia no longer stay closed after a crash, and a Python kernel whose stuck interpreter finally exits recovers instead of rejecting every cell. Cells queued behind the death keep their order and run on the replacement, whose first result says `[<language> kernel was restarted after <reason>; every global is lost]`; the cell that was running fails once and is never re-run, and a replacement that dies before finishing a cell fails the queued cells with `eval_kernel_unavailable` ([#2452](https://github.com/code-yeongyu/senpi/issues/2452))
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.10.4] - 2026-10-03
+
+### Breaking Changes
+
+### Added
+
+- Every live eval kernel in a process is listed in a process-wide registry with its session, language, measure, and last-known memory reading; a JavaScript kernel keeps the heap reading from each result and idle collection and answers an on-demand heap query between cells without running one, while Python, Ruby, and Julia kernels report their interpreter's footprint on demand. Thresholds, notices, and the result frame are unchanged ([#2561](https://github.com/code-yeongyu/senpi/issues/2561)).
+
+- An eval regression gate records the full prompt and schema surfaces, helper witnesses across five required runtime legs, codemode-scoped eager imports, measured teardown resources (including global, named-import, promise and AbortSignal timers, named by creation site) and legacy contract results against a frozen baseline. CI provisions every interpreter and publishes the report; unrelated host imports and slow child startup cannot cause a regression failure. ([#2452](https://github.com/code-yeongyu/senpi/issues/2452))
+
+- Added an interleaved eval timing benchmark that judges each runtime, workload and metric on adjacent base/head pairs against its own A/A-calibrated threshold (capped at 5%, or one shared band with `--band-scope global`), with process CPU accounting across interpreter crashes, a per-row minimum detectable effect, and explicit inconclusive results for incomplete, host-contaminated or noise-limited comparisons. ([#2452](https://github.com/code-yeongyu/senpi/issues/2452))
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.10.3] - 2026-10-03
 
 ### Breaking Changes

package/README.md

@@ -339,6 +339,17 @@ bash tool for long-running commands you may want to stop. Native `Bun.$`
 cancellation is tracked in [Bun #11868](https://github.com/oven-sh/bun/issues/11868);
 the shell's interpretation and object redirects are not replaced.
 
+When a Python, Ruby, or Julia interpreter dies on its own (a crash, an OOM kill,
+`os.kill(os.getpid(), 9)`), the cell it was running fails once and is never run
+again: its side effects may already have happened. Cells queued behind it keep
+their order, callbacks, and deadlines and run on one fresh interpreter started
+for that death; the first result there carries
+`[<language> kernel was restarted after <reason>; every global is lost]`. If the
+fresh interpreter dies too before it finished a cell, the queued cells fail with
+`eval_kernel_unavailable` naming the reason, and the next cell you run starts
+another. An interpreter whose exit cannot be confirmed is reported, never
+replaced by a second one. The JavaScript worker keeps its own restart path.
+
 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`,
@@ -425,6 +436,12 @@ bun run --cwd packages/senpi-codemode gate --target <base-checkout> \
   --baseline test/gate/baseline.json --write-baseline
 ```
 
+Record with the canonical runtimes, so the baseline's runtime observations do not
+flip between recordings: Bun 1.4.2, Python 3.14, Julia 1.12 and Ruby 4.x from
+Homebrew (put `/opt/homebrew/opt/ruby/bin` first on `PATH`; macOS's system Ruby
+2.6 records a different runtime). Check `ruby --version` and `python3 --version`
+before `--write-baseline`.
+
 The report is gitignored `gate-report.json` by default (`--report <path>` overrides it).
 `test/gate/allowlist.json` contains reviewed additive changes keyed by plan node;
 it cannot authorize removal or modification of a legacy entry. The test-only

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.10.3",
+	"version": "2026.10.5",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -17,6 +17,7 @@
 	],
 	"scripts": {
 		"gate": "bun scripts/gate-eval.ts",
+		"bench": "bun scripts/bench-eval.ts",
 		"test": "vitest run test/",
 		"clean": "node -e \"\"",
 		"build": "node -e \"\""
@@ -31,14 +32,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.3",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.5",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.10.3"
+		"@code-yeongyu/senpi": "2026.10.5"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.10.3"
+		"@code-yeongyu/senpi": "2026.10.5"
 	},
 	"keywords": [
 		"senpi",

package/src/bridge/memory-protocol.ts

@@ -34,6 +34,20 @@ export const kernelMemoryReportSchema = Type.Object({
 	notice: Type.Optional(Type.String()),
 });
 
+/** On-demand heap reading between cells (JS kernels): no cell runs and no collection is forced. */
+export const kernelMemoryQueryHostToKernelSchemas = [
+	Type.Object({ type: Type.Literal("memory-query"), requestId: Type.String({ minLength: 1 }) }),
+] as const;
+
+export const kernelMemoryQueryKernelToHostSchemas = [
+	Type.Object({
+		type: Type.Literal("memory-query-result"),
+		requestId: Type.String({ minLength: 1 }),
+		liveBytes: Type.Integer({ minimum: 0 }),
+		measure: Type.Literal("heap"),
+	}),
+] as const;
+
 export type KernelMemoryThresholds = Static<typeof kernelMemoryThresholdsSchema>;
 export type KernelMemoryReport = Static<typeof kernelMemoryReportSchema>;
 export type KernelMemoryGlobal = Static<typeof kernelMemoryGlobalSchema>;

package/src/bridge/protocol.ts

@@ -2,7 +2,12 @@ import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypt
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
 import { kernelToolHostToKernelSchemas, kernelToolKernelToHostSchemas } from "./kernel-tools-protocol.ts";
-import { kernelMemoryReportSchema, kernelMemoryThresholdsSchema } from "./memory-protocol.ts";
+import {
+	kernelMemoryQueryHostToKernelSchemas,
+	kernelMemoryQueryKernelToHostSchemas,
+	kernelMemoryReportSchema,
+	kernelMemoryThresholdsSchema,
+} from "./memory-protocol.ts";
 
 export const BRIDGE_FRAME_MAX_BYTES = 10 * 1024 * 1024;
 
@@ -82,8 +87,15 @@ const hostToKernelMessageSchema = Type.Union([
 		error: bridgeErrorSchema,
 	}),
 	...kernelToolHostToKernelSchemas,
+	...kernelMemoryQueryHostToKernelSchemas,
 ]);
 
+/**
+ * Host-set: what a kernel death did to this cell's state. `lost`: the interpreter died while it ran;
+ * `restarted`: it ran on a kernel replaced after a death; `not-run`: it was failed without running.
+ */
+const kernelStateSchema = Type.Union([Type.Literal("lost"), Type.Literal("restarted"), Type.Literal("not-run")]);
+
 const kernelToHostMessageSchema = Type.Union([
 	Type.Object({ type: Type.Literal("ready") }),
 	Type.Object({ type: Type.Literal("init-failed"), error: bridgeErrorSchema }),
@@ -113,6 +125,9 @@ const kernelToHostMessageSchema = Type.Union([
 		valueRepr: Type.Optional(Type.String()),
 		durationMs: Type.Integer({ minimum: 0 }),
 		memory: Type.Optional(kernelMemoryReportSchema),
+		/** Host-set: the bracketed notice that this cell ran on a kernel restarted after its interpreter died. */
+		notice: Type.Optional(Type.String()),
+		kernelState: Type.Optional(kernelStateSchema),
 	}),
 	Type.Object({
 		type: Type.Literal("result"),
@@ -121,10 +136,13 @@ const kernelToHostMessageSchema = Type.Union([
 		error: bridgeErrorSchema,
 		durationMs: Type.Integer({ minimum: 0 }),
 		memory: Type.Optional(kernelMemoryReportSchema),
+		notice: Type.Optional(Type.String()),
+		kernelState: Type.Optional(kernelStateSchema),
 	}),
 	Type.Object({ type: Type.Literal("closed") }),
 	Type.Object({ type: Type.Literal("webview-connect"), requestId: Type.String({ minLength: 1 }) }),
 	...kernelToolKernelToHostSchemas,
+	...kernelMemoryQueryKernelToHostSchemas,
 ]);
 
 const bridgeMessageSchema = Type.Union([hostToKernelMessageSchema, kernelToHostMessageSchema]);

package/src/extension/kernel-registration.ts

@@ -0,0 +1,96 @@
+import { readProcessFootprint } from "@code-yeongyu/senpi";
+import type { KernelMemoryThresholds } from "../bridge/memory-protocol.ts";
+import type { BridgeConnectionConfig, KernelToHostMessage } from "../bridge/protocol.ts";
+import { JuliaKernel } from "../kernels/jl/kernel.ts";
+import type { JavaScriptKernel } from "../kernels/js/context-manager.ts";
+import { PythonKernel } from "../kernels/py/kernel.ts";
+import { defaultSpawn } from "../kernels/py/process.ts";
+import { RubyKernel } from "../kernels/rb/kernel.ts";
+import type { SessionEnvironment } from "../kernels/session-env.ts";
+import { spawnSubprocess } from "../kernels/shared/subprocess-process.ts";
+import type { EvalKernel, EvalLanguage } from "../tool/types.ts";
+import { type KernelMemoryReading, kernelRegistry, type RegisteredKernelSource } from "./kernel-registry.ts";
+
+export interface StartedKernel {
+	readonly kernel: EvalKernel;
+	readonly memory: RegisteredKernelSource;
+}
+
+export interface SubprocessKernelStart {
+	readonly language: Exclude<EvalLanguage, "js">;
+	readonly interpreterPath: string;
+	readonly memory: KernelMemoryThresholds;
+	readonly shared: {
+		readonly sessionId: string;
+		readonly cwd: string;
+		readonly sessionEnv?: SessionEnvironment;
+		readonly connection: BridgeConnectionConfig;
+		readonly onMessage: (message: KernelToHostMessage) => void;
+	};
+}
+
+export function registerKernel(sessionId: string, language: EvalLanguage, memory: RegisteredKernelSource): string {
+	const id = crypto.randomUUID();
+	kernelRegistry.register({ id, sessionId, language, source: memory });
+	return id;
+}
+
+export function javaScriptKernelMemory(kernel: JavaScriptKernel): RegisteredKernelSource {
+	return {
+		measure: "heap",
+		lastLiveBytes: () => kernel.lastLiveBytes,
+		busy: () => kernel.queueSnapshot().activeCellId !== null,
+		queryMemory: () => kernel.queryMemory(),
+	};
+}
+
+/**
+ * Starts a py/rb/jl kernel through a spawn that remembers its interpreter's pid, so the registry can read
+ * that process's footprint on demand; a restarted interpreter replaces the pid.
+ */
+export async function startSubprocessKernel(start: SubprocessKernelStart): Promise<StartedKernel> {
+	let pid: number | undefined;
+	const { shared, memory } = start;
+	let kernel: EvalKernel;
+	if (start.language === "py") {
+		kernel = await PythonKernel.start({
+			...shared,
+			interpreterPath: start.interpreterPath,
+			memory,
+			spawnProcess: (options) => {
+				const child = defaultSpawn(options);
+				pid = child.pid;
+				return child;
+			},
+		});
+	} else {
+		// rb/jl runners report no memory: the host reads the interpreter footprint for the ceiling only.
+		const options = {
+			...shared,
+			command: start.interpreterPath,
+			memory: { thresholds: memory, readFootprint: readProcessFootprint },
+			spawn: (command: string, args: readonly string[], spawnOptions: { cwd?: string; env?: NodeJS.ProcessEnv }) => {
+				const child = spawnSubprocess(undefined, { command, args, ...spawnOptions });
+				pid = child.pid;
+				return child;
+			},
+		};
+		kernel = start.language === "rb" ? RubyKernel.start(options) : JuliaKernel.start(options);
+	}
+	return { kernel, memory: footprintMemory(kernel, () => pid) };
+}
+
+function footprintMemory(kernel: EvalKernel, pid: () => number | undefined): RegisteredKernelSource {
+	const read = (): KernelMemoryReading | undefined => {
+		const current = pid();
+		const footprint = current === undefined ? undefined : readProcessFootprint(current);
+		return footprint === undefined ? undefined : { liveBytes: Math.round(footprint.bytes), measure: "footprint" };
+	};
+	return {
+		measure: "footprint",
+		lastLiveBytes: () => read()?.liveBytes,
+		busy: () => kernel.queueSnapshot().activeCellId !== null,
+		queryMemory: async () => read(),
+		pid,
+	};
+}

package/src/extension/kernel-registry.ts

@@ -0,0 +1,105 @@
+import type { EvalLanguage } from "../tool/types.ts";
+
+/** `heap`: a JS worker's own heap estimate; `footprint`: the interpreter process's memory footprint. */
+export type KernelMeasure = "heap" | "footprint";
+
+export interface KernelMemoryReading {
+	readonly liveBytes: number;
+	readonly measure: KernelMeasure;
+}
+
+/**
+ * What the registry reads from a live kernel. It is backed by the kernel object, not its worker or
+ * process, so a kernel that restarts its worker (ceiling, crash, reset) keeps its registry entry.
+ */
+export interface RegisteredKernelSource {
+	readonly measure: KernelMeasure;
+	/** The last reading the host holds, without asking the kernel; `undefined` before the first one. */
+	lastLiveBytes(): number | undefined;
+	/** A cell is running, so the last reading may predate what the kernel holds now. */
+	busy(): boolean;
+	/** A fresh reading taken without running a cell; `undefined` when no worker or process is live. */
+	queryMemory(): Promise<KernelMemoryReading | undefined>;
+	pid?(): number | undefined;
+}
+
+export interface KernelRegistration {
+	readonly id: string;
+	readonly sessionId: string;
+	readonly language: EvalLanguage;
+	readonly source: RegisteredKernelSource;
+}
+
+export interface KernelListing {
+	readonly id: string;
+	readonly sessionId: string;
+	readonly language: EvalLanguage;
+	readonly measure: KernelMeasure;
+	readonly lastLiveBytes?: number;
+	readonly busy: boolean;
+	readonly pid?: number;
+}
+
+export interface KernelRegistry {
+	register(kernel: KernelRegistration): void;
+	unregister(id: string): boolean;
+	list(): KernelListing[];
+	lastLiveBytes(id: string): number | undefined;
+	query(id: string): Promise<KernelMemoryReading | undefined>;
+}
+
+// One registry per process, whichever copy of this module asks: the extension loader can evaluate the
+// codemode module graph more than once in a process, and the host's memory report reads the same key.
+const REGISTRY_KEY = Symbol.for("senpi.codemode.kernel-registry");
+
+function createKernelRegistry(): KernelRegistry {
+	const kernels = new Map<string, KernelRegistration>();
+	return {
+		register(kernel) {
+			kernels.set(kernel.id, kernel);
+		},
+		unregister(id) {
+			return kernels.delete(id);
+		},
+		list() {
+			return [...kernels.values()].map(listing);
+		},
+		lastLiveBytes(id) {
+			return kernels.get(id)?.source.lastLiveBytes();
+		},
+		async query(id) {
+			return await kernels.get(id)?.source.queryMemory();
+		},
+	};
+}
+
+function listing({ id, sessionId, language, source }: KernelRegistration): KernelListing {
+	const lastLiveBytes = source.lastLiveBytes();
+	const pid = source.pid?.();
+	return {
+		id,
+		sessionId,
+		language,
+		measure: source.measure,
+		busy: source.busy(),
+		...(lastLiveBytes === undefined ? {} : { lastLiveBytes }),
+		...(pid === undefined ? {} : { pid }),
+	};
+}
+
+function isKernelRegistry(value: unknown): value is KernelRegistry {
+	if (typeof value !== "object" || value === null) return false;
+	return ["register", "unregister", "list", "lastLiveBytes", "query"].every(
+		(name) => typeof Reflect.get(value, name) === "function",
+	);
+}
+
+function processKernelRegistry(): KernelRegistry {
+	const existing: unknown = Reflect.get(globalThis, REGISTRY_KEY);
+	if (isKernelRegistry(existing)) return existing;
+	const created = createKernelRegistry();
+	Reflect.set(globalThis, REGISTRY_KEY, created);
+	return created;
+}
+
+export const kernelRegistry: KernelRegistry = processKernelRegistry();

package/src/extension/kernel-replacement.ts

@@ -0,0 +1,230 @@
+import type { HostToKernelMessage } from "../bridge/protocol.ts";
+import {
+	type KernelLifecycle,
+	KernelUnavailableError,
+	restartNotice,
+	unstartedResult,
+} from "../kernels/shared/kernel-death.ts";
+import type {
+	EvalKernel,
+	EvalKernelResult,
+	EvalKernelRunInput,
+	EvalLanguage,
+	KernelInterruptHandle,
+	PendingCell,
+} from "../tool/types.ts";
+
+export type StartKernel = (lifecycle: Required<KernelLifecycle>) => Promise<EvalKernel>;
+
+class ReplaceableKernelClosedError extends Error {
+	readonly name = "ReplaceableKernelClosedError";
+
+	constructor() {
+		super("Kernel closed");
+	}
+}
+
+/**
+ * The one kernel a session holds for a language whose instances can die (py, rb, jl). Every caller keeps
+ * this object for the life of a cell - its handler, its execution, its detached record - so a death never
+ * strands them: on the instance's own death event this evicts it, takes back the cells that never started,
+ * starts ONE replacement and runs them there in their original order, with their own callbacks. The first
+ * result of the replacement says the kernel was restarted. A replacement that dies before it finished a
+ * cell is not replaced again for the same cells: they fail with `eval_kernel_unavailable`, and the next
+ * cell submitted starts a fresh one. The cell that was running when the interpreter died is never re-run.
+ */
+export class ReplaceableKernel implements EvalKernel {
+	readonly #language: EvalLanguage;
+	readonly #start: StartKernel;
+	#kernel: EvalKernel;
+	#generation = 0;
+	#nextGeneration = 0;
+	#held: PendingCell[] = [];
+	#replacing: Promise<void> | null = null;
+	/** The death the current instance replaced, until that instance settled a cell of its own. */
+	#recovering: string | null = null;
+	/** A death whose cells were failed instead of replaced: the next cell's fresh instance announces it. */
+	#unannounced: string | null = null;
+	/** Carried by the first result the current replacement produces. */
+	#announce: string | null = null;
+	#closed = false;
+	#closeFailure: unknown;
+
+	private constructor(language: EvalLanguage, start: StartKernel, first: EvalKernel) {
+		this.#language = language;
+		this.#start = start;
+		this.#kernel = first;
+	}
+
+	/** Starts the first instance; one that cannot hand back its queue is returned as it is. */
+	static async create(language: EvalLanguage, start: StartKernel): Promise<EvalKernel> {
+		let owner: ReplaceableKernel | undefined;
+		const first = await start({
+			onDeath: (reason) => {
+				if (owner !== undefined) owner.#died(0, reason);
+			},
+		});
+		if (first.drainPending === undefined) return first;
+		owner = new ReplaceableKernel(language, start, first);
+		return owner;
+	}
+
+	run(input: EvalKernelRunInput): Promise<EvalKernelResult> {
+		if (this.#closed) return Promise.reject(new ReplaceableKernelClosedError());
+		if (this.#replacing === null && this.#kernel.isAlive?.() !== false) {
+			return this.#submit(this.#generation, this.#kernel, input);
+		}
+		return new Promise((settle) => {
+			this.#held.push({ input, settle });
+			this.#ensureReplacement();
+		});
+	}
+
+	cancelQueued(cellId: string, reason: string): boolean {
+		return this.#cancelHeld(cellId, reason) || this.#kernel.cancelQueued(cellId, reason);
+	}
+
+	async interrupt(reason = "interrupted", cellId?: string): Promise<KernelInterruptHandle> {
+		if (cellId !== undefined && this.#cancelHeld(cellId, reason)) return { stateRetained: Promise.resolve(true) };
+		if (cellId === undefined) this.#failHeld(reason === "Eval interrupted" ? reason : `Eval interrupted: ${reason}`);
+		return await this.#kernel.interrupt(reason, cellId);
+	}
+
+	queueSnapshot(): { activeCellId: string | null; queuedCellIds: readonly string[] } {
+		const current = this.#kernel.queueSnapshot();
+		return {
+			activeCellId: current.activeCellId,
+			queuedCellIds: [...current.queuedCellIds, ...this.#held.map((cell) => cell.input.cellId)],
+		};
+	}
+
+	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void {
+		this.#kernel.deliverToolReply(message);
+	}
+
+	async reset(): Promise<void> {
+		if (this.#replacing !== null) await this.#replacing;
+		if (this.#kernel.isAlive?.() === false) {
+			// A reset discards every global anyway, so the fresh instance announces nothing.
+			this.#unannounced = null;
+			const replacing = this.#replace(null);
+			this.#replacing = replacing;
+			await replacing;
+			if (this.#replacing === replacing) this.#replacing = null;
+			return;
+		}
+		await this.#kernel.reset();
+	}
+
+	async close(): Promise<void> {
+		this.#closed = true;
+		const held = this.#held.splice(0);
+		for (const cell of held)
+			cell.settle(unstartedResult(cell.input.cellId, new ReplaceableKernelClosedError().message));
+		if (this.#replacing !== null) await this.#replacing;
+		if (this.#closeFailure !== undefined) throw this.#closeFailure;
+		await this.#kernel.close();
+	}
+
+	listKernelToolNames(): readonly string[] {
+		return this.#kernel.listKernelToolNames?.() ?? [];
+	}
+
+	#submit(generation: number, kernel: EvalKernel, input: EvalKernelRunInput): Promise<EvalKernelResult> {
+		return kernel.run(input).then((result) => {
+			if (generation !== this.#generation) return result;
+			// The result the kernel settled for the cell its death interrupted proves nothing about the
+			// replacement; a result from a still-live current instance proves it works.
+			// A drained cell settles through this same promise already tagged; only the interrupted one is `lost`.
+			if (kernel.isAlive?.() === false)
+				return result.kernelState === undefined ? { ...result, kernelState: "lost" } : result;
+			this.#recovering = null;
+			const notice = this.#announce;
+			if (notice === null) return result;
+			this.#announce = null;
+			return { ...result, notice, kernelState: "restarted" };
+		});
+	}
+
+	#died(generation: number, reason: string): void {
+		if (generation !== this.#generation || this.#closed) return;
+		this.#held = [...(this.#kernel.drainPending?.() ?? []), ...this.#held];
+		if (this.#recovering !== null) {
+			this.#recovering = null;
+			this.#unannounced = reason;
+			const error = new KernelUnavailableError(this.#language, reason);
+			for (const cell of this.#held.splice(0)) cell.settle(unstartedResult(cell.input.cellId, error.message));
+			return;
+		}
+		this.#recovering = reason;
+		this.#ensureReplacement();
+	}
+
+	#ensureReplacement(): void {
+		if (this.#replacing !== null) return;
+		const reason = this.#recovering ?? this.#unannounced;
+		this.#recovering = reason;
+		this.#unannounced = null;
+		const replacing = this.#replace(reason).finally(() => {
+			if (this.#replacing === replacing) this.#replacing = null;
+		});
+		this.#replacing = replacing;
+	}
+
+	/** Never rejects: every failure settles the held cells with what went wrong. */
+	async #replace(reason: string | null): Promise<void> {
+		const dead = this.#kernel;
+		try {
+			await dead.close();
+		} catch (error) {
+			// The old interpreter may still be running: report that rather than start a second one.
+			this.#failUnavailable(reason, `its interpreter could not be retired: ${errorText(error)}`);
+			return;
+		}
+		if (this.#closed) return;
+		const generation = ++this.#nextGeneration;
+		let next: EvalKernel;
+		try {
+			next = await this.#start({ onDeath: (died) => this.#died(generation, died) });
+		} catch (error) {
+			this.#failUnavailable(reason, `its replacement did not start: ${errorText(error)}`);
+			return;
+		}
+		if (this.#closed) {
+			await next.close().catch((error: unknown) => {
+				this.#closeFailure = error;
+			});
+			return;
+		}
+		this.#kernel = next;
+		this.#generation = generation;
+		this.#announce = reason === null ? null : restartNotice(this.#language, reason);
+		for (const cell of this.#held.splice(0)) {
+			void this.#submit(generation, next, cell.input).then(cell.settle, (error: unknown) =>
+				cell.settle(unstartedResult(cell.input.cellId, errorText(error))),
+			);
+		}
+	}
+
+	#failUnavailable(reason: string | null, detail: string): void {
+		this.#recovering = null;
+		this.#unannounced = reason;
+		const error = new KernelUnavailableError(this.#language, reason === null ? detail : `${reason}; ${detail}`);
+		for (const cell of this.#held.splice(0)) cell.settle(unstartedResult(cell.input.cellId, error.message));
+	}
+
+	#cancelHeld(cellId: string, reason: string): boolean {
+		const index = this.#held.findIndex((cell) => cell.input.cellId === cellId);
+		const [cell] = index < 0 ? [] : this.#held.splice(index, 1);
+		cell?.settle(unstartedResult(cellId, reason));
+		return cell !== undefined;
+	}
+
+	#failHeld(message: string): void {
+		for (const cell of this.#held.splice(0)) cell.settle(unstartedResult(cell.input.cellId, message));
+	}
+}
+
+function errorText(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/extension/runtime-factory.ts

@@ -72,6 +72,7 @@ export async function createRuntime(
 	const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
 	const manager = await create({
 		sessionId,
+		ownerSessionId: ctx.sessionManager.getSessionId(),
 		cwd: ctx.cwd,
 		sessionEnv,
 		settings,

package/src/extension/session-manager-contract.ts

@@ -0,0 +1,42 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import type { CodemodeSettings } from "../config/settings.ts";
+import type { InterpreterAvailability } from "../interpreters/detect.ts";
+import type { SessionEnvironment } from "../kernels/session-env.ts";
+import type { EvalKernelManager, ExecuteTool } from "../tool/types.ts";
+
+export interface CodemodeSessionManager extends EvalKernelManager {
+	dispose(): Promise<void>;
+	complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult>;
+	setContext?(ctx: ExtensionContext): void;
+	bridgeEndpoint?(): BridgeEndpoint;
+}
+
+export interface BridgeEndpoint {
+	readonly port: number;
+	readonly token: string;
+}
+
+export interface EvalExecutionTracker {
+	assertEvalExecutionAllowed(): void;
+	trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result>;
+}
+
+export interface CreateCodemodeSessionManagerOptions {
+	readonly sessionId: string;
+	/** The agent session that owns these kernels, as the process kernel registry lists them; defaults to `sessionId`. */
+	readonly ownerSessionId?: string;
+	readonly cwd: string;
+	readonly settings: CodemodeSettings;
+	readonly availability: InterpreterAvailability;
+	/** Session-scoped roots exposed to kernel helpers such as local://. */
+	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>;
+}