@code-yeongyu/senpi-codemode 2026.10.3 → 2026.10.5

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

@@ -44,6 +44,11 @@ export class SubprocessRunQueue {
 		};
 	}
 
+	/** Removes every queued run that has not started, oldest first. */
+	drain(): PendingRun[] {
+		return this.#queue.splice(0);
+	}
+
 	releaseActive(run: PendingRun): boolean {
 		if (this.#active !== run) return false;
 		this.#active = null;
@@ -114,6 +119,7 @@ export class SubprocessRunQueue {
 				onMessage?.(message);
 				return false;
 			case "webview-connect":
+			case "memory-query-result":
 				return false;
 			default: {
 				const exhaustive: never = message;

package/src/tool/cell-runtime.ts

@@ -5,7 +5,14 @@ import { formatModelTruncationNotice } from "../output/output-meta.ts";
 import { DEFAULT_MAX_BYTES, TailLineRing } from "../output/streaming-output.ts";
 import type { EvalToolCallMetric } from "./call-capture.ts";
 import { type EvalImageResizer, EvalOutputCollector, type EvalOutputResult } from "./image.ts";
-import type { EvalMemoryDetails, EvalRuntimeInfo, EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
+import type {
+	EvalKernelState,
+	EvalMemoryDetails,
+	EvalRuntimeInfo,
+	EvalStatusEvent,
+	EvalToolDetails,
+	EvalToolInput,
+} from "./types.ts";
 
 const LIVE_UPDATE_LINES = 8;
 /** Same cadence as the core bash tool's streaming updates (BASH_UPDATE_THROTTLE_MS). */
@@ -48,6 +55,8 @@ export class CellResultBuilder {
 	readonly #output: EvalOutputCollector;
 	readonly #state: CellState;
 	#memory: KernelMemoryReport | undefined;
+	#restartNotice: string | undefined;
+	#kernelState: EvalKernelState | undefined;
 	readonly #liveLines = new TailLineRing({ maxBytes: DEFAULT_MAX_BYTES * 2, maxLines: LIVE_UPDATE_LINES });
 	#lastOutputUpdateAt = 0;
 	#outputUpdateTimer: ReturnType<typeof setTimeout> | undefined;
@@ -85,6 +94,8 @@ export class CellResultBuilder {
 	async finalize(result: KernelResult): Promise<AgentToolResult<EvalToolDetails>> {
 		this.#state.durationMs = result.durationMs;
 		this.#memory = result.memory;
+		this.#restartNotice = result.notice;
+		this.#kernelState = result.kernelState;
 		if (result.ok) {
 			if (result.valueRepr) this.#output.pushValue(`${result.valueRepr}\n`);
 			this.#state.status = "complete";
@@ -160,9 +171,10 @@ export class CellResultBuilder {
 				? `(displayed ${output.images.length} image${output.images.length === 1 ? "" : "s"}; no text output)`
 				: "(no output)");
 		const text = output.meta === undefined ? shown : `${shown}\n${formatModelTruncationNotice(output.meta)}`;
-		const notice = this.#memory?.notice;
-		const noticePart = notice === undefined ? [] : [{ type: "text" as const, text: notice }];
-		return { content: [{ type: "text", text }, ...noticePart, ...output.images], details };
+		const noticeParts = [this.#restartNotice, this.#memory?.notice].flatMap((notice) =>
+			notice === undefined ? [] : [{ type: "text" as const, text: notice }],
+		);
+		return { content: [{ type: "text", text }, ...noticeParts, ...output.images], details };
 	}
 
 	#details(output: EvalOutputResult | undefined, isError: boolean): EvalToolDetails {
@@ -202,6 +214,7 @@ export class CellResultBuilder {
 			...(output?.notice === undefined ? {} : { notice: output.notice }),
 			...(output?.meta === undefined ? {} : { meta: output.meta }),
 			...(output === undefined || this.#memory === undefined ? {} : { memory: memoryDetails(this.#memory) }),
+			...(this.#kernelState === undefined ? {} : { kernelState: this.#kernelState }),
 		};
 	}
 

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

@@ -2,7 +2,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";
-import type { EvalMemoryDetails } from "./types.ts";
+import type { EvalKernelState, EvalMemoryDetails } from "./types.ts";
 
 const NOTIFICATION_TAIL_BYTES = 512;
 
@@ -78,11 +78,22 @@ function outcomeOf(cell: EvalDetachedCellSnapshot): string {
 }
 
 function stateNoteOf(cell: EvalDetachedCellSnapshot): string {
-	if (cell.state !== "cancelled") return memoryStateNote(cell.result.details?.memory);
+	if (cell.state !== "cancelled") {
+		const kernelState = cell.result.details?.kernelState;
+		return kernelState === undefined ? memoryStateNote(cell.result.details?.memory) : KERNEL_STATE_NOTES[kernelState];
+	}
 	const note = interruptionStateNote(cell.language, cell.stateRetained) ?? unknownInterruptionStateNote(cell.language);
 	return cell.interruptNote === undefined ? note : `${note} ${cell.interruptNote.trim()}`;
 }
 
+/** A kernel death decides what survived, whatever the memory report says. */
+const KERNEL_STATE_NOTES: Readonly<Record<EvalKernelState, string>> = {
+	lost: "The kernel died while this cell ran - every global is lost; the next eval cell runs on a fresh kernel.",
+	restarted:
+		"The kernel was restarted before this cell ran - globals from earlier cells are gone; this cell's variables are available to the next eval cell.",
+	"not-run": "This cell never ran and changed no kernel state.",
+};
+
 export function memoryStateNote(memory: EvalMemoryDetails | undefined): string {
 	if (memory?.overCeiling === true)
 		return "Kernel memory is over its ceiling - the kernel restarts before the next eval cell and every global is lost.";

package/src/tool/types.ts

@@ -161,6 +161,12 @@ export interface KernelInterruptHandle {
 	readonly note?: string;
 }
 
+/** An unstarted cell a dead kernel hands back, so its replacement runs it with the same input and callbacks. */
+export interface PendingCell {
+	readonly input: EvalKernelRunInput;
+	readonly settle: (result: EvalKernelResult) => void;
+}
+
 export interface EvalKernel {
 	run(input: EvalKernelRunInput): Promise<EvalKernelResult>;
 	cancelQueued(cellId: string, reason: string): boolean;
@@ -171,6 +177,10 @@ export interface EvalKernel {
 	close(): Promise<void>;
 	/** Names this kernel has registered; JS collides with other languages in the same session. */
 	listKernelToolNames?(): readonly string[];
+	/** False once the interpreter died on its own; the session manager then replaces the instance. */
+	isAlive?(): boolean;
+	/** Hands over, and forgets, every queued cell of a dead kernel that never started. */
+	drainPending?(): readonly PendingCell[];
 }
 
 export interface EvalKernelManager {
@@ -273,6 +283,10 @@ export interface EvalToolDetails {
 	readonly meta?: TruncationMeta;
 	/** Kernel memory after the cell; its notice text is delivered as its own content part. */
 	readonly memory?: EvalMemoryDetails;
+	/** What a kernel death did to this cell's state, when one did. */
+	readonly kernelState?: EvalKernelState;
 }
 
+export type EvalKernelState = NonNullable<EvalKernelResult["kernelState"]>;
+
 export type EvalMemoryDetails = Omit<KernelMemoryReport, "notice">;