@code-yeongyu/senpi-codemode 2026.10.6 → 2026.10.7

package/src/handles/wait.ts

@@ -0,0 +1,214 @@
+import {
+	EvalHandleError,
+	type HandleOutcome,
+	type HandlePhase,
+	type HandleRef,
+	type HandleSnapshot,
+	type HandleWatch,
+} from "@code-yeongyu/senpi";
+import { refKey, type WaitRequest } from "./handle-args.ts";
+
+const MAX_TIMER_MS = 2 ** 31 - 1;
+
+export interface WaitBackend {
+	watch(refs: readonly HandleRef[]): Promise<HandleWatch>;
+	result(ref: HandleRef): Promise<HandleOutcome>;
+	readonly signal?: AbortSignal;
+}
+
+export type WaitAnyResult = { readonly index: number; readonly ref: HandleRef; readonly value: unknown };
+
+/** A handle's own failure, raised by `wait(..., {mode: "all"})` and `control.wait()`; `code` is in the text. */
+export class HandleOutcomeError extends Error {
+	readonly name = "HandleOutcomeError";
+	readonly code: string;
+	readonly ref: HandleRef;
+	readonly details: unknown;
+
+	constructor(outcome: Extract<HandleOutcome, { status: "rejected" }>) {
+		super(`${outcome.error.code}: ${outcome.error.message}`);
+		this.code = outcome.error.code;
+		this.ref = outcome.ref;
+		this.details = outcome.error.details;
+	}
+}
+
+export class WaitAllRejectedError extends Error {
+	readonly name = "WaitAllRejectedError";
+	readonly code = "eval_wait_all_rejected";
+	readonly outcomes: readonly HandleOutcome[];
+
+	constructor(outcomes: readonly HandleOutcome[]) {
+		const summary = outcomes
+			.map((outcome) =>
+				outcome.status === "rejected" ? `${outcome.ref.id}: ${outcome.error.code}` : outcome.ref.id,
+			)
+			.join("; ");
+		super(`eval_wait_all_rejected: wait(any) found no successful handle among ${outcomes.length}; ${summary}`);
+		this.outcomes = outcomes;
+	}
+}
+
+const TERMINAL: ReadonlySet<HandlePhase> = new Set(["succeeded", "failed", "cancelled", "lost"]);
+
+/**
+ * The in-cell barrier. Subscribes once per distinct ref, keeps duplicate slots, settles according to the
+ * mode, and never cancels work: a timeout only closes the subscription. The timeout runs from entry and,
+ * like cancelling the cell, also ends a wait that is still subscribing or fetching a result. Parked time
+ * is the caller's concern (the bridge-call path pauses the run budget around this call).
+ */
+export async function waitForHandles(request: WaitRequest, backend: WaitBackend): Promise<unknown> {
+	const { refs, mode } = request;
+	if (refs.length === 0) {
+		if (mode === "any") throw new EvalHandleError("eval_wait_empty", "wait(any) needs at least one handle");
+		return [];
+	}
+	const unique = [...new Map(refs.map((ref) => [refKey(ref), ref])).values()];
+	const outcomes = new Map<string, HandleOutcome>();
+	const revisions = new Map<string, number>();
+	const stop = interruption(request.timeoutSeconds, backend.signal, refs, outcomes);
+	let watch: HandleWatch | undefined;
+	const finish = (): unknown => {
+		switch (mode) {
+			case "all":
+				return refs.map((ref) => settledValue(outcomes, ref));
+			case "settled":
+				return refs.map((ref) => outcomeOf(outcomes, ref));
+			case "any":
+				return firstSuccess(refs, outcomes) ?? rejectAll(refs, outcomes);
+			default:
+				return assertNever(mode);
+		}
+	};
+	// Returns true once the mode can settle without waiting for the remaining handles.
+	const absorb = async (snapshot: HandleSnapshot): Promise<boolean> => {
+		const key = refKey(snapshot.ref);
+		const known = revisions.get(key);
+		if (known !== undefined && snapshot.revision <= known) return false;
+		revisions.set(key, snapshot.revision);
+		if (snapshot.ref.kind === "workpool" && snapshot.phase === "pending" && snapshot.host_status === "open") {
+			throw new EvalHandleError(
+				"eval_pool_open",
+				`workpool ${snapshot.ref.id} is still open; close() it before waiting`,
+			);
+		}
+		if (!TERMINAL.has(snapshot.phase) || outcomes.has(key)) return false;
+		const outcome = await stop.race(backend.result(snapshot.ref));
+		outcomes.set(key, outcome);
+		if (mode === "all" && outcome.status === "rejected") throw new HandleOutcomeError(outcome);
+		if (mode === "any" && outcome.status === "fulfilled") return true;
+		return outcomes.size === unique.length;
+	};
+	try {
+		const subscribing = backend.watch(unique);
+		// A watch that resolves after the wait already ended is closed, so its subscription never leaks.
+		void subscribing.then(
+			(late) => {
+				if (stop.ended) late.close();
+			},
+			() => undefined,
+		);
+		watch = await stop.race(subscribing);
+		for (const snapshot of watch.initial) {
+			if (await absorb(snapshot)) return finish();
+		}
+		if (outcomes.size === unique.length) return finish();
+		if (request.timeoutSeconds === 0) throw timeoutError(0, refs, outcomes);
+		const iterator = watch.updates[Symbol.asyncIterator]();
+		try {
+			while (true) {
+				const step = await stop.race(iterator.next());
+				if (step.done) return finish();
+				if (await absorb(step.value)) return finish();
+			}
+		} finally {
+			await iterator.return?.();
+		}
+	} finally {
+		stop.end();
+		watch?.close();
+	}
+}
+
+/** One deadline armed at entry plus the cell's abort; `race` rejects any pending step once either fires. */
+function interruption(
+	timeoutSeconds: number | undefined,
+	signal: AbortSignal | undefined,
+	refs: readonly HandleRef[],
+	outcomes: ReadonlyMap<string, HandleOutcome>,
+) {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	let onAbort: (() => void) | undefined;
+	let ended = false;
+	const fired = new Promise<never>((_resolve, reject) => {
+		if (timeoutSeconds !== undefined && timeoutSeconds > 0) {
+			// A timer longer than the platform maximum fires at once, so a long deadline is armed in chunks.
+			const deadline = Date.now() + timeoutSeconds * 1_000;
+			const arm = (): void => {
+				const remainingMs = deadline - Date.now();
+				if (remainingMs <= 0) {
+					reject(timeoutError(timeoutSeconds, refs, outcomes));
+					return;
+				}
+				timer = setTimeout(arm, Math.min(remainingMs, MAX_TIMER_MS));
+			};
+			arm();
+		}
+		if (signal !== undefined) {
+			onAbort = () =>
+				reject(signal.reason instanceof Error ? signal.reason : new Error("wait() cancelled with its cell"));
+			if (signal.aborted) onAbort();
+			else signal.addEventListener("abort", onAbort, { once: true });
+		}
+	});
+	fired.catch(() => undefined);
+	return {
+		get ended(): boolean {
+			return ended;
+		},
+		race<T>(step: Promise<T>): Promise<T> {
+			return Promise.race([step, fired]);
+		},
+		end(): void {
+			ended = true;
+			if (timer !== undefined) clearTimeout(timer);
+			if (signal !== undefined && onAbort !== undefined) signal.removeEventListener("abort", onAbort);
+		},
+	};
+}
+
+function timeoutError(seconds: number, refs: readonly HandleRef[], outcomes: ReadonlyMap<string, HandleOutcome>) {
+	const settled = refs.filter((ref) => outcomes.has(refKey(ref))).length;
+	return new EvalHandleError(
+		"eval_wait_timeout",
+		`wait() timed out after ${seconds}s; ${settled}/${refs.length} handles settled; work was not cancelled`,
+	);
+}
+
+function outcomeOf(outcomes: ReadonlyMap<string, HandleOutcome>, ref: HandleRef): HandleOutcome {
+	const outcome = outcomes.get(refKey(ref));
+	if (outcome === undefined) throw new EvalHandleError("eval_handle_pending", `${ref.id} did not settle`);
+	return outcome;
+}
+
+function settledValue(outcomes: ReadonlyMap<string, HandleOutcome>, ref: HandleRef): unknown {
+	const outcome = outcomeOf(outcomes, ref);
+	if (outcome.status === "rejected") throw new HandleOutcomeError(outcome);
+	return outcome.value;
+}
+
+function firstSuccess(refs: readonly HandleRef[], outcomes: ReadonlyMap<string, HandleOutcome>) {
+	for (const [index, ref] of refs.entries()) {
+		const outcome = outcomes.get(refKey(ref));
+		if (outcome?.status === "fulfilled") return { index, ref, value: outcome.value } satisfies WaitAnyResult;
+	}
+	return undefined;
+}
+
+function rejectAll(refs: readonly HandleRef[], outcomes: ReadonlyMap<string, HandleOutcome>): never {
+	throw new WaitAllRejectedError(refs.map((ref) => outcomeOf(outcomes, ref)));
+}
+
+function assertNever(value: never): never {
+	throw new TypeError(`Unsupported wait mode: ${String(value)}`);
+}

