@code-yeongyu/senpi-codemode 2026.10.18 → 2026.10.19

package/CHANGELOG.md

@@ -12,6 +12,32 @@
 
 ### Removed
 
+## [2026.10.19] - 2026-10-19
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.10.18-1] - 2026-10-18
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- A Python kernel no longer loses its globals silently. When its control pipe broke before its exit was seen (a dying interpreter hit by the host's next write), the death went unreported and the next cell started a fresh interpreter with no notice; it is now a death like any other, replaced and announced. A kernel replaced by a later generation of the same session (a reload, including the automatic config reload, a host restart, or a resume) now announces itself on its first result. Restart notices name the lost globals; a SIGKILL that senpi did not send says it was probably the system under memory pressure and gives the host's memory state and the kernel's last memory reading; the prelude's parent watch names itself when it stops the kernel. Reported by 용짱 ([#3612](https://github.com/code-yeongyu/senpi/issues/3612)).
+
+### Removed
+
 ## [2026.10.18] - 2026-10-18
 
 ### Breaking Changes

package/README.md

@@ -560,6 +560,21 @@ fresh interpreter dies too before it finished a cell, the queued cells fail with
 another. An interpreter whose exit cannot be confirmed is reported, never
 replaced by a second one. The JavaScript worker keeps its own restart path.
 
+A death is reported however the host first hears of it: a broken control pipe
+(EPIPE) counts the same as the exit. A SIGKILL senpi did not send reads
+`signal 9, probably killed by the system, most often under memory pressure`,
+with the host's memory state when it can be read (macOS memory pressure level
+and swap in use; Linux available memory and swap in use) and, for Python, the
+kernel's last memory reading. The Python prelude's parent watch names itself
+instead when it stops the kernel. Python results report the user globals
+defined so far (`globalNames`, at most 64, and `globalCount`); the notice lists
+the ones a dead kernel took with it (`Lost: helper, rows`). The session keeps
+that list in `<artifacts>/kernels/py-globals.json`, so the first result of a
+kernel started by a later generation of the same session (a reload, including
+the automatic config reload, a host restart, or a resume) says
+`[py kernel is new: ...; every global it held is gone. Lost: ...]`. A reset
+clears the list.
+
 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`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.10.18",
+	"version": "2026.10.19",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -33,15 +33,15 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.18",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.19",
 		"quickjs-wasi": "3.6.2",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.10.18"
+		"@code-yeongyu/senpi": "2026.10.19"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.10.18"
+		"@code-yeongyu/senpi": "2026.10.19"
 	},
 	"keywords": [
 		"senpi",

package/src/bridge/protocol.ts

@@ -100,6 +100,12 @@ const hostToKernelMessageSchema = Type.Union([
  */
 const kernelStateSchema = Type.Union([Type.Literal("lost"), Type.Literal("restarted"), Type.Literal("not-run")]);
 
+/** Python results: the user globals defined after the cell, so a notice can name what a lost kernel took with it. */
+const resultGlobalsSchema = {
+	globalCount: Type.Optional(Type.Integer({ minimum: 0 })),
+	globalNames: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { maxItems: 64 })),
+};
+
 const kernelToHostMessageSchema = Type.Union([
 	Type.Object({ type: Type.Literal("ready"), memoryGlobals: Type.Optional(Type.Boolean()) }),
 	Type.Object({ type: Type.Literal("init-failed"), error: bridgeErrorSchema }),
@@ -129,6 +135,7 @@ const kernelToHostMessageSchema = Type.Union([
 		valueRepr: Type.Optional(Type.String()),
 		durationMs: Type.Integer({ minimum: 0 }),
 		memory: Type.Optional(kernelMemoryReportSchema),
+		...resultGlobalsSchema,
 		/** 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),
@@ -140,6 +147,7 @@ const kernelToHostMessageSchema = Type.Union([
 		error: bridgeErrorSchema,
 		durationMs: Type.Integer({ minimum: 0 }),
 		memory: Type.Optional(kernelMemoryReportSchema),
+		...resultGlobalsSchema,
 		notice: Type.Optional(Type.String()),
 		kernelState: Type.Optional(kernelStateSchema),
 	}),

package/src/extension/kernel-globals-ledger.ts

@@ -0,0 +1,101 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { LostGlobals } from "../kernels/shared/kernel-death.ts";
+import type { EvalKernelResult, EvalLanguage } from "../tool/types.ts";
+
+const NONE: LostGlobals = { names: [], count: 0 };
+
+/**
+ * The user globals a session's kernel holds, as its newest result reported them, kept in memory and in
+ * the session's artifacts directory. A death names them in its restart notice; a later session-manager
+ * generation (reload, host restart, resume) reads the file and names what its predecessor took with it.
+ * The file is a diagnostic: when it cannot be read or written the notice names fewer globals, nothing else.
+ */
+export class KernelGlobalsLedger {
+	readonly #path: string | undefined;
+	#current: LostGlobals = NONE;
+	#inherited: LostGlobals;
+	#writes: Promise<void> = Promise.resolve();
+	#written = "";
+
+	private constructor(path: string | undefined, inherited: LostGlobals) {
+		this.#path = path;
+		this.#inherited = inherited;
+		this.#written = serialize(inherited);
+	}
+
+	static inMemory(): KernelGlobalsLedger {
+		return new KernelGlobalsLedger(undefined, NONE);
+	}
+
+	static async open(artifactsDir: string | undefined, language: EvalLanguage): Promise<KernelGlobalsLedger> {
+		if (artifactsDir === undefined) return KernelGlobalsLedger.inMemory();
+		const path = join(artifactsDir, "kernels", `${language}-globals.json`);
+		return new KernelGlobalsLedger(path, await readLedger(path));
+	}
+
+	/** What an earlier kernel of this session held when it ended, once; empty when it held nothing. */
+	takeInherited(): LostGlobals {
+		const inherited = this.#inherited;
+		this.#inherited = NONE;
+		return inherited;
+	}
+
+	takeLost(): LostGlobals {
+		const lost = this.#current;
+		this.#record(NONE);
+		return lost;
+	}
+
+	observe(result: EvalKernelResult): void {
+		if (result.globalNames === undefined) return;
+		this.#record({ names: result.globalNames, count: result.globalCount ?? result.globalNames.length });
+	}
+
+	/** A reset discards every global on purpose: nothing is lost that a later notice should name. */
+	clear(): void {
+		this.#inherited = NONE;
+		this.#record(NONE);
+	}
+
+	flush(): Promise<void> {
+		return this.#writes;
+	}
+
+	#record(globals: LostGlobals): void {
+		this.#current = globals;
+		const path = this.#path;
+		const text = serialize(globals);
+		if (path === undefined || text === this.#written) return;
+		this.#written = text;
+		this.#writes = this.#writes.then(() => writeLedger(path, text)).catch(() => undefined);
+	}
+}
+
+function serialize(globals: LostGlobals): string {
+	return JSON.stringify({ names: globals.names, count: globals.count });
+}
+
+async function writeLedger(path: string, text: string): Promise<void> {
+	await mkdir(dirname(path), { recursive: true });
+	const staging = `${path}.${process.pid}.tmp`;
+	await writeFile(staging, text);
+	await rename(staging, path);
+}
+
+async function readLedger(path: string): Promise<LostGlobals> {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		return NONE;
+	}
+	if (typeof parsed !== "object" || parsed === null) return NONE;
+	const names = "names" in parsed && Array.isArray(parsed.names) ? parsed.names.filter(isName) : [];
+	const count = "count" in parsed && typeof parsed.count === "number" ? parsed.count : names.length;
+	return { names, count: Math.max(count, names.length) };
+}
+
+function isName(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0;
+}

package/src/extension/kernel-replacement.ts

@@ -1,7 +1,10 @@
 import type { HostToKernelMessage } from "../bridge/protocol.ts";
+import { type HostMemoryReader, readHostMemoryState } from "../kernels/shared/host-memory-state.ts";
 import {
 	type KernelLifecycle,
 	KernelUnavailableError,
+	type LostGlobals,
+	replacedKernelNotice,
 	restartNotice,
 	unstartedResult,
 } from "../kernels/shared/kernel-death.ts";
@@ -13,10 +16,21 @@ import type {
 	KernelInterruptHandle,
 	PendingCell,
 } from "../tool/types.ts";
+import { KernelGlobalsLedger } from "./kernel-globals-ledger.ts";
 import { hasKernelTools, type KernelToolsMethods } from "./kernel-tools-probe.ts";
 
 export type StartKernel = (lifecycle: Required<KernelLifecycle>) => Promise<EvalKernel>;
 
+export interface ReplaceableKernelOptions {
+	/** Names the globals a death or an earlier generation of the session took with it. */
+	readonly ledger?: KernelGlobalsLedger;
+	/** Read when a SIGKILL nobody in senpi sent explains a death; the default asks the OS. */
+	readonly readHostMemory?: HostMemoryReader;
+}
+
+/** An unlabeled SIGKILL reaching a live host came from outside senpi: on a desktop, most often the OS under memory pressure. */
+const SIGKILL_REASON = "signal 9";
+
 class ReplaceableKernelClosedError extends Error {
 	readonly name = "ReplaceableKernelClosedError";
 
@@ -50,14 +64,25 @@ export class ReplaceableKernel implements EvalKernel {
 	#announce: string | null = null;
 	#closed = false;
 	#closeFailure: unknown;
+	readonly #ledger: KernelGlobalsLedger;
+	readonly #readHostMemory: HostMemoryReader;
+	/** What the instance held when it died, named by the replacement's notice. */
+	#lostAtDeath: LostGlobals | undefined;
 
 	// Present only when the instance has kernel tools, so a probe sees what it would see on the instance itself.
 	declare readonly describeKernelTools?: KernelToolsMethods["describeKernelTools"];
 	declare readonly invokeKernelTool?: KernelToolsMethods["invokeKernelTool"];
 
-	private constructor(language: EvalLanguage, start: StartKernel, first: EvalKernel) {
+	private constructor(
+		language: EvalLanguage,
+		start: StartKernel,
+		first: EvalKernel,
+		options: ReplaceableKernelOptions,
+	) {
 		this.#language = language;
 		this.#start = start;
+		this.#ledger = options.ledger ?? KernelGlobalsLedger.inMemory();
+		this.#readHostMemory = options.readHostMemory ?? readHostMemoryState;
 		this.#kernel = first;
 		// Python is the one subprocess kernel with kernel tools; rb and jl only carry tools_unavailable stubs to hide.
 		if (language === "py" && hasKernelTools(first)) {
@@ -77,7 +102,11 @@ export class ReplaceableKernel implements EvalKernel {
 	}
 
 	/** 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> {
+	static async create(
+		language: EvalLanguage,
+		start: StartKernel,
+		options: ReplaceableKernelOptions = {},
+	): Promise<EvalKernel> {
 		let owner: ReplaceableKernel | undefined;
 		const first = await start({
 			onDeath: (reason) => {
@@ -85,7 +114,7 @@ export class ReplaceableKernel implements EvalKernel {
 			},
 		});
 		if (first.drainPending === undefined) return first;
-		owner = new ReplaceableKernel(language, start, first);
+		owner = new ReplaceableKernel(language, start, first, options);
 		return owner;
 	}
 
@@ -123,6 +152,7 @@ export class ReplaceableKernel implements EvalKernel {
 	}
 
 	async reset(): Promise<void> {
+		this.#ledger.clear();
 		if (this.#replacing !== null) await this.#replacing;
 		if (this.#kernel.isAlive?.() === false) {
 			// A reset discards every global anyway, so the fresh instance announces nothing.
@@ -144,6 +174,7 @@ export class ReplaceableKernel implements EvalKernel {
 		if (this.#replacing !== null) await this.#replacing;
 		if (this.#closeFailure !== undefined) throw this.#closeFailure;
 		await this.#kernel.close();
+		await this.#ledger.flush();
 	}
 
 	listKernelToolNames(): readonly string[] {
@@ -159,7 +190,10 @@ export class ReplaceableKernel implements EvalKernel {
 			if (kernel.isAlive?.() === false)
 				return result.kernelState === undefined ? { ...result, kernelState: "lost" } : result;
 			this.#recovering = null;
-			const notice = this.#announce;
+			this.#ledger.observe(result);
+			const inherited = this.#ledger.takeInherited();
+			const notice =
+				this.#announce ?? (inherited.count > 0 ? replacedKernelNotice(this.#language, inherited) : null);
 			if (notice === null) return result;
 			this.#announce = null;
 			return { ...result, notice, kernelState: "restarted" };
@@ -169,6 +203,7 @@ export class ReplaceableKernel implements EvalKernel {
 	#died(generation: number, reason: string): void {
 		if (generation !== this.#generation || this.#closed) return;
 		this.#held = [...(this.#kernel.drainPending?.() ?? []), ...this.#held];
+		this.#lostAtDeath = this.#ledger.takeLost();
 		if (this.#recovering !== null) {
 			this.#recovering = null;
 			this.#unannounced = reason;
@@ -194,6 +229,9 @@ export class ReplaceableKernel implements EvalKernel {
 	/** Never rejects: every failure settles the held cells with what went wrong. */
 	async #replace(reason: string | null): Promise<void> {
 		const dead = this.#kernel;
+		// Composed while the old interpreter retires, and before the replacement starts: a death of the
+		// replacement must find it already current, with no await between its start and its adoption.
+		const announcing = reason === null ? Promise.resolve(null) : this.#restartNotice(reason);
 		try {
 			await dead.close();
 		} catch (error) {
@@ -201,6 +239,7 @@ export class ReplaceableKernel implements EvalKernel {
 			this.#failUnavailable(reason, `its interpreter could not be retired: ${errorText(error)}`);
 			return;
 		}
+		const announce = await announcing;
 		if (this.#closed) return;
 		const generation = ++this.#nextGeneration;
 		let next: EvalKernel;
@@ -218,7 +257,7 @@ export class ReplaceableKernel implements EvalKernel {
 		}
 		this.#kernel = next;
 		this.#generation = generation;
-		this.#announce = reason === null ? null : restartNotice(this.#language, reason);
+		this.#announce = announce;
 		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))),
@@ -226,6 +265,15 @@ export class ReplaceableKernel implements EvalKernel {
 		}
 	}
 
+	async #restartNotice(reason: string): Promise<string> {
+		const lost = this.#lostAtDeath;
+		this.#lostAtDeath = undefined;
+		if (!reason.startsWith(SIGKILL_REASON)) return restartNotice(this.#language, reason, lost);
+		const memory = await this.#readHostMemory();
+		const cause = `probably killed by the system, most often under memory pressure${memory === undefined ? "" : ` (${memory})`}`;
+		return restartNotice(this.#language, `${reason}, ${cause}`, lost);
+	}
+
 	#failUnavailable(reason: string | null, detail: string): void {
 		this.#recovering = null;
 		this.#unannounced = reason;

package/src/extension/session-manager.ts

@@ -16,6 +16,7 @@ import { type BridgeDispatchContext, dispatchBridgeCompletion } from "./bridge-d
 import { type BridgeToolCallRequest, routeBridgeToolCall } from "./bridge-tool-call.ts";
 import { CellKernelTools } from "./cell-kernel-tools.ts";
 import { parkWhenIdle } from "./idle-parking-kernel.ts";
+import { KernelGlobalsLedger } from "./kernel-globals-ledger.ts";
 import {
 	javaScriptKernelMemory,
 	SessionKernelRegistrations,
@@ -69,6 +70,8 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 	readonly #registrations: SessionKernelRegistrations;
 	#kernelCreations = new Map<EvalLanguage, Promise<EvalKernel>>();
 	#onMessageRefs = new Map<EvalLanguage, (message: KernelToHostMessage) => void>();
+	/** One per language for the manager's life, so an idle-park restart never re-announces an earlier generation. */
+	readonly #ledgers = new Map<EvalLanguage, Promise<KernelGlobalsLedger>>();
 	readonly #cellKernelTools = new CellKernelTools();
 	#context: ExtensionContext | undefined;
 	#generation = 0;
@@ -231,11 +234,21 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 	): Promise<{ readonly kernel: EvalKernel; readonly memory: RegisteredKernelSource | undefined }> {
 		if (language === "js") return await this.#createKernel(language, onMessage);
 		let memory: RegisteredKernelSource | undefined;
-		const kernel = await ReplaceableKernel.create(language, async (lifecycle) => {
-			const created = await this.#createKernel(language, onMessage, lifecycle);
-			memory ??= created.memory;
-			return created.kernel;
-		});
+		let ledger = this.#ledgers.get(language);
+		if (ledger === undefined) {
+			ledger = KernelGlobalsLedger.open(this.#options.artifactsDir, language);
+			this.#ledgers.set(language, ledger);
+		}
+		const options = { ledger: await ledger };
+		const kernel = await ReplaceableKernel.create(
+			language,
+			async (lifecycle) => {
+				const created = await this.#createKernel(language, onMessage, lifecycle);
+				memory ??= created.memory;
+				return created.kernel;
+			},
+			options,
+		);
 		return { kernel, memory };
 	}
 

package/src/kernels/py/death-reason.ts

@@ -0,0 +1,29 @@
+import type { KernelMemoryReport } from "../../bridge/memory-protocol.ts";
+import { describeExit } from "../shared/kernel-death.ts";
+import { formatBytes } from "../shared/kernel-memory.ts";
+
+/** Written by the prelude's parent watch (prelude.py `PARENT_WATCH_MARKER`) just before it kills its own group. */
+const PARENT_WATCH_MARKER = "[senpi] parent watch:";
+
+export interface PythonExit {
+	readonly code: number | null;
+	readonly signal: string | null;
+}
+
+/**
+ * Why an interpreter the host did not retire is gone, for the restart notice: the prelude's own parent
+ * watch names itself on stderr; anything else is its exit status, with the last memory the kernel
+ * reported so a reader can tell whether its own size could explain a kill by the system.
+ */
+export function pythonDeathReason(stderrTail: string, exit: PythonExit, lastMemory?: KernelMemoryReport): string {
+	const watch = stderrTail
+		.split("\n")
+		.find((line) => line.startsWith(PARENT_WATCH_MARKER))
+		?.slice(PARENT_WATCH_MARKER.length)
+		.trim();
+	if (watch !== undefined) return `senpi's parent watch stopped it (${watch})`;
+	const status = describeExit(exit.code, exit.signal);
+	if (lastMemory === undefined) return status;
+	const measure = lastMemory.measure === "heap" ? "live after GC" : "in its process footprint";
+	return `${status} (its last reading was ${formatBytes(lastMemory.liveBytes)} ${measure})`;
+}

package/src/kernels/py/kernel.ts

@@ -6,9 +6,9 @@ import type {
 	KernelToolsInvokeRequest,
 } from "../js/kernel-tools-types.ts";
 import { inputAtStart } from "../shared/cell-source-at-start.ts";
-import { describeExit } from "../shared/kernel-death.ts";
 import { KernelMemoryHost } from "../shared/kernel-memory-host.ts";
 import { KernelPreludeTracker } from "../shared/kernel-prelude-plan.ts";
+import { pythonDeathReason } from "./death-reason.ts";
 import { runHostCell } from "./host-cell.ts";
 import type { PendingRun, PythonKernelRunOptions, PythonKernelStartOptions, ResultMessage } from "./kernel-contract.ts";
 import { PythonKernelTools } from "./kernel-tools-host.ts";
@@ -41,6 +41,8 @@ export class PythonKernel {
 	#failure: Error | null = null;
 	readonly #preludes = new KernelPreludeTracker();
 	readonly #memory: KernelMemoryHost | null;
+	/** The newest reading the interpreter reported, named by a restart notice if it dies. */
+	#lastMemory: ResultMessage["memory"];
 	#generation = 0;
 	#closed = false;
 	readonly #tools: PythonKernelTools;
@@ -313,6 +315,7 @@ export class PythonKernel {
 	async #spawn(generation: number): Promise<void> {
 		if (this.#closed || generation !== this.#generation) throw new Error("Python kernel startup was superseded");
 		this.#memory?.processReplaced();
+		this.#lastMemory = undefined;
 		this.#transport = await PythonKernelTransport.start({
 			...this.#options,
 			onMessage: (message) => {
@@ -334,12 +337,14 @@ export class PythonKernel {
 			},
 			onResult: (transport, result) => this.#onResult(transport, result),
 			onError: (transport, error) => this.#onError(transport, error),
-			onExit: (transport, error, exit) => this.#onExit(transport, error, describeExit(exit.code, exit.signal)),
+			onExit: (transport, error, exit) =>
+				this.#onExit(transport, error, pythonDeathReason(error.message, exit, this.#lastMemory)),
 		});
 	}
 
 	#onResult(transport: PythonKernelTransport, result: ResultMessage): void {
 		if (this.#transport !== transport) return;
+		if (result.memory !== undefined) this.#lastMemory = result.memory;
 		const pending = this.#pending.get(result.cellId);
 		if (pending) {
 			const annotated = this.#memory?.annotate(result) ?? result;
@@ -403,11 +408,16 @@ export class PythonKernel {
 				);
 			},
 		);
+		// With an owner, the retired interpreter is a death like an exit (senpi#3612): replaced, and announced.
+		const onDeath = this.#options.onDeath;
+		if (onDeath) this.#dead = true;
 		const active = this.#active;
 		if (active) {
 			if (active.resolveStateRetained) active.resolveStateRetained(false);
-			this.#settleRun(active, failedPythonResult(active.input.cellId, "Python kernel died", error.message));
+			const message = onDeath ? "Python kernel died; every global is lost" : "Python kernel died";
+			this.#settleRun(active, failedPythonResult(active.input.cellId, message, error.message));
 		}
+		onDeath?.(`a failure of its control pipe (${error.message})`);
 	}
 
 	#settleRun(pending: PendingRun, result: ResultMessage): void {

package/src/kernels/py/prelude.py

@@ -2172,6 +2172,12 @@ async def run_code(code: Any, want_value: bool) -> Any:
     return None
 
 
+# Globals a tool prelude installs: the host reinstalls them on a fresh kernel, so they are never reported as lost.
+_PRELUDE_EXPORTS: set[str] = set()
+# The host keeps the newest list so a notice can name what a dead or replaced kernel took with it.
+_REPORTED_GLOBAL_NAMES = 64
+
+
 def apply_preludes(preludes: Any) -> None:
     # Host-computed per cell: globals of tools deactivated since the last cell are dropped,
     # and an active tool's snippet runs only while one of its exports is missing.
@@ -2179,11 +2185,22 @@ def apply_preludes(preludes: Any) -> None:
         return
     for name in preludes.get("remove", []):
         USER_NS.pop(name, None)
+        _PRELUDE_EXPORTS.discard(name)
     for contribution in preludes.get("install", []):
-        if any(name not in USER_NS for name in contribution.get("exports", [])):
+        exports = contribution.get("exports", [])
+        _PRELUDE_EXPORTS.update(exports)
+        if any(name not in USER_NS for name in exports):
             exec(compile(contribution.get("python", ""), "<kernel-prelude>", "exec"), USER_NS)
 
 
+def _user_global_names() -> list[str]:
+    return sorted(
+        name
+        for name in list(USER_NS)
+        if name not in _MEMORY_BASELINE and name not in _PRELUDE_EXPORTS and not name.startswith("__")
+    )
+
+
 def _enter_source_file(source_file: str | None) -> Callable[[], None]:
     # A %load cell runs as its file: __file__ names it and its directory comes first on the import path,
     # so `from sibling import x` resolves next to the file the way it does when the file runs as a script.
@@ -2272,6 +2289,9 @@ def run_cell(
         text("stderr", f"[senpi] kernel memory measurement failed: {exc}\n")
     if memory is not None:
         result["memory"] = memory
+    names = _user_global_names()
+    result["globalCount"] = len(names)
+    result["globalNames"] = names[:_REPORTED_GLOBAL_NAMES]
     emit(result)
 
 
@@ -2334,12 +2354,21 @@ def _activate_env_root(root: str) -> None:
     importlib.invalidate_caches()
 
 
-def _terminate_process_group() -> None:
+PARENT_WATCH_MARKER = "[senpi] parent watch:"
+
+
+def _terminate_process_group(reason: str) -> None:
     # The kernel is spawned into its own session (setsid), so its pid is its process
     # group id and a cell's subprocesses inherit that group. Killing the group takes
     # those children down with the kernel instead of orphaning them to init.
+    # The reason goes to the real stderr first: a host that is still alive names it in its restart notice.
     if os.name != "posix":
         return
+    stream = sys.__stderr__
+    if stream is not None:
+        with contextlib.suppress(OSError, ValueError):
+            stream.write(f"{PARENT_WATCH_MARKER} {reason}; stopping the kernel\n")
+            stream.flush()
     with contextlib.suppress(OSError):
         os.killpg(os.getpgrp(), signal.SIGKILL)
 
@@ -2350,8 +2379,9 @@ def _watch_parent(initial_ppid: int) -> None:
     # daemon thread notices the reparenting instead and takes the whole group down.
     while True:
         time.sleep(1.0)
-        if os.getppid() != initial_ppid:
-            _terminate_process_group()
+        current_ppid = os.getppid()
+        if current_ppid != initial_ppid:
+            _terminate_process_group(f"its parent process changed from {initial_ppid} to {current_ppid}")
             return
 
 
@@ -2366,7 +2396,7 @@ def _watch_named_parent(parent_pid: int) -> None:
         try:
             os.kill(parent_pid, 0)
         except ProcessLookupError:
-            _terminate_process_group()
+            _terminate_process_group(f"its host process {parent_pid} is gone")
             return
 
 
@@ -2422,7 +2452,7 @@ def main() -> None:
     # Reaching here without a close frame means the host's pipe hit EOF: it is gone,
     # so retire any subprocess the last cell left running before the interpreter exits.
     if not host_closed:
-        _terminate_process_group()
+        _terminate_process_group("its host closed the control pipe")
 
 
 if __name__ == "__main__":

package/src/kernels/py/transport.ts

@@ -70,6 +70,8 @@ export interface PythonTransportOptions {
 }
 
 const hardKillWaitMs = 500;
+/** How long a broken control pipe waits for the interpreter's exit, which carries the real cause of the death. */
+const pipeErrorExitWaitMs = 1_000;
 
 export interface PythonPreludePathOptions extends CodemodeRuntimeAssetEnvironment {
 	readonly localPath?: string;
@@ -95,6 +97,7 @@ export class PythonKernelTransport {
 	#retirement: Promise<void> | null = null;
 	#gone: Promise<void> | null = null;
 	#isGone = false;
+	#pipeErrorTimer: NodeJS.Timeout | null = null;
 
 	private constructor(options: PythonTransportOptions, child: KernelChild) {
 		this.#options = options;
@@ -245,9 +248,11 @@ export class PythonKernelTransport {
 		this.#child.on("error", onError);
 		this.#child.on("exit", onExit);
 		// senpi#3016: a frame written while the interpreter is dying fails on the stdin stream (EPIPE), not on the child.
-		// #onError already ignores it once the child has exited or the transport is inactive, and the listener is never
-		// detached, so a late write failure is never unhandled.
-		this.#child.stdin.on("error", onError);
+		// The listener is never detached, so a late write failure is never unhandled. senpi#3612: that failure can be
+		// processed before the child's exit; the exit then reports the death, with its signal.
+		this.#child.stdin.on("error", (error: unknown) =>
+			this.#onPipeError(error instanceof Error ? error : new Error(String(error))),
+		);
 		const { sessionId, connection, memory, kernelGeneration } = this.#options;
 		this.#write({
 			type: "init",
@@ -305,6 +310,7 @@ export class PythonKernelTransport {
 	#onExit(code: number | null, signal: string | null): void {
 		if (this.#exited) return;
 		this.#exited = true;
+		this.#clearPipeErrorTimer();
 		const active = this.#active;
 		this.#active = false;
 		const error = new Error(this.#stderrTail.trim() || `Python kernel exited (${code ?? signal ?? "unknown"})`);
@@ -315,10 +321,27 @@ export class PythonKernelTransport {
 
 	#onError(error: Error): void {
 		if (this.#exited || !this.#active) return;
+		this.#clearPipeErrorTimer();
 		this.#active = false;
 		if (!this.#settleStartup(error)) this.#options.onError(this, error);
 	}
 
+	/** A broken control pipe means the interpreter is gone or going: its exit, not this error, reports the death. */
+	#onPipeError(error: Error): void {
+		if (this.#exited || !this.#active || this.#pipeErrorTimer !== null) return;
+		this.#pipeErrorTimer = setTimeout(() => {
+			this.#pipeErrorTimer = null;
+			this.#onError(error);
+		}, pipeErrorExitWaitMs);
+		this.#pipeErrorTimer.unref?.();
+	}
+
+	#clearPipeErrorTimer(): void {
+		if (this.#pipeErrorTimer === null) return;
+		clearTimeout(this.#pipeErrorTimer);
+		this.#pipeErrorTimer = null;
+	}
+
 	#detachListeners(): void {
 		const detach = this.#detachChildListeners;
 		if (!detach) return;

package/src/kernels/shared/host-memory-state.ts

@@ -0,0 +1,65 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { formatBytes } from "./kernel-memory.ts";
+
+const READ_TIMEOUT_MS = 1_000;
+const MIB = 1024 * 1024;
+const KIB = 1024;
+
+/** kern.memorystatus_vm_pressure_level: the kernel's own verdict, the one jetsam acts on. */
+const DARWIN_PRESSURE_LEVELS: Readonly<Record<string, string>> = { "1": "normal", "2": "warning", "4": "critical" };
+
+export type HostMemoryReader = () => Promise<string | undefined>;
+
+/**
+ * The host's memory state in a few words, for a notice about a kernel the system may have killed:
+ * macOS memory pressure and swap in use, Linux available memory and swap in use. `undefined` when the
+ * platform has no reading or it could not be taken in time; the notice then simply says less.
+ */
+export const readHostMemoryState: HostMemoryReader = async () => {
+	try {
+		if (process.platform === "darwin") return describeDarwin(await sysctl());
+		if (process.platform === "linux") return describeLinux(await readFile("/proc/meminfo", "utf8"));
+		return undefined;
+	} catch {
+		return undefined;
+	}
+};
+
+function sysctl(): Promise<string> {
+	return new Promise((resolve, reject) => {
+		execFile(
+			"sysctl",
+			["-n", "kern.memorystatus_vm_pressure_level", "vm.swapusage"],
+			{ encoding: "utf8", timeout: READ_TIMEOUT_MS, env: { ...process.env, LC_ALL: "C" } },
+			(error, stdout) => (error ? reject(error) : resolve(stdout)),
+		);
+	});
+}
+
+export function describeDarwin(output: string): string | undefined {
+	const [levelLine = "", swapLine = ""] = output.trim().split("\n");
+	const parts: string[] = [];
+	const level = DARWIN_PRESSURE_LEVELS[levelLine.trim()];
+	if (level !== undefined) parts.push(`system memory pressure ${level}`);
+	const used = /used = ([\d.]+)M/u.exec(swapLine)?.[1];
+	if (used !== undefined) parts.push(`swap used ${formatBytes(Number(used) * MIB)}`);
+	return parts.length === 0 ? undefined : parts.join(", ");
+}
+
+export function describeLinux(meminfo: string): string | undefined {
+	const kib = (key: string): number | undefined => {
+		const value = new RegExp(`^${key}:\\s+(\\d+) kB$`, "mu").exec(meminfo)?.[1];
+		return value === undefined ? undefined : Number(value) * KIB;
+	};
+	const available = kib("MemAvailable");
+	const total = kib("MemTotal");
+	const swapTotal = kib("SwapTotal");
+	const swapFree = kib("SwapFree");
+	const parts: string[] = [];
+	if (available !== undefined && total !== undefined)
+		parts.push(`${formatBytes(available)} of ${formatBytes(total)} memory available`);
+	if (swapTotal !== undefined && swapFree !== undefined && swapTotal > 0)
+		parts.push(`swap used ${formatBytes(swapTotal - swapFree)}`);
+	return parts.length === 0 ? undefined : parts.join(", ");
+}

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

@@ -16,8 +16,28 @@ export function describeExit(code: number | null, signal: string | null): string
 	return code === null ? "an exit with no status" : `exit code ${code}`;
 }
 
-export function restartNotice(language: EvalLanguage, reason: string): string {
-	return `[${language} kernel was restarted after ${reason}; every global is lost]`;
+/** Globals a lost kernel held, as its last result reported them: their names and how many there were in all. */
+export interface LostGlobals {
+	readonly names: readonly string[];
+	readonly count: number;
+}
+
+const NAMED_LOST_GLOBALS = 20;
+
+export function restartNotice(language: EvalLanguage, reason: string, lost?: LostGlobals): string {
+	return `[${language} kernel was restarted after ${reason}; every global is lost${lostPhrase(lost)}]`;
+}
+
+/** The first result of a session's kernel when an earlier kernel of the same session ended with globals defined. */
+export function replacedKernelNotice(language: EvalLanguage, lost: LostGlobals): string {
+	return `[${language} kernel is new: this session's previous ${language} kernel ended (session reload, host restart, or resume), so every global it held is gone${lostPhrase(lost)}]`;
+}
+
+function lostPhrase(lost: LostGlobals | undefined): string {
+	if (lost === undefined || lost.count === 0) return "";
+	const named = lost.names.slice(0, NAMED_LOST_GLOBALS);
+	const more = lost.count - named.length;
+	return `. Lost: ${named.join(", ")}${more > 0 ? ` and ${more} more` : ""}`;
 }
 
 export const EVAL_KERNEL_UNAVAILABLE = "eval_kernel_unavailable";