@code-yeongyu/senpi-codemode 2026.9.5-3 → 2026.9.6

package/src/kernels/js/worker-shell-capture.js

@@ -1,5 +1,12 @@
 const SHELL_CONFIG_METHODS = ["env", "cwd", "nothrow", "throws"];
 const SHELL_READ_METHODS = ["text", "json", "lines", "arrayBuffer", "bytes", "blob"];
+// `true | ( … )` hands every command in the template an empty pipe as stdin. The worker thread shares
+// the host process's fd 0 (the TUI's terminal), which Bun.$ would otherwise inherit, so a stdin
+// reader would wait on the user's keyboard forever. The newline before `)` keeps a trailing comment
+// from swallowing the closing paren; the Bun shell has no other stdin control (no `$.stdin`, no
+// redirect on a subshell).
+const STDIN_ISOLATION_HEAD = "true | (\n";
+const STDIN_ISOLATION_TAIL = "\n)";
 
 export function installShellCapture(options) {
 	const bun = globalThis.Bun;
@@ -20,8 +27,9 @@ function isBunRuntime(bun) {
 
 function capturedShell(originalShell, options) {
 	const shell = (strings, ...expressions) => {
-		const promise = originalShell(strings, ...expressions);
-		return options.isActive() ? captureShellPromise(promise, options.emitText) : promise;
+		if (!options.isActive()) return originalShell(strings, ...expressions);
+		const promise = originalShell(isolateStdin(strings), ...expressions);
+		return captureShellPromise(promise, options.emitText);
 	};
 	for (const key of Object.keys(originalShell)) shell[key] = originalShell[key];
 	for (const method of SHELL_CONFIG_METHODS) {
@@ -33,6 +41,18 @@ function capturedShell(originalShell, options) {
 	return shell;
 }
 
+function isolateStdin(strings) {
+	if (!Array.isArray(strings) || !Array.isArray(strings.raw)) return strings;
+	const cooked = [...strings];
+	const raw = [...strings.raw];
+	const last = cooked.length - 1;
+	cooked[0] = `${STDIN_ISOLATION_HEAD}${cooked[0]}`;
+	raw[0] = `${STDIN_ISOLATION_HEAD}${raw[0]}`;
+	cooked[last] = `${cooked[last]}${STDIN_ISOLATION_TAIL}`;
+	raw[last] = `${raw[last]}${STDIN_ISOLATION_TAIL}`;
+	return Object.freeze(Object.assign(cooked, { raw: Object.freeze(raw) }));
+}
+
 function captureShellPromise(promise, emitText) {
 	const prototype = Object.getPrototypeOf(promise);
 	let echo = true;
@@ -87,13 +107,19 @@ function capturedSpawn(originalSpawn, options) {
 	return (...args) => {
 		if (!options.isActive()) return originalSpawn(...args);
 		const [first, second] = args;
+		let child;
 		if (Array.isArray(first)) {
 			const spawnOptions = second === undefined ? {} : second;
-			if (!needsStderrCapture(spawnOptions)) return originalSpawn(...args);
-			return drainStderr(originalSpawn(first, { ...spawnOptions, stderr: "pipe" }), options.emitText);
+			child = needsStderrCapture(spawnOptions)
+				? drainStderr(originalSpawn(first, { ...spawnOptions, stderr: "pipe" }), options.emitText)
+				: originalSpawn(...args);
+		} else {
+			child = needsStderrCapture(first)
+				? drainStderr(originalSpawn({ ...first, stderr: "pipe" }), options.emitText)
+				: originalSpawn(...args);
 		}
-		if (!needsStderrCapture(first)) return originalSpawn(...args);
-		return drainStderr(originalSpawn({ ...first, stderr: "pipe" }), options.emitText);
+		options.onChild?.(child);
+		return child;
 	};
 }
 

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

@@ -0,0 +1,106 @@
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { WorkerLike } from "./inline-worker.ts";
+import { retireWorker, type WorkerRetirement } from "./interrupt-bounds.ts";
+import type { JavaScriptKernelMode } from "./kernel-contract.ts";
+import type { JavaScriptKernelOptions } from "./local-module-loader.ts";
+import { WorkerStartupCancelledError } from "./worker-host.ts";
+import { startWorkerWithInlineFallback } from "./worker-startup.ts";
+
+export interface WorkerSlotListeners {
+	isOpen(): boolean;
+	onMessage(message: KernelToHostMessage): void;
+	onCrash(error: Error): void;
+}
+
+/** The kernel's current worker generation: startup with inline fallback, message fencing, bounded retirement. */
+export class WorkerSlot {
+	readonly #options: JavaScriptKernelOptions;
+	readonly #listeners: WorkerSlotListeners;
+	#worker: WorkerLike | null = null;
+	#mode: JavaScriptKernelMode = "worker";
+	#generation = 0;
+	#ready: Promise<void> | null = null;
+	#startupAbort: AbortController | null = null;
+
+	constructor(options: JavaScriptKernelOptions, listeners: WorkerSlotListeners) {
+		this.#options = options;
+		this.#listeners = listeners;
+	}
+
+	get mode(): JavaScriptKernelMode {
+		return this.#mode;
+	}
+
+	get present(): boolean {
+		return this.#worker !== null;
+	}
+
+	get startingUp(): boolean {
+		return this.#startupAbort !== null;
+	}
+
+	postMessage(message: HostToKernelMessage): void {
+		this.#worker?.postMessage(message);
+	}
+
+	async ensureReady(): Promise<void> {
+		if (!this.#ready) {
+			const generation = ++this.#generation;
+			const controller = new AbortController();
+			this.#startupAbort = controller;
+			const ready = startWorkerWithInlineFallback(
+				{
+					options: this.#options,
+					publish: (worker) => this.#publish(worker, generation),
+					isCurrent: (worker) => this.#isCurrent(worker, generation),
+					retire: (worker) => {
+						if (this.#worker === worker) this.#worker = null;
+					},
+					canFallBackInline: () => this.#listeners.isOpen() && generation === this.#generation,
+				},
+				controller.signal,
+			);
+			this.#ready = ready;
+			void ready.then(
+				() => {
+					if (this.#ready !== ready) return;
+					this.#startupAbort = null;
+					this.#mode = this.#worker?.mode ?? this.#mode;
+				},
+				() => {
+					if (this.#ready === ready) {
+						this.#ready = null;
+						this.#startupAbort = null;
+					}
+				},
+			);
+		}
+		return await this.#ready;
+	}
+
+	async retire(): Promise<WorkerRetirement> {
+		this.#generation += 1;
+		this.#startupAbort?.abort();
+		this.#startupAbort = null;
+		this.#ready = null;
+		const worker = this.#worker;
+		this.#worker = null;
+		if (!worker) return "terminated";
+		return await retireWorker(worker);
+	}
+
+	#publish(worker: WorkerLike, generation: number): void {
+		if (!this.#listeners.isOpen() || generation !== this.#generation) throw new WorkerStartupCancelledError();
+		this.#worker = worker;
+		worker.onMessage((message) => {
+			if (this.#isCurrent(worker, generation)) this.#listeners.onMessage(message);
+		});
+		worker.onError((error) => {
+			if (this.#isCurrent(worker, generation)) this.#listeners.onCrash(error);
+		});
+	}
+
+	#isCurrent(worker: WorkerLike, generation: number): boolean {
+		return this.#listeners.isOpen() && this.#worker === worker && this.#generation === generation;
+	}
+}

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

@@ -0,0 +1,69 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { type CodemodeRuntimeAssetEnvironment, resolveCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
+import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
+import { type JavaScriptKernelOptions, localBridgeConnection } from "./local-module-loader.ts";
+import { spawnNodeWorker, WorkerStartupCancelledError, waitForReady } from "./worker-host.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 interface WorkerStartupHooks {
+	readonly options: JavaScriptKernelOptions;
+	/** Wires the worker into the kernel; throws `WorkerStartupCancelledError` once the generation is stale. */
+	publish(worker: WorkerLike): void;
+	isCurrent(worker: WorkerLike): boolean;
+	retire(worker: WorkerLike): void;
+	canFallBackInline(): boolean;
+}
+
+export async function startWorkerWithInlineFallback(hooks: WorkerStartupHooks, signal: AbortSignal): Promise<void> {
+	let worker = spawnWorker(hooks.options);
+	hooks.publish(worker);
+	try {
+		await initializeWorker(worker, hooks.options, signal);
+		return;
+	} catch (error) {
+		if (!hooks.isCurrent(worker) || error instanceof WorkerStartupCancelledError) {
+			await worker.terminate();
+			throw new WorkerStartupCancelledError();
+		}
+		if (worker.mode === "inline") throw error;
+		hooks.retire(worker);
+		await worker.terminate();
+	}
+	if (!hooks.canFallBackInline()) throw new WorkerStartupCancelledError();
+	worker = createInlineWorker(hooks.options.cwd, hooks.options.parallelPoolWidth);
+	hooks.publish(worker);
+	await initializeWorker(worker, hooks.options, signal);
+}
+
+function spawnWorker(options: JavaScriptKernelOptions): WorkerLike {
+	try {
+		const url = options.workerEntryUrl ?? resolveJsWorkerEntryUrl();
+		return spawnNodeWorker(url, options.cwd, options.parallelPoolWidth);
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		return createInlineWorker(options.cwd, options.parallelPoolWidth);
+	}
+}
+
+async function initializeWorker(
+	worker: WorkerLike,
+	options: JavaScriptKernelOptions,
+	signal: AbortSignal,
+): Promise<void> {
+	const ready = waitForReady(worker, signal);
+	worker.postMessage({
+		type: "init",
+		sessionId: options.sessionId,
+		connection: localBridgeConnection(options),
+	});
+	await ready;
+}

package/src/prompt/eval-prompt.ts

@@ -102,7 +102,7 @@ Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to it
 A cell that outlives the foreground window detaches: it keeps its language kernel busy (another language can continue) and completes as one notification with its value or error and buffered output. Do not re-run a detached cell; read or cancel it with \`eval({ action: "peek", cell_id })\` / \`eval({ action: "stop", cell_id })\`.
 
 {{#if py}}Python runs on a live event loop: use top-level \`await\`; \`asyncio.run(…)\` raises.{{/if}}
-{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot.{{#if bunSkillPath}} MUST READ the bun-1-4 skill at {{bunSkillPath}} before your first js cell — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
+{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot. Shell out through \`Bun.$\` or \`Bun.spawn\`, never \`Bun.spawnSync\`: a synchronous child blocks the worker, so a stop or timeout then loses every variable.{{#if bunSkillPath}} MUST READ the bun-1-4 skill at {{bunSkillPath}} before your first js cell — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
 {{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
 {{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
 On error, fix and re-run only the failing step; a normal error keeps state, while a timeout or stop message says whether the kernel restarted.

package/src/tool/cell-execution.ts

@@ -1,5 +1,5 @@
 import { IdleTimeout, type IdleTimeoutOptions, type TimeoutPauseHandle } from "../timeouts/idle-timeout.ts";
-import type { EvalKernel } from "./types.ts";
+import type { EvalKernel, KernelInterruptHandle } from "./types.ts";
 
 const INTERRUPT_DELIVERY_GRACE_MS = 100;
 
@@ -104,7 +104,8 @@ export class CellExecution {
 		this.#abort(this.#callerSignal.reason);
 	};
 
-	interruptStateRetained: Promise<boolean> | undefined;
+	/** Resolves with the kernel's interrupt handle once the abort reached it; undefined when no kernel was bound. */
+	interruptHandle: Promise<KernelInterruptHandle> | undefined;
 
 	#abort(reason: unknown): void {
 		if (!this.#active) return;
@@ -118,15 +119,12 @@ export class CellExecution {
 			return;
 		}
 		this.#interruptDeadline = setTimeout(() => this.#settleAbort(error), INTERRUPT_DELIVERY_GRACE_MS);
-		void Promise.resolve()
-			.then(async () => {
-				const handle = await kernel.interrupt(error.message);
-				this.interruptStateRetained = handle?.stateRetained;
-			})
-			.then(
-				() => this.#settleAbort(error),
-				(interruptError: unknown) => this.#settleAbort(interruptError),
-			);
+		const handle = Promise.resolve().then(async () => await kernel.interrupt(error.message));
+		this.interruptHandle = handle;
+		void handle.then(
+			() => this.#settleAbort(error),
+			(interruptError: unknown) => this.#settleAbort(interruptError),
+		);
 	}
 
 	#settleAbort(reason: unknown): void {

package/src/tool/detached-cell-contract.ts

@@ -0,0 +1,45 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import type { WakeSourceState } from "../extension/wake-source-state.ts";
+import type { EvalLanguage, EvalToolDetails } from "./types.ts";
+
+export type EvalDetachedCellState = "running" | "detached" | "completed" | "failed" | "cancelled";
+
+export interface EvalDetachedCellSnapshot {
+	readonly cellId: string;
+	readonly language: EvalLanguage;
+	readonly state: EvalDetachedCellState;
+	readonly outputTail: string;
+	readonly result: AgentToolResult<EvalToolDetails>;
+	readonly stateRetained: boolean | undefined;
+	/** Kernel-supplied detail about the interrupt outcome, e.g. an abandoned blocked worker. */
+	readonly interruptNote?: string;
+	/** Set only when the wall-clock kill deadline ended this cell. */
+	readonly hardLimitSeconds?: number;
+}
+
+export interface EvalDetachedCellNotification {
+	readonly cellId: string;
+	readonly content: string;
+}
+
+export interface EvalDetachedCellNotifier {
+	notify(cells: readonly EvalDetachedCellNotification[]): void;
+}
+
+export interface EvalDetachedCellStatusEntry {
+	readonly cellId: string;
+	readonly language: EvalLanguage;
+	readonly summary?: string;
+	readonly startedAtMs: number;
+}
+
+export interface EvalDetachedCellManagerOptions {
+	readonly artifactsDir?: string;
+	readonly notifier?: EvalDetachedCellNotifier;
+	/** Wall-clock kill deadline in seconds; defaults to the bash-parity 1800s. */
+	readonly hardLimitSeconds?: number;
+	readonly onStatusChange?: (entries: readonly EvalDetachedCellStatusEntry[]) => void;
+	/** Receives a full per-source liveness snapshot on every detached-cell transition; used by the goal builtin. */
+	readonly onWakeSourceState?: (state: WakeSourceState) => void;
+	readonly now?: () => number;
+}

package/src/tool/detached-cell-manager.ts

@@ -1,6 +1,12 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
 import { DEFAULT_HARD_LIMIT_SECONDS } from "../config/settings.ts";
-import { SENPI_CODEMODE_WAKE_SOURCE, type WakeSourceState } from "../extension/wake-source-state.ts";
+import type { WakeSourceState } from "../extension/wake-source-state.ts";
+import type {
+	EvalDetachedCellManagerOptions,
+	EvalDetachedCellSnapshot,
+	EvalDetachedCellState,
+	EvalDetachedCellStatusEntry,
+} from "./detached-cell-contract.ts";
 import { detachedNotificationSpillPath } from "./detached-cell-notification.ts";
 import { currentDetachedResult, detachedErrorResult, snapshotDetachedCell } from "./detached-cell-snapshot.ts";
 import {
@@ -8,10 +14,18 @@ import {
 	allowsDetachedCellTransition,
 	detachedCellIsActive,
 } from "./detached-cell-state.ts";
+import { detachedStatusEntries, detachedWakeSourceState } from "./detached-cell-status.ts";
 import { DetachedNotificationQueue } from "./detached-notification-queue.ts";
 import type { EvalKernel, EvalLanguage, EvalToolDetails, EvalToolInput } from "./types.ts";
 
-export type EvalDetachedCellState = "running" | "detached" | "completed" | "failed" | "cancelled";
+export type {
+	EvalDetachedCellManagerOptions,
+	EvalDetachedCellNotification,
+	EvalDetachedCellNotifier,
+	EvalDetachedCellSnapshot,
+	EvalDetachedCellState,
+	EvalDetachedCellStatusEntry,
+} from "./detached-cell-contract.ts";
 
 type LiveResultProvider = () => AgentToolResult<EvalToolDetails>;
 
@@ -26,6 +40,9 @@ type ManagedCell = {
 	wasDetached: boolean;
 	kernel: EvalKernel | undefined;
 	stateRetained: boolean | undefined;
+	interruptNote: string | undefined;
+	/** Holds the completion notification until the interrupt has reported whether kernel state survived. */
+	interruptOutcome: PromiseWithResolvers<void> | undefined;
 	liveResult: LiveResultProvider | undefined;
 	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
 	notificationQueued: boolean;
@@ -35,44 +52,6 @@ type ManagedCell = {
 	onHardLimit: ((error: Error) => void) | undefined;
 };
 
-export interface EvalDetachedCellSnapshot {
-	readonly cellId: string;
-	readonly language: EvalLanguage;
-	readonly state: EvalDetachedCellState;
-	readonly outputTail: string;
-	readonly result: AgentToolResult<EvalToolDetails>;
-	readonly stateRetained: boolean | undefined;
-	/** Set only when the wall-clock kill deadline ended this cell. */
-	readonly hardLimitSeconds?: number;
-}
-
-export interface EvalDetachedCellNotification {
-	readonly cellId: string;
-	readonly content: string;
-}
-
-export interface EvalDetachedCellNotifier {
-	notify(cells: readonly EvalDetachedCellNotification[]): void;
-}
-
-export interface EvalDetachedCellStatusEntry {
-	readonly cellId: string;
-	readonly language: EvalLanguage;
-	readonly summary?: string;
-	readonly startedAtMs: number;
-}
-
-export interface EvalDetachedCellManagerOptions {
-	readonly artifactsDir?: string;
-	readonly notifier?: EvalDetachedCellNotifier;
-	/** Wall-clock kill deadline in seconds; defaults to the bash-parity 1800s. */
-	readonly hardLimitSeconds?: number;
-	readonly onStatusChange?: (entries: readonly EvalDetachedCellStatusEntry[]) => void;
-	/** Receives a full per-source liveness snapshot on every detached-cell transition; used by the goal builtin. */
-	readonly onWakeSourceState?: (state: WakeSourceState) => void;
-	readonly now?: () => number;
-}
-
 export function hardLimitError(cellId: string, hardLimitSeconds: number): Error {
 	const error = new Error(`Eval cell ${cellId} was killed at the ${hardLimitSeconds}s hard limit.`);
 	error.name = "TimeoutError";
@@ -114,6 +93,8 @@ export class EvalDetachedCellManager {
 			wasDetached: false,
 			kernel: undefined,
 			stateRetained: undefined,
+			interruptNote: undefined,
+			interruptOutcome: undefined,
 			liveResult: undefined,
 			terminalResult: undefined,
 			notificationQueued: false,
@@ -162,13 +143,7 @@ export class EvalDetachedCellManager {
 
 	async stop(cellId: string, reason = "Stopped detached eval cell"): Promise<EvalDetachedCellSnapshot> {
 		const cell = this.#get(cellId);
-		if (cell.state === "detached") {
-			const claimed = this.#settle(cell, "cancelled", currentDetachedResult(cell));
-			if (claimed && cell.kernel !== undefined) {
-				const handle = await cell.kernel.interrupt(reason);
-				cell.stateRetained = await handle.stateRetained;
-			}
-		}
+		if (cell.state === "detached") await this.#cancel(cell, reason);
 		return this.#snapshot(cell);
 	}
 
@@ -221,7 +196,10 @@ export class EvalDetachedCellManager {
 			if (!cell.notificationQueued) {
 				cell.notificationQueued = true;
 				this.#notificationQueue.enqueue({
-					snapshot: () => this.#snapshot(cell),
+					snapshot: async () => {
+						await cell.interruptOutcome?.promise;
+						return this.#snapshot(cell);
+					},
 					spillPath: cell.spillPath,
 				});
 			}
@@ -250,40 +228,34 @@ export class EvalDetachedCellManager {
 		const foreground = cell.state === "running" && cell.onHardLimit !== undefined;
 		cell.hardLimited = true;
 		const error = hardLimitError(cell.cellId, cell.hardLimitSeconds);
-		if (!this.#settle(cell, "cancelled", currentDetachedResult(cell))) return;
 		if (foreground) {
-			cell.onHardLimit?.(error);
+			if (this.#settle(cell, "cancelled", currentDetachedResult(cell))) cell.onHardLimit?.(error);
 			return;
 		}
-		if (cell.kernel === undefined) return;
-		const handle = await cell.kernel.interrupt(error.message);
-		cell.stateRetained = await handle.stateRetained;
+		await this.#cancel(cell, error.message);
+	}
+
+	async #cancel(cell: ManagedCell, reason: string): Promise<void> {
+		const outcome = Promise.withResolvers<void>();
+		cell.interruptOutcome = outcome;
+		try {
+			if (!this.#settle(cell, "cancelled", currentDetachedResult(cell)) || cell.kernel === undefined) return;
+			const handle = await cell.kernel.interrupt(reason);
+			cell.interruptNote = handle.note;
+			cell.stateRetained = await handle.stateRetained;
+		} finally {
+			outcome.resolve();
+		}
 	}
 
 	#emitStatus(): void {
 		const liveCells = [...this.#detachedByLanguage.values()];
-		this.#onStatusChange?.(
-			liveCells.map((cell) => ({
-				cellId: cell.cellId,
-				language: cell.input.language,
-				startedAtMs: cell.startedAtMs,
-				...(cell.input.summary === undefined ? {} : { summary: cell.input.summary }),
-			})),
-		);
+		this.#onStatusChange?.(detachedStatusEntries(liveCells));
 		this.#emitWakeSourceState(liveCells);
 	}
 
 	#emitWakeSourceState(liveCells: readonly ManagedCell[]): void {
-		this.#onWakeSourceState?.({
-			source: SENPI_CODEMODE_WAKE_SOURCE,
-			activeCount: liveCells.length,
-			items: liveCells.map((cell) => ({
-				id: cell.cellId,
-				description:
-					cell.input.summary === undefined || cell.input.summary.length === 0 ? cell.cellId : cell.input.summary,
-				startedAtMs: cell.startedAtMs,
-			})),
-		});
+		this.#onWakeSourceState?.(detachedWakeSourceState(liveCells));
 	}
 
 	#snapshot(cell: ManagedCell): EvalDetachedCellSnapshot {

package/src/tool/detached-cell-notification.ts

@@ -1,6 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import type { EvalDetachedCellNotification, EvalDetachedCellSnapshot } from "./detached-cell-manager.ts";
+import { interruptionStateNote, unknownInterruptionStateNote } from "./interrupt-note.ts";
 
 const NOTIFICATION_TAIL_BYTES = 512;
 
@@ -74,11 +75,9 @@ function outcomeOf(cell: EvalDetachedCellSnapshot): string {
 }
 
 function stateNoteOf(cell: EvalDetachedCellSnapshot): string {
-	if (cell.state === "cancelled" && cell.language === "js")
-		return "JavaScript worker was restarted; VM state was lost.";
-	if (cell.state === "cancelled" && cell.language === "py")
-		return "Python kernel was interrupted; its existing variables are preserved.";
-	return "Kernel state updated - variables are available to the next eval cell.";
+	if (cell.state !== "cancelled") return "Kernel state updated - variables are available to the next eval cell.";
+	const note = interruptionStateNote(cell.language, cell.stateRetained) ?? unknownInterruptionStateNote(cell.language);
+	return cell.interruptNote === undefined ? note : `${note} ${cell.interruptNote.trim()}`;
 }
 
 function safeCellId(cellId: string): string {

package/src/tool/detached-cell-snapshot.ts

@@ -10,6 +10,7 @@ export interface DetachedCellResultSource {
 	state: EvalDetachedCellState;
 	kernel: EvalKernel | undefined;
 	stateRetained: boolean | undefined;
+	interruptNote?: string | undefined;
 	liveResult: (() => AgentToolResult<EvalToolDetails>) | undefined;
 	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
 	hardLimited?: boolean;
@@ -26,6 +27,7 @@ export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: numb
 		outputTail: detachedOutputTail(result),
 		result,
 		stateRetained: cell.stateRetained,
+		...(cell.interruptNote === undefined ? {} : { interruptNote: cell.interruptNote }),
 		...(cell.hardLimited === true && cell.hardLimitSeconds !== undefined
 			? { hardLimitSeconds: cell.hardLimitSeconds }
 			: {}),

package/src/tool/detached-cell-status.ts

@@ -0,0 +1,30 @@
+import { SENPI_CODEMODE_WAKE_SOURCE, type WakeSourceState } from "../extension/wake-source-state.ts";
+import type { EvalDetachedCellStatusEntry } from "./detached-cell-manager.ts";
+
+export interface LiveDetachedCell {
+	readonly cellId: string;
+	readonly startedAtMs: number;
+	readonly input: { readonly language: EvalDetachedCellStatusEntry["language"]; readonly summary?: string };
+}
+
+export function detachedStatusEntries(liveCells: readonly LiveDetachedCell[]): EvalDetachedCellStatusEntry[] {
+	return liveCells.map((cell) => ({
+		cellId: cell.cellId,
+		language: cell.input.language,
+		startedAtMs: cell.startedAtMs,
+		...(cell.input.summary === undefined ? {} : { summary: cell.input.summary }),
+	}));
+}
+
+export function detachedWakeSourceState(liveCells: readonly LiveDetachedCell[]): WakeSourceState {
+	return {
+		source: SENPI_CODEMODE_WAKE_SOURCE,
+		activeCount: liveCells.length,
+		items: liveCells.map((cell) => ({
+			id: cell.cellId,
+			description:
+				cell.input.summary === undefined || cell.input.summary.length === 0 ? cell.cellId : cell.input.summary,
+			startedAtMs: cell.startedAtMs,
+		})),
+	};
+}

package/src/tool/detached-eval-result.ts

@@ -40,6 +40,7 @@ export function createDetachedControlResult(snapshot: EvalDetachedCellSnapshot):
 		`Eval cell ${snapshot.cellId} (${snapshot.language}) is ${snapshot.state}.`,
 		output.length === 0 ? "(no buffered output)" : output,
 		...(terminationNote === undefined ? [] : [terminationNote]),
+		...(snapshot.interruptNote === undefined ? [] : [snapshot.interruptNote.trim()]),
 	].join("\n");
 	return {
 		content: [{ type: "text", text }, ...snapshot.result.content.filter((part) => part.type === "image")],

package/src/tool/detached-notification-queue.ts

@@ -2,7 +2,7 @@ import type { EvalDetachedCellNotifier, EvalDetachedCellSnapshot } from "./detac
 import { buildDetachedCellNotification } from "./detached-cell-notification.ts";
 
 export interface PendingDetachedNotification {
-	readonly snapshot: () => EvalDetachedCellSnapshot;
+	readonly snapshot: () => EvalDetachedCellSnapshot | Promise<EvalDetachedCellSnapshot>;
 	readonly spillPath: string | undefined;
 }
 
@@ -30,7 +30,7 @@ export class DetachedNotificationQueue {
 		const flush = Promise.resolve().then(async () => {
 			const pending = this.#pending.splice(0);
 			const notifications = await Promise.all(
-				pending.map(async (item) => await buildDetachedCellNotification(item.snapshot(), item.spillPath)),
+				pending.map(async (item) => await buildDetachedCellNotification(await item.snapshot(), item.spillPath)),
 			);
 			this.#notifier?.notify(notifications);
 		});