package/src/handles/watch-queue.ts

@@ -0,0 +1,102 @@
+import type { HandleSnapshot, HandleWatch } from "@code-yeongyu/senpi";
+import { refKey } from "./handle-args.ts";
+
+/**
+ * A pull-side buffer for handle snapshots. Pushes queue up until the consumer iterates, so a change
+ * that lands between subscription and `initial` is delivered exactly once; `close()` is idempotent
+ * and ends the iterator.
+ */
+export class WatchQueue {
+	readonly #keys: ReadonlySet<string> | undefined;
+	readonly #queue: HandleSnapshot[] = [];
+	#wake: (() => void) | undefined;
+	#closed = false;
+	#failure: unknown;
+	#failed = false;
+
+	/** Without keys every snapshot is accepted (used by the merger); with keys only matching refs are. */
+	constructor(keys?: readonly string[]) {
+		this.#keys = keys === undefined ? undefined : new Set(keys);
+	}
+
+	get closed(): boolean {
+		return this.#closed;
+	}
+
+	push(snapshot: HandleSnapshot): void {
+		if (this.#closed || (this.#keys !== undefined && !this.#keys.has(refKey(snapshot.ref)))) return;
+		this.#queue.push(snapshot);
+		this.#wake?.();
+	}
+
+	close(): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#wake?.();
+	}
+
+	/** Ends the stream with an error: the next pull rejects instead of reporting a clean end. */
+	fail(error: unknown): void {
+		if (this.#closed) return;
+		this.#failed = true;
+		this.#failure = error;
+		this.close();
+	}
+
+	toWatch(initial: readonly HandleSnapshot[], onClose?: () => void): HandleWatch {
+		const close = (): void => {
+			this.close();
+			onClose?.();
+		};
+		const next = async (): Promise<IteratorResult<HandleSnapshot>> => {
+			while (this.#queue.length === 0 && !this.#closed) {
+				await new Promise<void>((resolve) => {
+					this.#wake = resolve;
+				});
+			}
+			this.#wake = undefined;
+			const value = this.#queue.shift();
+			if (value !== undefined) return { done: false, value };
+			if (this.#failed) throw this.#failure;
+			return { done: true, value: undefined };
+		};
+		const updates: AsyncIterable<HandleSnapshot> = {
+			[Symbol.asyncIterator]: () => ({
+				next,
+				return: async (): Promise<IteratorResult<HandleSnapshot>> => {
+					close();
+					return { done: true, value: undefined };
+				},
+			}),
+		};
+		return { initial, updates, close };
+	}
+}
+
+/** One watch over several: `initial` keeps the caller's order, updates from every part are drained eagerly. */
+export function mergeWatches(ordered: readonly HandleSnapshot[], parts: readonly HandleWatch[]): HandleWatch {
+	if (parts.length === 1 && parts[0] !== undefined) return { ...parts[0], initial: ordered };
+	const queue = new WatchQueue();
+	let open = parts.length;
+	const drain = async (part: HandleWatch): Promise<void> => {
+		try {
+			for await (const snapshot of part.updates) queue.push(snapshot);
+		} catch (error) {
+			queue.fail(error);
+		} finally {
+			open -= 1;
+			if (open === 0) queue.close();
+		}
+	};
+	if (parts.length === 0) queue.close();
+	for (const part of parts) void drain(part);
+	const merged = queue.toWatch(ordered);
+	return {
+		initial: merged.initial,
+		updates: merged.updates,
+		close: () => {
+			for (const part of parts) part.close();
+			merged.close();
+		},
+	};
+}

package/src/index.ts

@@ -1,4 +1,3 @@
-import * as os from "node:os";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
 import type { EvalSchemaToolInfo } from "./bridges/schema-bridge.ts";
@@ -14,18 +13,22 @@ import {
 import { EvalNotifier } from "./extension/eval-notifier.ts";
 import { EVAL_CELLS_STATUS_KEY } from "./extension/eval-status.ts";
 import { EvalStatusTicker } from "./extension/eval-status-ticker.ts";
+import { hostLine, modelIdFrom } from "./extension/host-facts.ts";
 import { activeKernelPreludes, kernelPreludeDocsKey, promptKernelPreludes } from "./extension/kernel-preludes.ts";
+import { registerRemovedToolHints } from "./extension/removed-tool-hints.ts";
 import {
 	createExecuteTool,
 	createRuntime,
 	enabledLanguagesFrom,
 	type SessionRuntime,
 } from "./extension/runtime-factory.ts";
-import { jsRuntimeInfo, jsRuntimeLabel } from "./extension/runtime-info.ts";
+import { jsRuntimeInfo } from "./extension/runtime-info.ts";
 import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from "./extension/session-manager.ts";
 import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
 import { activeBunSkillPath, registerBunSkillContribution } from "./extension/skill-contribution.ts";
+import { StartRecovery, withStartRecovery } from "./extension/start-recovery.ts";
 import { WAKE_SOURCE_STATE_EVENT, type WakeSourceState } from "./extension/wake-source-state.ts";
+import { HandleRegistry } from "./handles/handle-registry.ts";
 import type { KernelToolsCapability } from "./kernels/js/kernel-tools-types.ts";
 import { EvalDetachedCellManager, type EvalDetachedCellStatusEntry } from "./tool/detached-cell-manager.ts";
 import {
@@ -36,12 +39,9 @@ import {
 import { createEvalTool } from "./tool/eval-tool.ts";
 import { renderEvalCall, renderEvalResult } from "./tool/render.ts";
 
-const SESSION_LIFECYCLE_EVENTS = [
-	"session_start",
-	"session_shutdown",
-	"session_before_switch",
-	"session_before_fork",
-] as const;
+// session_before_switch / session_before_fork are veto points another extension can cancel, so they never
+// tear the runtime down; a switch or fork that goes ahead emits session_shutdown before the old session ends.
+const SESSION_LIFECYCLE_EVENTS = ["session_start", "session_shutdown"] as const;
 
 type SessionLifecycleEvent = (typeof SESSION_LIFECYCLE_EVENTS)[number];
 
@@ -93,6 +93,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 	let activeModelId: string | undefined;
 	let activeContext: ExtensionContext | undefined;
 	let activeCells: EvalDetachedCellManager | undefined;
+	let activeHandles: HandleRegistry | undefined;
 	let promptPreludeDocs = "";
 	const notifier = new EvalNotifier({
 		sendMessage: (message, notifyOptions) => pi.sendMessage(message, notifyOptions),
@@ -122,10 +123,12 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		pi.rpc?.emit(WAKE_SOURCE_STATE_EVENT, state);
 		pi.events?.emit(WAKE_SOURCE_STATE_EVENT, state);
 	};
+	const recovery = new StartRecovery(async (event, ctx) => await startSession(event, ctx));
 	const registerEvalForRuntime = (
 		runtime: SessionRuntime,
 		modelId: string | undefined,
 		cellManager: EvalDetachedCellManager,
+		handles: HandleRegistry,
 	): void => {
 		const onCellSettled = (payload: EvalExecutionEventPayload): void => {
 			if (activeCells !== cellManager) return;
@@ -140,93 +143,104 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		const preludes = promptKernelPreludes(pi);
 		promptPreludeDocs = kernelPreludeDocsKey(preludes);
 		pi.registerTool(
-			createEvalTool({
-				enabledLanguages: runtime.enabledLanguages,
-				kernelManager: manager,
-				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
-				foregroundWindowSeconds: resolveForegroundWindowSeconds(runtime.settings),
-				runBudgetSeconds: resolveRunBudgetSeconds(runtime.settings),
-				hardLimitSeconds: resolveHardLimitSeconds(runtime.settings),
-				executeTool: runtime.executeTool,
-				listTools: () => pi.getAllTools(),
-				complete,
-				settings: runtime.settings,
-				artifactsDir: runtime.artifactsDir,
-				cellManager,
-				executionTracker: manager,
-				onCellSettled,
-				renderers,
-				monitor,
-				spawns: runtime.spawns,
-				spawnDefaultAgent: runtime.settings.taskTools.task,
-				hostLine: hostLine(),
-				runtimes: runtime.runtimes,
-				kernelPreludes: () => activeKernelPreludes(pi),
-				promptKernelPreludes: preludes,
-				...(bunSkillPath === undefined ? {} : { bunSkillPath }),
-				...(modelId === undefined ? {} : { modelId }),
-			}),
+			withStartRecovery(
+				recovery,
+				createEvalTool({
+					enabledLanguages: runtime.enabledLanguages,
+					kernelManager: manager,
+					cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
+					foregroundWindowSeconds: resolveForegroundWindowSeconds(runtime.settings),
+					runBudgetSeconds: resolveRunBudgetSeconds(runtime.settings),
+					hardLimitSeconds: resolveHardLimitSeconds(runtime.settings),
+					executeTool: runtime.executeTool,
+					listTools: () => pi.getAllTools(),
+					complete,
+					settings: runtime.settings,
+					artifactsDir: runtime.artifactsDir,
+					cellManager,
+					handles,
+					executionTracker: manager,
+					onCellSettled,
+					renderers,
+					monitor,
+					spawns: runtime.spawns,
+					spawnDefaultAgent: runtime.settings.taskTools.task,
+					hostLine: hostLine(),
+					runtimes: runtime.runtimes,
+					kernelPreludes: () => activeKernelPreludes(pi),
+					promptKernelPreludes: preludes,
+					...(bunSkillPath === undefined ? {} : { bunSkillPath }),
+					...(modelId === undefined ? {} : { modelId }),
+				}),
+			),
 		);
 	};
 	const dropRuntime = async (): Promise<void> => {
 		const cells = activeCells;
+		const handles = activeHandles;
 		activeRuntime = undefined;
 		activeModelId = undefined;
 		activeCells = undefined;
+		activeHandles = undefined;
 		statusTicker.stop();
+		// Fail every saved handle closed before the kernels go: a late wait() must never reach a successor generation.
+		handles?.dispose();
 		await cells?.dispose();
 		activeContext = undefined;
 		await manager.dispose();
 	};
 	pi.registerTool(
-		createEvalTool({
-			enabledLanguages: { py: true, js: true, rb: true, jl: true },
-			kernelManager: manager,
-			cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
-			foregroundWindowSeconds: resolveForegroundWindowSeconds(defaultCodemodeSettings),
-			runBudgetSeconds: resolveRunBudgetSeconds(defaultCodemodeSettings),
-			hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
-			executeTool: createExecuteTool(pi),
-			listTools: () => pi.getAllTools(),
-			complete,
-			settings: defaultCodemodeSettings,
-			cellManager: new EvalDetachedCellManager({
-				notifier,
-				maxDetachedCells: resolveMaxDetachedCells(defaultCodemodeSettings),
-				retainedResultsBytes: resolveRetainedResultsBytes(defaultCodemodeSettings),
-				hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
+		withStartRecovery(
+			recovery,
+			createEvalTool({
+				enabledLanguages: { py: true, js: true, rb: true, jl: true },
+				kernelManager: manager,
+				cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
+				foregroundWindowSeconds: resolveForegroundWindowSeconds(defaultCodemodeSettings),
 				runBudgetSeconds: resolveRunBudgetSeconds(defaultCodemodeSettings),
-				onStatusChange: showDetachedCells,
-				onWakeSourceState: emitWakeSourceState,
-				...(options.now === undefined ? {} : { now: options.now }),
+				hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
+				executeTool: createExecuteTool(pi),
+				listTools: () => pi.getAllTools(),
+				complete,
+				settings: defaultCodemodeSettings,
+				cellManager: new EvalDetachedCellManager({
+					notifier,
+					maxDetachedCells: resolveMaxDetachedCells(defaultCodemodeSettings),
+					retainedResultsBytes: resolveRetainedResultsBytes(defaultCodemodeSettings),
+					hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
+					runBudgetSeconds: resolveRunBudgetSeconds(defaultCodemodeSettings),
+					onStatusChange: showDetachedCells,
+					onWakeSourceState: emitWakeSourceState,
+					...(options.now === undefined ? {} : { now: options.now }),
+				}),
+				executionTracker: manager,
+				renderers,
+				// The baseline tool is registered before extensions such as monitor load.
+				monitor: false,
+				hostLine: hostLine(),
+				runtimes: { js: jsRuntimeInfo() },
+				...(bunSkillPath === undefined ? {} : { bunSkillPath }),
 			}),
-			executionTracker: manager,
-			renderers,
-			// The baseline tool is registered before extensions such as monitor load.
-			monitor: false,
-			hostLine: hostLine(),
-			runtimes: { js: jsRuntimeInfo() },
-			...(bunSkillPath === undefined ? {} : { bunSkillPath }),
-		}),
-	);
-	pi.registerRemovedToolHint(
-		"exec",
-		'exec was removed; use eval({ language: "js", code }) instead. Long eval cells detach on their own 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.',
+		),
 	);
+	registerRemovedToolHints(pi);
 	registerBunSkillContribution(pi);
 
-	pi.on("session_start", async (event, ctx) => {
+	const startSession = async (event: unknown, ctx: ExtensionContext): Promise<void> => {
 		const previousCells = activeCells;
+		const previousHandles = activeHandles;
 		activeCells = undefined;
+		activeHandles = undefined;
+		previousHandles?.dispose();
 		await previousCells?.dispose();
 		const generation = manager.beginReplacement();
-		const runtime = await createRuntime(pi, ctx, event, complete, options);
+		const handles = new HandleRegistry({ ownerSessionId: ctx.sessionManager.getSessionId() });
+		const runtime = await createRuntime(pi, ctx, event, complete, options, handles);
 		const replaced = await manager.replace(generation, runtime.manager);
-		if (!replaced) return;
+		if (!replaced) {
+			handles.dispose();
+			return;
+		}
 		notifier.reset();
 		activeContext = ctx;
 		const cellManager = new EvalDetachedCellManager({
@@ -242,15 +256,18 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			...(options.now === undefined ? {} : { now: options.now }),
 		});
 		activeCells = cellManager;
+		activeHandles = handles;
 		// The goal builtin clears its per-session counts at session_start; re-publish our snapshot.
 		cellManager.publishWakeSourceState();
 		activeRuntime = runtime;
 		activeModelId = ctx.model?.id;
-		registerEvalForRuntime(runtime, activeModelId, cellManager);
+		registerEvalForRuntime(runtime, activeModelId, cellManager, handles);
+	};
+	pi.on("session_start", async (event, ctx) => await recovery.runStart(event, ctx));
+	pi.on("session_shutdown", async () => {
+		recovery.sessionEnded();
+		await dropRuntime();
 	});
-	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, ctx) => {
 		activeContext = ctx;
 		const runtime = activeRuntime;
@@ -259,33 +276,21 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		if (modelId === undefined || modelId === activeModelId) return;
 		activeModelId = modelId;
 		const cellManager = activeCells;
-		if (cellManager === undefined) return;
-		registerEvalForRuntime(runtime, modelId, cellManager);
+		const handles = activeHandles;
+		if (cellManager === undefined || handles === undefined) return;
+		registerEvalForRuntime(runtime, modelId, cellManager, handles);
 	});
 	// Tool activation has no event of its own; the next turn re-documents a changed contribution set.
 	pi.on("turn_start", async () => {
 		const runtime = activeRuntime;
 		const cellManager = activeCells;
-		if (runtime === undefined || cellManager === undefined) return;
+		const handles = activeHandles;
+		if (runtime === undefined || cellManager === undefined || handles === undefined) return;
 		if (kernelPreludeDocsKey(promptKernelPreludes(pi)) === promptPreludeDocs) return;
-		registerEvalForRuntime(runtime, activeModelId, cellManager);
+		registerEvalForRuntime(runtime, activeModelId, cellManager, handles);
 	});
 }
 
-function hostLine(): string {
-	const cpu = os.cpus()[0]?.model?.trim();
-	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`, jsRuntimeLabel()]
-		.filter((part): part is string => !!part)
-		.join(" \u00b7 ");
-}
-
-function modelIdFrom(event: unknown): string | undefined {
-	if (typeof event !== "object" || event === null || !("model" in event)) return undefined;
-	const model = event.model;
-	if (typeof model !== "object" || model === null || !("id" in model)) return undefined;
-	return typeof model.id === "string" ? model.id : undefined;
-}
-
 export {
 	KERNEL_TOOLS_CAPABILITIES,
 	KERNEL_TOOLS_UNSUPPORTED,