@code-yeongyu/senpi-codemode 2026.9.28 → 2026.9.29-3

package/CHANGELOG.md

@@ -12,6 +12,129 @@
 
 ### Removed
 
+## [2026.9.29-3] - 2026-09-29
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.29-2] - 2026-09-29
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.29] - 2026-09-29
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.28-7] - 2026-09-28
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.28-6] - 2026-09-28
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.28-5] - 2026-09-28
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.28-4] - 2026-09-28
+
+### Breaking Changes
+
+### Added
+
+- JavaScript eval kernels report their memory: a result whose kernel holds at least `memory.noticeMb` (default 1 GiB) live after a collection carries one bracketed notice naming the largest globals and how to drop them, plus `details.memory` (`liveBytes`, `gcRan`, `globals`). A kernel whose live memory reaches `memory.ceilingMb` (default a quarter of physical memory, 2-8 GiB) says so in that result and restarts once no cell is running or queued on it; the next result reports `details.memory.recycled`. Settings `memory.gcWatermarkMb`, `memory.noticeMb`, `memory.ceilingMb` and their `SENPI_CODEMODE_MEMORY_*_MB` overrides; `0` disables each. ([#2261](https://github.com/code-yeongyu/senpi/issues/2261))
+- Python eval kernels follow the same memory contract: after each cell the kernel reads its process footprint (macOS `phys_footprint`, Linux `RssAnon`, Windows `PrivateUsage`), runs `gc.collect()` plus glibc `malloc_trim(0)` when it grew past `memory.gcWatermarkMb`, and a result at `memory.noticeMb` names the largest globals (numpy `nbytes`, pandas `memory_usage(deep=True)`, sampled containers) with `del <name>` advice; at `memory.ceilingMb` the Python kernel restarts once its queue is empty and the next result reports `details.memory.recycled`. Ruby and Julia kernels get the ceiling restart from the interpreter footprint the host reads after each result (no globals list). ([#2261](https://github.com/code-yeongyu/senpi/issues/2261))
+
+### Changed
+
+### Fixed
+
+- Retiring a JavaScript eval worker (timeout, interrupt, reset, crash, or memory-ceiling restart) no longer leaves each child process the cell was still running as a zombie of the host: the host now collects them after killing them. Measured: 30 retirements that each left two children went from 60 zombies to 0. ([#1962](https://github.com/code-yeongyu/senpi/issues/1962))
+- A persistent eval kernel no longer pins its first cell's handler for the whole kernel generation. The kernel dispatcher is now a bound method of the session manager instead of a closure over the `getKernel` call that created the kernel (under Bun/JSC that closure retained the creating cell's `onMessage` — its output buffers and display images — until the kernel was reset), and every cell releases its kernel listener once it settles, so nothing keeps a settled cell's state alive. Interpreter startup stderr still reaches the cell that created the kernel; a message arriving between cells reaches no settled handler. ([#2260](https://github.com/code-yeongyu/senpi/issues/2260))
+- Memory a JavaScript eval cell no longer references returns to the machine without a reset: a finished cell whose heap grew past `memory.gcWatermarkMb` (default 256 MiB) runs a full collection, and on Node and on Bun before 1.4.3 a kernel still holding that much runs an idle collection about a second after its last cell, so `delete globalThis.rows` no longer leaves gigabytes resident until the kernel is reset (Bun 1.4.3 collects idle threads itself). ([#2261](https://github.com/code-yeongyu/senpi/issues/2261))
+
+- Settled eval cells kept for `peek`/`list` no longer pin up to ~800 MB of image data in the session's memory. Their images are written to `<session artifacts>/settled-images/` and read back on `peek`, which still returns the full result. The files are bounded by the new `memory.retainedImagesMb` setting (default 256, env `SENPI_CODEMODE_RETAINED_IMAGES_MB`), deleted with an evicted cell, and removed when the session ends. The in-memory snapshots are bounded by the new `memory.retainedResultsMb` setting (default 32, env `SENPI_CODEMODE_RETAINED_RESULTS_MB`) on top of the 32-cell count cap. ([#2259](https://github.com/code-yeongyu/senpi/issues/2259))
+
+- The JavaScript eval kernel no longer compiles a fresh code-cache entry for its loader prelude on every cell: the prelude is evaluated under one stable source URL (`senpi:kernel-prelude`) instead of a per-cell `` `${cellId}:prelude` `` URL, so identical prelude text reuses the engine's eval code cache: per-cell kernel heap growth over a 1,000-cell series drops from ~2.3 KB to ~1.1 KB (the remainder is the cell body's own per-cell source URL, kept for stack attribution and bounded by the engine's code-cache cap). Stack frames from prelude code now attribute to `senpi:kernel-prelude` for every cell. ([#2263](https://github.com/code-yeongyu/senpi/issues/2263))
+
+### Removed
+
+## [2026.9.28-3] - 2026-09-28
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Live output updates for eval cells no longer rebuild the retained output tail on every chunk. The streaming preview keeps the last eight lines of the trailing byte window, appends in time proportional to the chunk, and output-driven updates are coalesced to one per 100 ms (the core bash tool's cadence), so a cell printing 30,000 lines sends about 10 updates instead of 30,008 and finishes about 4x faster with a lower memory peak. The final result and the text of each update are unchanged. ([#2262](https://github.com/code-yeongyu/senpi/issues/2262))
+
+- `new Bun.WebView()` in a JavaScript eval cell no longer fails with `Bun.WebView with backend "chrome" is only available on the main thread` (every call on Windows and Linux, `backend: "chrome"` on macOS). Cells see a `Bun` whose `WebView` (also through `import { WebView } from "bun"`) hands Chrome-backed views to the process main thread with the same API: navigation, input, `evaluate`, screenshots, `cdp()` and its events, `console` capture, `url`/`title`/`loading`, `close()` and `await using`. The macOS default (WebKit) stays a native view in the kernel worker. `Bun.WebView.closeAll()` in a cell closes only that kernel's views. ([#2248](https://github.com/code-yeongyu/senpi/issues/2248))
+
+### Removed
+
+## [2026.9.28-2] - 2026-09-28
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.9.28] - 2026-09-28
 
 ### Breaking Changes

package/README.md

@@ -105,7 +105,14 @@ Configuration is loaded in this order:
     "headBytes": 20480,
     "maxColumns": 768
   },
-  "statusEvents": true
+  "statusEvents": true,
+  "memory": {
+    "gcWatermarkMb": 256,
+    "noticeMb": 1024,
+    "ceilingMb": 8192,
+    "retainedResultsMb": 32,
+    "retainedImagesMb": 256
+  }
 }
 ```
 
@@ -123,6 +130,11 @@ Configuration is loaded in this order:
 | `outputSink.headBytes` | `20480` | Bytes retained from the beginning of a middle-truncated preview; `0` disables it. |
 | `outputSink.maxColumns` | `768` | Maximum rendered output columns; `0` disables column clamping. |
 | `statusEvents` | `true` | Enables kernel status-event forwarding and rendering. Each cell retains at most 100 status rows; after overflow, one omitted-count row precedes the latest 99 events. |
+| `memory.gcWatermarkMb` | `256` | JavaScript kernel: a finished cell whose heap reached this size and grew runs a full collection before its result; whenever at least this much stays live, an idle full collection runs about a second after the cell, so dropped globals return their memory without a reset. Python kernel: a finished cell whose process footprint reached this size and grew runs `gc.collect()` (plus glibc `malloc_trim(0)` on Linux) before its result, and while at least this much stays live the next cells collect too (at most 1/20 of the time), so `del rows` returns its memory. `0` disables. Env override: `SENPI_CODEMODE_MEMORY_GC_WATERMARK_MB`. |
+| `memory.noticeMb` | `1024` | JavaScript and Python kernels: when live memory after a collection (JS heap, Python process footprint) reaches this size (first time, or 25% more than at the last notice), the result gets one bracketed notice naming the largest globals and how to drop them (`rows = undefined`, `del rows`), plus `details.memory`. Ruby and Julia get no notice. `0` disables. Env override: `SENPI_CODEMODE_MEMORY_NOTICE_MB`. |
+| `memory.ceilingMb` | a quarter of physical memory, 2048-8192 | Every kernel (JS heap and Python footprint after a collection; Ruby and Julia interpreter footprint read by the host after each result, without a globals list): when live memory reaches this size, the result says so and the kernel restarts once no cell is running or queued on it; the next result says it was restarted (`details.memory.recycled`). `0` disables. Env override: `SENPI_CODEMODE_MEMORY_CEILING_MB`. Non-zero memory thresholds must satisfy watermark <= notice <= ceiling, otherwise all three use their defaults. |
+| `memory.retainedResultsMb` | `32` | In-memory byte budget (MiB) for the settled cells kept for `peek`/`list`, on top of the 32-cell count cap; the oldest go first and the newest is always kept. `0` keeps only the count cap. Env override: `SENPI_CODEMODE_RETAINED_RESULTS_MB` (a non-negative integer). |
+| `memory.retainedImagesMb` | `256` | Disk budget (MiB) for settled-cell images. Images of settled cells (foreground and detached) are written as base64 files under `<session artifacts>/settled-images/` instead of staying in memory, and `peek` reads them back, so it returns the full result. Beyond the budget the oldest files are deleted first; an evicted cell's files are deleted with it; the directory is removed when the session ends. A `peek` whose image file is gone returns the text plus a one-line note. `0` keeps only the count cap. Env override: `SENPI_CODEMODE_RETAINED_IMAGES_MB` (a non-negative integer). |
 
 `SENPI_CODEMODE_PY`, `SENPI_CODEMODE_JS`, `SENPI_CODEMODE_RB`, and
 `SENPI_CODEMODE_JL` override the corresponding file setting. `1` or `true`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.28",
+	"version": "2026.9.29-3",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.28",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.29-3",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.28"
+		"@code-yeongyu/senpi": "2026.9.29-3"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.28"
+		"@code-yeongyu/senpi": "2026.9.29-3"
 	},
 	"keywords": [
 		"senpi",

package/src/bridge/memory-protocol.ts

@@ -0,0 +1,39 @@
+import { type Static, Type } from "typebox";
+
+/** Host -> kernel (`init`): byte thresholds for post-cell collection, the large-globals notice, and the ceiling; 0 disables each. */
+export const kernelMemoryThresholdsSchema = Type.Object({
+	gcWatermarkBytes: Type.Integer({ minimum: 0 }),
+	noticeBytes: Type.Integer({ minimum: 0 }),
+	ceilingBytes: Type.Integer({ minimum: 0 }),
+});
+
+const kernelMemoryGlobalSchema = Type.Object({
+	name: Type.String({ minLength: 1 }),
+	bytes: Type.Integer({ minimum: 0 }),
+	approximate: Type.Optional(Type.Boolean()),
+});
+
+/**
+ * Kernel -> host memory report carried on the `result` frame. The kernel sets `liveBytes`, `measure`,
+ * `gcRan`, and `globals`; the kernel host adds `overCeiling`, `recycled`, and the `notice` text.
+ */
+export const kernelMemoryReportSchema = Type.Object({
+	liveBytes: Type.Integer({ minimum: 0 }),
+	measure: Type.Union([Type.Literal("heap"), Type.Literal("footprint")]),
+	/** `liveBytes` is a peak-RSS fallback (no footprint counter on this platform), not the current size. */
+	approximate: Type.Optional(Type.Boolean()),
+	/** `liveBytes` was measured right after a full collection in this cell. */
+	gcRan: Type.Optional(Type.Boolean()),
+	/** Largest user globals, measured only when live memory after collection reached the notice threshold. */
+	globals: Type.Optional(Type.Array(kernelMemoryGlobalSchema, { maxItems: 8 })),
+	/** Host-set: live memory after collection reached the ceiling; the kernel restarts once its queue drains. */
+	overCeiling: Type.Optional(Type.Boolean()),
+	/** Host-set: this is the first result on a kernel that was restarted for exceeding the ceiling. */
+	recycled: Type.Optional(Type.Boolean()),
+	/** Host-set: the bracketed notice shown to the model as its own text part. */
+	notice: Type.Optional(Type.String()),
+});
+
+export type KernelMemoryThresholds = Static<typeof kernelMemoryThresholdsSchema>;
+export type KernelMemoryReport = Static<typeof kernelMemoryReportSchema>;
+export type KernelMemoryGlobal = Static<typeof kernelMemoryGlobalSchema>;

package/src/bridge/protocol.ts

@@ -2,6 +2,7 @@ import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypt
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
 import { kernelToolHostToKernelSchemas, kernelToolKernelToHostSchemas } from "./kernel-tools-protocol.ts";
+import { kernelMemoryReportSchema, kernelMemoryThresholdsSchema } from "./memory-protocol.ts";
 
 export const BRIDGE_FRAME_MAX_BYTES = 10 * 1024 * 1024;
 
@@ -31,6 +32,7 @@ const hostToKernelMessageSchema = Type.Union([
 		kernelGeneration: Type.Optional(Type.Integer({ minimum: 1 })),
 		hostToolNames: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
 		foreignLanguageNames: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+		memory: Type.Optional(kernelMemoryThresholdsSchema),
 	}),
 	Type.Object({
 		type: Type.Literal("run"),
@@ -66,6 +68,19 @@ const hostToKernelMessageSchema = Type.Union([
 	Type.Object({
 		type: Type.Literal("close"),
 	}),
+	/** JS only: the kernel's private port to the main-thread Bun.WebView service, sent in the transfer list. */
+	Type.Object({
+		type: Type.Literal("webview-port"),
+		requestId: Type.String({ minLength: 1 }),
+		ok: Type.Literal(true),
+		port: Type.Unknown(),
+	}),
+	Type.Object({
+		type: Type.Literal("webview-port"),
+		requestId: Type.String({ minLength: 1 }),
+		ok: Type.Literal(false),
+		error: bridgeErrorSchema,
+	}),
 	...kernelToolHostToKernelSchemas,
 ]);
 
@@ -97,6 +112,7 @@ const kernelToHostMessageSchema = Type.Union([
 		ok: Type.Literal(true),
 		valueRepr: Type.Optional(Type.String()),
 		durationMs: Type.Integer({ minimum: 0 }),
+		memory: Type.Optional(kernelMemoryReportSchema),
 	}),
 	Type.Object({
 		type: Type.Literal("result"),
@@ -104,8 +120,10 @@ const kernelToHostMessageSchema = Type.Union([
 		ok: Type.Literal(false),
 		error: bridgeErrorSchema,
 		durationMs: Type.Integer({ minimum: 0 }),
+		memory: Type.Optional(kernelMemoryReportSchema),
 	}),
 	Type.Object({ type: Type.Literal("closed") }),
+	Type.Object({ type: Type.Literal("webview-connect"), requestId: Type.String({ minLength: 1 }) }),
 	...kernelToolKernelToHostSchemas,
 ]);
 

package/src/bridge/reserved.ts

@@ -13,3 +13,5 @@ export const TIMEOUT_RESUME_OP = "timeout-resume" as const;
 export const INTERRUPT_ACK_OP = "interrupt-ack" as const;
 /** Status op the JS worker emits when a cell child is tracked or exits, so the host can retire it if the worker is lost. */
 export const CHILD_LIFECYCLE_OP = "child" as const;
+/** Status op the JS worker emits after an idle full collection between cells, carrying the live heap it measured. */
+export const MEMORY_COLLECTED_OP = "memory-collected" as const;

package/src/config/memory-settings.ts

@@ -0,0 +1,149 @@
+import { totalmem } from "node:os";
+import { type Static, Type } from "typebox";
+import type { KernelMemoryThresholds } from "../bridge/memory-protocol.ts";
+import type { CodemodeSettings, Environment } from "./settings.ts";
+
+export const memorySettingsSchema = Type.Object(
+	{
+		gcWatermarkMb: Type.Optional(Type.Number({ minimum: 0 })),
+		noticeMb: Type.Optional(Type.Number({ minimum: 0 })),
+		ceilingMb: Type.Optional(Type.Number({ minimum: 0 })),
+		retainedResultsMb: Type.Optional(Type.Number({ minimum: 0 })),
+		retainedImagesMb: Type.Optional(Type.Number({ minimum: 0 })),
+	},
+	{ additionalProperties: false },
+);
+
+export type CodemodeMemorySettingsInput = Static<typeof memorySettingsSchema>;
+
+export interface CodemodeMemorySettings {
+	/** Live kernel memory from which a finished cell triggers a full collection. */
+	readonly gcWatermarkMb: number;
+	/** Live kernel memory after collection from which a result names the largest globals. */
+	readonly noticeMb: number;
+	/** Live kernel memory after collection from which the kernel restarts once its queue drains. */
+	readonly ceilingMb: number;
+	/** In-memory byte budget (MiB) for settled-cell snapshots kept for `peek`/`list`; 0 keeps only the count cap. */
+	readonly retainedResultsMb: number;
+	/** Disk budget (MiB) for settled-cell images spilled under the session artifacts dir; 0 keeps only the count cap. */
+	readonly retainedImagesMb: number;
+}
+
+export const DEFAULT_MEMORY_GC_WATERMARK_MB = 256;
+export const DEFAULT_MEMORY_NOTICE_MB = 1024;
+export const DEFAULT_RETAINED_RESULTS_MB = 32;
+export const DEFAULT_RETAINED_IMAGES_MB = 256;
+const CEILING_FLOOR_MB = 2048;
+const CEILING_CAP_MB = 8192;
+
+export const MEMORY_GC_WATERMARK_ENVIRONMENT_FLAG = "SENPI_CODEMODE_MEMORY_GC_WATERMARK_MB";
+export const MEMORY_NOTICE_ENVIRONMENT_FLAG = "SENPI_CODEMODE_MEMORY_NOTICE_MB";
+export const MEMORY_CEILING_ENVIRONMENT_FLAG = "SENPI_CODEMODE_MEMORY_CEILING_MB";
+export const RETAINED_RESULTS_ENVIRONMENT_FLAG = "SENPI_CODEMODE_RETAINED_RESULTS_MB";
+export const RETAINED_IMAGES_ENVIRONMENT_FLAG = "SENPI_CODEMODE_RETAINED_IMAGES_MB";
+
+const MIB = 1024 * 1024;
+
+export function defaultMemoryCeilingMb(totalBytes: number = totalmem()): number {
+	const quarterMb = Math.floor(totalBytes / MIB / 4);
+	return Math.min(CEILING_CAP_MB, Math.max(CEILING_FLOOR_MB, quarterMb));
+}
+
+export function defaultMemorySettings(totalBytes?: number): CodemodeMemorySettings {
+	return {
+		gcWatermarkMb: DEFAULT_MEMORY_GC_WATERMARK_MB,
+		noticeMb: DEFAULT_MEMORY_NOTICE_MB,
+		ceilingMb: defaultMemoryCeilingMb(totalBytes),
+		retainedResultsMb: DEFAULT_RETAINED_RESULTS_MB,
+		retainedImagesMb: DEFAULT_RETAINED_IMAGES_MB,
+	};
+}
+
+export function mergeMemorySettings(input: CodemodeMemorySettingsInput | undefined): CodemodeMemorySettings {
+	const defaults = defaultMemorySettings();
+	return {
+		gcWatermarkMb: input?.gcWatermarkMb ?? defaults.gcWatermarkMb,
+		noticeMb: input?.noticeMb ?? defaults.noticeMb,
+		ceilingMb: input?.ceilingMb ?? defaults.ceilingMb,
+		retainedResultsMb: input?.retainedResultsMb ?? defaults.retainedResultsMb,
+		retainedImagesMb: input?.retainedImagesMb ?? defaults.retainedImagesMb,
+	};
+}
+
+export function memorySettingsOrderWarning(memory: CodemodeMemorySettings): string | undefined {
+	const enabled = [memory.gcWatermarkMb, memory.noticeMb, memory.ceilingMb].filter((value) => value > 0);
+	const ordered = enabled.every((value, index) => index === 0 || (enabled[index - 1] ?? 0) <= value);
+	if (ordered) return undefined;
+	return `Codemode memory thresholds must satisfy gcWatermarkMb <= noticeMb <= ceilingMb (got ${memory.gcWatermarkMb}, ${memory.noticeMb}, ${memory.ceilingMb}); using the defaults.`;
+}
+
+/** File thresholds out of order fall back to the defaults with a warning; the settled-cell budgets are kept. */
+export function validatedMemorySettings(input: CodemodeMemorySettingsInput | undefined): {
+	readonly settings: CodemodeMemorySettings;
+	readonly warnings: readonly string[];
+} {
+	const merged = mergeMemorySettings(input);
+	const warning = memorySettingsOrderWarning(merged);
+	if (warning === undefined) return { settings: merged, warnings: [] };
+	const defaults = defaultMemorySettings();
+	return {
+		settings: {
+			...defaults,
+			retainedResultsMb: merged.retainedResultsMb,
+			retainedImagesMb: merged.retainedImagesMb,
+		},
+		warnings: [warning],
+	};
+}
+
+/**
+ * Environment overrides win over the settings file; `0` disables a threshold, and a malformed value is
+ * ignored. Thresholds out of order after the overrides fall back to the defaults.
+ */
+export function resolveKernelMemoryThresholds(
+	memory: CodemodeMemorySettings | undefined,
+	env: Environment = process.env,
+): KernelMemoryThresholds {
+	const base = memory ?? defaultMemorySettings();
+	const resolved: CodemodeMemorySettings = {
+		...base,
+		gcWatermarkMb: megabytesOverride(env[MEMORY_GC_WATERMARK_ENVIRONMENT_FLAG]) ?? base.gcWatermarkMb,
+		noticeMb: megabytesOverride(env[MEMORY_NOTICE_ENVIRONMENT_FLAG]) ?? base.noticeMb,
+		ceilingMb: megabytesOverride(env[MEMORY_CEILING_ENVIRONMENT_FLAG]) ?? base.ceilingMb,
+	};
+	const effective = memorySettingsOrderWarning(resolved) === undefined ? resolved : defaultMemorySettings();
+	return {
+		gcWatermarkBytes: Math.round(effective.gcWatermarkMb * MIB),
+		noticeBytes: Math.round(effective.noticeMb * MIB),
+		ceilingBytes: Math.round(effective.ceilingMb * MIB),
+	};
+}
+
+/** Settled-cell in-memory snapshot byte budget; the environment override accepts 0 (count cap only). */
+export function resolveRetainedResultsBytes(settings: CodemodeSettings, env: Environment = process.env): number {
+	const megabytes =
+		nonNegativeIntegerOverride(env[RETAINED_RESULTS_ENVIRONMENT_FLAG]) ??
+		settings.memory?.retainedResultsMb ??
+		DEFAULT_RETAINED_RESULTS_MB;
+	return megabytes * MIB;
+}
+
+/** Settled-cell image spill disk budget; the environment override accepts 0 (count cap only). */
+export function resolveRetainedImagesBytes(settings: CodemodeSettings, env: Environment = process.env): number {
+	const megabytes =
+		nonNegativeIntegerOverride(env[RETAINED_IMAGES_ENVIRONMENT_FLAG]) ??
+		settings.memory?.retainedImagesMb ??
+		DEFAULT_RETAINED_IMAGES_MB;
+	return megabytes * MIB;
+}
+
+function megabytesOverride(value: string | undefined): number | undefined {
+	if (value === undefined || value.trim() === "") return undefined;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+
+function nonNegativeIntegerOverride(value: string | undefined): number | undefined {
+	if (value === undefined || !/^\s*\d+\s*$/u.test(value)) return undefined;
+	return Number.parseInt(value, 10);
+}

package/src/config/settings.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import type { Static } from "typebox";
 import { Type } from "typebox";
 import { Check } from "typebox/value";
+import { type CodemodeMemorySettings, memorySettingsSchema, validatedMemorySettings } from "./memory-settings.ts";
 
 export const codemodeSettingsSchema = Type.Object(
 	{
@@ -43,6 +44,7 @@ export const codemodeSettingsSchema = Type.Object(
 			),
 		),
 		statusEvents: Type.Optional(Type.Boolean()),
+		memory: Type.Optional(memorySettingsSchema),
 	},
 	{ additionalProperties: false },
 );
@@ -87,6 +89,7 @@ export interface CodemodeSettings {
 	readonly taskTools?: CodemodeTaskTools;
 	readonly outputSink?: CodemodeOutputSink;
 	readonly statusEvents?: boolean;
+	readonly memory?: CodemodeMemorySettings;
 }
 
 export type ResolvedCodemodeSettings = CodemodeSettings & {
@@ -94,6 +97,7 @@ export type ResolvedCodemodeSettings = CodemodeSettings & {
 	readonly taskTools: CodemodeTaskTools;
 	readonly outputSink: CodemodeOutputSink;
 	readonly statusEvents: boolean;
+	readonly memory: CodemodeMemorySettings;
 };
 
 export interface LoadCodemodeSettingsOptions {
@@ -162,6 +166,7 @@ export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
 		maxColumns: 768,
 	},
 	statusEvents: true,
+	memory: validatedMemorySettings(undefined).settings,
 };
 
 const languageEnvironmentFlags = {
@@ -171,7 +176,7 @@ const languageEnvironmentFlags = {
 	jl: "SENPI_CODEMODE_JL",
 } as const;
 
-type Environment = Readonly<Record<string, string | undefined>>;
+export type Environment = Readonly<Record<string, string | undefined>>;
 
 export async function loadCodemodeSettings(options: LoadCodemodeSettingsOptions = {}): Promise<LoadedCodemodeSettings> {
 	const cwd = options.cwd ?? process.cwd();
@@ -252,7 +257,7 @@ async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
 		};
 	}
 
-	return { settings: mergeSettings(parsed), source: path, warnings: [] };
+	return { settings: mergeSettings(parsed), source: path, warnings: validatedMemorySettings(parsed.memory).warnings };
 }
 
 function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
@@ -278,6 +283,7 @@ function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
 			maxColumns: input.outputSink?.maxColumns ?? defaultCodemodeSettings.outputSink.maxColumns,
 		},
 		statusEvents: input.statusEvents ?? defaultCodemodeSettings.statusEvents,
+		memory: validatedMemorySettings(input.memory).settings,
 	};
 }
 

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

@@ -100,6 +100,12 @@ export class SessionManagerProxy implements CodemodeSessionManager, EvalExecutio
 		return await current.getKernel(language, onMessage);
 	}
 
+	releaseKernelListener(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): void {
+		// Best-effort like the rest of the proxy surface: a replaced or disposed
+		// generation has already cleared its listener refs, so there is nothing to release.
+		this.#current?.releaseKernelListener?.(language, onMessage);
+	}
+
 	async complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult> {
 		this.assertEvalExecutionAllowed();
 		const current = this.#current;

package/src/extension/session-manager.ts

@@ -1,11 +1,13 @@
 import { join } from "node:path";
-import type { ExtensionContext } from "@code-yeongyu/senpi";
+import { type ExtensionContext, readProcessFootprint } from "@code-yeongyu/senpi";
 import { type BridgeServerHandle, startBridgeServer } from "../bridge/http-server.ts";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import { isReservedToolName, runReservedTool } from "../bridges/reserved-dispatch.ts";
 import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import { resolveKernelMemoryThresholds } from "../config/memory-settings.ts";
 import { type CodemodeSettings, defaultCodemodeSettings } from "../config/settings.ts";
+import { collectOrphanedChildren } from "../host-sdk.ts";
 import type { InterpreterAvailability } from "../interpreters/detect.ts";
 import { JuliaKernel } from "../kernels/jl/kernel.ts";
 import { JavaScriptKernel } from "../kernels/js/context-manager.ts";
@@ -131,7 +133,11 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		if (existing) return existing;
 		const pending = this.#kernelCreations.get(language);
 		if (pending) return await pending;
-		const dispatch = (message: KernelToHostMessage): void => this.#onMessageRefs.get(language)?.(message);
+		// A bound method, never a closure in this frame: the dispatcher outlives every
+		// cell, and a closure here would capture this call's lexical environment — under
+		// JSC that keeps the creating cell's onMessage (CellHandler, output buffers,
+		// display images) alive for the whole kernel generation (#2260).
+		const dispatch = this.#dispatchTo.bind(this, language);
 		const generation = this.#generation;
 		const creation = this.#createAndStoreKernel(language, dispatch, generation);
 		this.#kernelCreations.set(language, creation);
@@ -142,6 +148,15 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		}
 	}
 
+	releaseKernelListener(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): void {
+		// Identity-checked: a cell settling late must not unbind a newer cell that already re-registered.
+		if (this.#onMessageRefs.get(language) === onMessage) this.#onMessageRefs.delete(language);
+	}
+
+	#dispatchTo(language: EvalLanguage, message: KernelToHostMessage): void {
+		this.#onMessageRefs.get(language)?.(message);
+	}
+
 	async complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult> {
 		return await this.#options.complete(request, ctx);
 	}
@@ -217,6 +232,8 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				onMessage,
 				hostToolNames: () => this.#options.listTools?.().map((tool) => tool.name) ?? [],
 				foreignLanguageNames: () => this.#foreignKernelToolNames(),
+				memory: resolveKernelMemoryThresholds(this.#options.settings.memory),
+				collectOrphanedChildren,
 				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 				...(localRoots ? { localRoots: { ...localRoots } } : {}),
 				...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
@@ -231,34 +248,19 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 			...(localRoots ? { localRoots: { ...localRoots } } : {}),
 			...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
 		};
-		if (language === "py") {
-			return await PythonKernel.start({
-				interpreterPath: detected.path,
-				sessionId: this.#options.sessionId,
-				cwd: this.#options.cwd,
-				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
-				connection,
-				onMessage,
-			});
-		}
-		if (language === "rb") {
-			return RubyKernel.start({
-				command: detected.path,
-				sessionId: this.#options.sessionId,
-				cwd: this.#options.cwd,
-				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
-				connection,
-				onMessage,
-			});
-		}
-		return JuliaKernel.start({
-			command: detected.path,
+		const shared = {
 			sessionId: this.#options.sessionId,
 			cwd: this.#options.cwd,
 			...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 			connection,
 			onMessage,
-		});
+		};
+		const memory = resolveKernelMemoryThresholds(this.#options.settings.memory);
+		if (language === "py") return await PythonKernel.start({ ...shared, interpreterPath: detected.path, memory });
+		// rb/jl runners report no memory: the host reads the interpreter footprint for the ceiling only.
+		const hostMeasured = { thresholds: memory, readFootprint: readProcessFootprint };
+		if (language === "rb") return RubyKernel.start({ ...shared, command: detected.path, memory: hostMeasured });
+		return JuliaKernel.start({ ...shared, command: detected.path, memory: hostMeasured });
 	}
 
 	#foreignKernelToolNames(): string[] {

package/src/host-sdk.ts

@@ -1 +1 @@
-export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "@code-yeongyu/senpi";
+export { collectOrphanedChildren, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "@code-yeongyu/senpi";

package/src/index.ts

@@ -3,6 +3,7 @@ import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
 import type { EvalSchemaToolInfo } from "./bridges/schema-bridge.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
+import { resolveRetainedImagesBytes, resolveRetainedResultsBytes } from "./config/memory-settings.ts";
 import {
 	defaultCodemodeSettings,
 	resolveForegroundWindowSeconds,
@@ -192,6 +193,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			cellManager: new EvalDetachedCellManager({
 				notifier,
 				maxDetachedCells: resolveMaxDetachedCells(defaultCodemodeSettings),
+				retainedResultsBytes: resolveRetainedResultsBytes(defaultCodemodeSettings),
 				hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
 				runBudgetSeconds: resolveRunBudgetSeconds(defaultCodemodeSettings),
 				onStatusChange: showDetachedCells,
@@ -231,6 +233,8 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			artifactsDir: runtime.artifactsDir,
 			notifier,
 			maxDetachedCells: resolveMaxDetachedCells(runtime.settings),
+			retainedResultsBytes: resolveRetainedResultsBytes(runtime.settings),
+			retainedImagesBytes: resolveRetainedImagesBytes(runtime.settings),
 			hardLimitSeconds: resolveHardLimitSeconds(runtime.settings),
 			runBudgetSeconds: resolveRunBudgetSeconds(runtime.settings),
 			onStatusChange: showDetachedCells,

package/src/kernels/jl/kernel.ts

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { SessionEnvironment } from "../session-env.ts";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
-import { SubprocessKernel, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
+import { SubprocessKernel, type SubprocessKernelMemory, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
 
 export interface JuliaKernelStartOptions {
 	readonly cwd: string;
@@ -13,6 +13,8 @@ export interface JuliaKernelStartOptions {
 	readonly command?: string;
 	readonly spawn?: SubprocessSpawn;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
+	/** Ceiling-only memory management (no notice or globals list: the runner reports no memory). */
+	readonly memory?: SubprocessKernelMemory;
 }
 
 export interface JuliaRunnerPathOptions extends CodemodeRuntimeAssetEnvironment {
@@ -49,6 +51,7 @@ export class JuliaKernel extends SubprocessKernel {
 			connection: options.connection,
 			spawn: options.spawn,
 			onMessage: options.onMessage,
+			memory: options.memory && { language: "jl", ...options.memory },
 		});
 	}
 }