@code-yeongyu/senpi-codemode 2026.10.10-9 → 2026.10.11

package/src/kernels/js/worker-runtime.js

@@ -5,8 +5,9 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { inspect } from "node:util";
 import { encodeDisplayImage, resolveDisplayOps } from "./display-image.js";
-import { terminateProcessTrees } from "./process-tree.js";
+import { terminateProcessGroups, terminateProcessTrees } from "./process-tree.js";
 import { awaitMaybePromise, indirectEval, wrapUserCode } from "./worker-indirect-eval.js";
+import { INJECTED_GROUP } from "./worker-cwd.js";
 import { installShellCapture } from "./worker-shell-capture.js";
 import { bindKernelBun } from "./worker-webview.js";
 import { createWorkpool } from "./workpool.js";
@@ -33,6 +34,9 @@ export class JsWorkerRuntime {
 	#hooks = null;
 	#pendingDisplays = [];
 	#children = new Set();
+	// Groups the worker created for cell children (senpi#2995). A group outlives its leader, so a grandchild re-parented
+	// to init is still found through it at retirement (senpi#3020).
+	#ownedGroups = new Map();
 	#childrenStopping;
 	#shellWaits = new Set();
 	#onChildEvent;
@@ -111,9 +115,14 @@ export class JsWorkerRuntime {
 	#trackChild(child, spawnOptions) {
 		if (child === null || typeof child !== "object" || typeof child.kill !== "function") return;
 		// `detached: true` is the cell saying it wants the process to outlive it.
-		if (isPlainObject(spawnOptions) && spawnOptions.detached === true) return;
+		const groupInjected = (globalThis[INJECTED_GROUP] ?? 0) > 0;
+		if (isPlainObject(spawnOptions) && spawnOptions.detached === true && !groupInjected) return;
 		this.#children.add(child);
 		const pid = Number.isInteger(child.pid) && child.pid > 0 ? child.pid : null;
+		// Bun.spawn children get their group from worker-cwd.js without the injection marker, so every tracked child is
+		// recorded; a child that is not a group leader names no group, and signalling it later finds nothing.
+		const ownGroupLeader = !(isPlainObject(spawnOptions) && spawnOptions.detached === false);
+		if (pid !== null && process.platform !== "win32" && ownGroupLeader) this.#ownedGroups.set(pid, child);
 		// The host keeps its own copy of live pids: if this worker is terminated
 		// while blocked, only the host can still retire them.
 		if (pid !== null) this.#onChildEvent?.({ pid, state: "spawned" });
@@ -127,10 +136,20 @@ export class JsWorkerRuntime {
 	#terminateChildren() {
 		const children = [...this.#children].filter(child => child.exitCode === null && child.signalCode === null);
 		this.#children.clear();
-		if (children.length === 0) return undefined;
+		// A leader that already exited leaves its group id reserved only while the group has members; if that pid now
+		// names a live process, it was reused by someone else and the group is not ours to signal (senpi#3020 review).
+		const groups = [...this.#ownedGroups].map(([pgid, child]) => ({
+			pgid,
+			leaderExited: child.exitCode !== null || child.signalCode !== null,
+		}));
+		this.#ownedGroups.clear();
+		if (children.length === 0 && groups.length === 0) return undefined;
 		const roots = children.map(child => child.pid).filter(pid => Number.isInteger(pid) && pid > 0);
 		const settled = Promise.allSettled(children.map(child => (child.exited instanceof Promise ? child.exited : Promise.resolve())));
-		return terminateProcessTrees(roots, { graceMs: CHILD_TERMINATION_GRACE_MS, settled });
+		return Promise.all([
+			roots.length > 0 ? terminateProcessTrees(roots, { graceMs: CHILD_TERMINATION_GRACE_MS, settled }) : undefined,
+			terminateProcessGroups(groups, { graceMs: CHILD_TERMINATION_GRACE_MS }),
+		]);
 	}
 
 	async #drainPendingDisplays() {

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

@@ -1,4 +1,5 @@
 import { assertCellLive } from "./cell-run-context.js";
+import { groupSignalNotice, noticeChildProcessGroupSignals, shellCommandText, signalsProcessGroup } from "./group-signal-notice.js";
 
 const SHELL_CONFIG_METHODS = ["env", "cwd", "nothrow", "throws"];
 const SHELL_READ_METHODS = ["text", "json", "lines", "arrayBuffer", "bytes", "blob"];
@@ -28,7 +29,9 @@ export function installShellCapture(options) {
 	bun.$ = capturedShell(originalShell, options);
 	bun.spawn = capturedSpawn(originalSpawn, options, pinEnv);
 	if (originalSpawnSync !== null) bun.spawnSync = capturedSpawnSync(originalSpawnSync, pinEnv);
+	const restoreChildProcessNotice = noticeChildProcessGroupSignals(options.emitText, options.isActive);
 	return () => {
+		restoreChildProcessNotice();
 		bun.$ = originalShell;
 		bun.spawn = originalSpawn;
 		if (originalSpawnSync !== null) bun.spawnSync = originalSpawnSync;
@@ -43,6 +46,7 @@ function capturedShell(originalShell, options) {
 	const shell = (strings, ...expressions) => {
 		assertCellLive();
 		if (!options.isActive()) return originalShell(strings, ...expressions);
+		if (signalsProcessGroup(shellCommandText(strings, expressions))) options.emitText("stderr", groupSignalNotice("Bun.$"));
 		const promise = originalShell(isolateStdin(strings), ...expressions);
 		return captureShellPromise(promise, options);
 	};

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

@@ -4,7 +4,6 @@ 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 type { JavaScriptProcessWorker } from "./process-worker.ts";
 import { KernelWebViewClients } from "./webview-host.ts";
 import { WorkerStartupCancelledError } from "./worker-host.ts";
 import { startWorkerWithInlineFallback } from "./worker-startup.ts";
@@ -38,7 +37,7 @@ export class WorkerSlot {
 
 	get processPid(): number | undefined {
 		const worker = this.#worker;
-		if (worker?.mode === "process") return (worker as JavaScriptProcessWorker).pid;
+		if (worker?.mode === "process") return worker.pid;
 		return this.#lastProcessPid;
 	}
 
@@ -113,7 +112,7 @@ export class WorkerSlot {
 	#publish(worker: WorkerLike, generation: number): void {
 		if (!this.#listeners.isOpen() || generation !== this.#generation) throw new WorkerStartupCancelledError();
 		this.#worker = worker;
-		if (worker.mode === "process") this.#lastProcessPid = (worker as JavaScriptProcessWorker).pid;
+		if (worker.mode === "process") this.#lastProcessPid = worker.pid;
 		const webViews = new KernelWebViewClients((message, transfer) => worker.postMessage(message, transfer));
 		this.#webViews = webViews;
 		worker.onMessage((message) => {

package/src/kernels/py/prelude.py

@@ -661,25 +661,6 @@ class ThreadRoutedStream(io.TextIOBase):
         )
         self.cell_target: io.StringIO | None = None
 
-    @contextlib.contextmanager
-    def capture(self, buffer: io.StringIO, *, cell: bool) -> Iterator[None]:
-        me = threading.get_ident()
-        previous = self._targets.get(me)
-        self._targets[me] = buffer
-        inherited = self._inherited.set(buffer)
-        if cell:
-            self.cell_target = buffer
-        try:
-            yield
-        finally:
-            self._inherited.reset(inherited)
-            if previous is None:
-                self._targets.pop(me, None)
-            else:
-                self._targets[me] = previous
-            if cell:
-                self.cell_target = None
-
     def write(self, text: str) -> int:
         target = self._targets.get(threading.get_ident()) or self._inherited.get() or self.cell_target
         if target is None:
@@ -694,6 +675,38 @@ class ThreadRoutedStream(io.TextIOBase):
         return None
 
 
+@contextlib.contextmanager
+def capture_streams(
+    streams: tuple[ThreadRoutedStream, ThreadRoutedStream],
+    buffers: tuple[io.StringIO, io.StringIO],
+    *,
+    cell: bool,
+) -> Iterator[None]:
+    stdout, stderr = streams
+    out, err = buffers
+    me = threading.get_ident()
+    previous_out, previous_err = stdout._targets.get(me), stderr._targets.get(me)
+    stdout._targets[me], stderr._targets[me] = out, err
+    inherited_out, inherited_err = stdout._inherited.set(out), stderr._inherited.set(err)
+    if cell:
+        stdout.cell_target, stderr.cell_target = out, err
+    try:
+        yield
+    finally:
+        stderr._inherited.reset(inherited_err)
+        stdout._inherited.reset(inherited_out)
+        if previous_err is None:
+            stderr._targets.pop(me, None)
+        else:
+            stderr._targets[me] = previous_err
+        if previous_out is None:
+            stdout._targets.pop(me, None)
+        else:
+            stdout._targets[me] = previous_out
+        if cell:
+            stdout.cell_target, stderr.cell_target = None, None
+
+
 @dataclass
 class _Entry:
     name: str
@@ -905,8 +918,7 @@ class KernelToolRunner:
                 if invocation.cancelled.is_set():
                     raise Cancelled(CANCELLED_BEFORE_START)
                 CURRENT.set(invocation)
-                stdout, stderr = self._streams
-                with stdout.capture(output, cell=False), stderr.capture(output, cell=False):
+                with capture_streams(self._streams, (output, output), cell=False):
                     value = self._call(invocation, entry.fn, args)
             finally:
                 CURRENT.set(None)
@@ -2218,8 +2230,7 @@ def run_cell(
     cell_scope = CURRENT_CELL_TOKEN.set(cell_token)
     try:
         KERNEL_TOOL_TOKEN.acquire()
-        cell_stdout, cell_stderr = KERNEL_TOOL_STREAMS
-        with cell_stdout.capture(stdout, cell=True), cell_stderr.capture(stderr, cell=True):
+        with capture_streams(KERNEL_TOOL_STREAMS, (stdout, stderr), cell=True):
             apply_preludes(preludes)
             leave_source_file = _enter_source_file(source_file)
             body, expression = compile_cell(code, source_file or "<cell>")
@@ -2373,7 +2384,7 @@ def _start_parent_watch() -> None:
         ).start()
 
 
-def _read_control(commands: queue.Queue[tuple[str, Any]]) -> None:
+def _read_control(commands: queue.SimpleQueue[tuple[str, Any]]) -> None:
     # Kernel-tool frames are served here, so a callback can be admitted while the main thread is inside a cell.
     for raw in sys.stdin:
         try:
@@ -2392,7 +2403,7 @@ def main() -> None:
     signal.signal(signal.SIGINT, signal.SIG_IGN)
     _start_parent_watch()
     sys.stdout, sys.stderr = KERNEL_TOOL_STREAMS
-    commands: queue.Queue[tuple[str, Any]] = queue.Queue()
+    commands: queue.SimpleQueue[tuple[str, Any]] = queue.SimpleQueue()
     threading.Thread(target=_read_control, args=(commands,), name="senpi-control-reader", daemon=True).start()
     host_closed = False
     while True:

package/src/kernels/py/transport.ts

@@ -244,6 +244,10 @@ export class PythonKernelTransport {
 		this.#child.stderr.on("data", onStderr);
 		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);
 		const { sessionId, connection, memory, kernelGeneration } = this.#options;
 		this.#write({
 			type: "init",

package/src/kernels/rb/runner.rb

@@ -9,6 +9,7 @@ $stdout.flush
 $__senpi_binding = TOPLEVEL_BINDING
 $__senpi_frame_mutex = Mutex.new
 $__senpi_current_cell = nil
+$__senpi_memory_cell = nil
 $__senpi_capture_cell = nil
 $__senpi_connection = nil
 $__senpi_frame_io = STDOUT.dup
@@ -123,8 +124,6 @@ rescue JSON::GeneratorError
   value.inspect
 end
 
-$__senpi_memory = nil
-
 SENPI_SIZER_SAMPLE = 1_000
 SENPI_SIZER_NODE_BUDGET = 5_000
 SENPI_SIZER_MAX_DEPTH = 64
@@ -239,19 +238,6 @@ rescue StandardError
   []
 end
 
-# The host reads the interpreter's footprint and decides on the notice; the runner only names its
-# largest globals. Nothing here spawns a process, so the user's `$?` is left alone.
-def __senpi_memory_report
-  return nil if $__senpi_memory.nil?
-  named = __senpi_largest_globals(5)
-  # The host replaces liveBytes with the interpreter footprint it reads itself; only globals is used.
-  report = { "liveBytes" => 0, "measure" => "footprint" }
-  report["globals"] = named unless named.empty?
-  report
-rescue StandardError
-  nil
-end
-
 SENPI_NON_DISPLAY_NODES = %i[
   LASGN IASGN GASGN CVASGN DASGN OP_ASGN OP_CDECL CDECL MASGN CASGN
   DEFN DEFS CLASS MODULE SCLASS ALIAS UNDEF
@@ -305,8 +291,6 @@ def __senpi_run_cell(message)
       "durationMs" => ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round,
     }
     frame["valueRepr"] = __senpi_value_repr(value) if !value.nil? && __senpi_should_display_result?(source)
-    memory = __senpi_memory_report
-    frame["memory"] = memory unless memory.nil?
     __senpi_emit(frame)
   rescue Exception => error
     __senpi_emit({
@@ -319,6 +303,7 @@ def __senpi_run_cell(message)
   ensure
     $__senpi_capture_cell = nil
     $__senpi_current_cell = nil
+    $__senpi_memory_cell = cell_id
   end
 end
 
@@ -332,10 +317,15 @@ $__senpi_protocol_stdin.each_line do |line|
   when "init"
     __senpi_emit({ "type" => "status", "event" => { "op" => "kernel-startup", "stage" => "host-init" } })
     $__senpi_connection = message["connection"]
-    $__senpi_memory = message["memory"]
-    __senpi_emit({ "type" => "ready" })
+    __senpi_emit({ "type" => "ready", "memoryGlobals" => true })
   when "run"
+    $__senpi_memory_cell = nil
     __senpi_run_cell(message)
+  when "memory-globals"
+    if message["cellId"] == $__senpi_memory_cell && $__senpi_current_cell.nil?
+      __senpi_emit({ "type" => "memory-globals-result", "cellId" => message["cellId"], "globals" => __senpi_largest_globals(5) })
+      $__senpi_memory_cell = nil
+    end
   when "close"
     __senpi_emit({ "type" => "closed" })
     exit 0

package/src/kernels/sandbox/vendor/pi-codemode/runtime/host.ts

@@ -115,7 +115,7 @@ class Execution {
 	private finished = false;
 	// senpi-change begin: output streaming
 	private readonly stream: StreamOptions | undefined;
-	private readonly credits: Int32Array | undefined;
+	private readonly credits: Int32Array<SharedArrayBuffer> | undefined;
 	private frameChain: Promise<void> = Promise.resolve();
 	private frames = 0;
 	private inFlightBytes = 0;
@@ -188,7 +188,7 @@ class Execution {
 			// senpi-change begin: output streaming and builtin policy
 			...(this.credits === undefined || this.stream === undefined
 				? {}
-				: { stream: { credits: this.credits.buffer as SharedArrayBuffer, frameBytes: this.stream.frameBytes } }),
+				: { stream: { credits: this.credits.buffer, frameBytes: this.stream.frameBytes } }),
 			storePolicy: options.storePolicy,
 			// senpi-change end
 		};

package/src/kernels/shared/bun-ffi.ts

@@ -0,0 +1,24 @@
+/**
+ * The one read of `bun:ffi` behind a guard: `process.getBuiltinModule` returns the module on Bun and
+ * `undefined` on Node, so this module loads on either runtime, and only a result carrying the callable
+ * surface the CPU readers bind is treated as FFI - the same boundary `display-js.ts` uses for `Bun`.
+ */
+export type BunFfi = {
+	readonly dlopen: <S>(path: string, definitions: Record<string, unknown>) => { readonly symbols: S };
+	readonly FFIType: Record<string, number>;
+	readonly ptr: (buffer: ArrayBufferView) => number;
+};
+
+/** True when `value` carries the `bun:ffi` surface the kernel CPU readers use (`dlopen`, `FFIType`, `ptr`). */
+export function isBunFfi(value: unknown): value is BunFfi {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("dlopen" in value) || typeof value.dlopen !== "function") return false;
+	if (!("ptr" in value) || typeof value.ptr !== "function") return false;
+	return "FFIType" in value && typeof value.FFIType === "object" && value.FFIType !== null;
+}
+
+/** The runtime's `bun:ffi` module, or `undefined` on Node and on any runtime whose builtin is not one. */
+export function loadBunFfi(): BunFfi | undefined {
+	const ffi: unknown = process.getBuiltinModule("bun:ffi");
+	return isBunFfi(ffi) ? ffi : undefined;
+}

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

@@ -1,4 +1,4 @@
-import type { KernelMemoryThresholds } from "../../bridge/memory-protocol.ts";
+import type { KernelMemoryReport, KernelMemoryThresholds } from "../../bridge/memory-protocol.ts";
 import type { KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { EvalLanguage } from "../../tool/types.ts";
 import { KernelMemoryPolicy } from "./kernel-memory.ts";
@@ -11,7 +11,7 @@ export type FootprintReader = (pid: number) => { readonly bytes: number } | unde
 export interface KernelMemoryHostOptions {
 	/**
 	 * Host-measured kernel (rb, jl): the host reads the interpreter's footprint after each result and
-	 * replaces the runner's live reading with it; the runner still names its largest globals, so the
+	 * replaces the runner's live reading with it; the runner names its largest globals on demand, so the
 	 * notice and the ceiling both apply, with every reading counting (no collection precedes it).
 	 */
 	readonly readFootprint?: FootprintReader;
@@ -36,12 +36,35 @@ export class KernelMemoryHost {
 	}
 
 	annotate(result: ResultMessage, pid?: number): ResultMessage {
+		return this.annotateReport(result, this.readReport(result, pid));
+	}
+
+	readReport(result: ResultMessage, pid?: number): KernelMemoryReport | undefined {
 		const runnerReport = result.memory;
-		const report =
-			this.#readFootprint === undefined
-				? runnerReport
-				: this.#footprintReport(this.#readFootprint, pid, runnerReport);
-		return report === undefined ? result : { ...result, memory: this.#policy.annotate(report) };
+		return this.#readFootprint === undefined
+			? runnerReport
+			: this.#footprintReport(this.#readFootprint, pid, runnerReport);
+	}
+
+	needsGlobals(report: KernelMemoryReport): boolean {
+		const { noticeBytes, ceilingBytes } = this.#policy.thresholds;
+		// Collect at or above the host-read notice threshold or ceiling, regardless of notice hysteresis;
+		// never collect below both thresholds. Zero disables a threshold, not the lazy diagnostic gate.
+		return (
+			(noticeBytes > 0 && report.liveBytes >= noticeBytes) || (ceilingBytes > 0 && report.liveBytes >= ceilingBytes)
+		);
+	}
+
+	annotateReport(result: ResultMessage, report: KernelMemoryReport | undefined): ResultMessage {
+		if (report === undefined) return result;
+		const memory = this.#policy.annotate(report);
+		// Safety accounting still observes every cell, but ordinary host-measured results carry no payload.
+		// A recycle announcement remains visible even when the replacement process is below threshold.
+		if (this.#readFootprint !== undefined && !this.needsGlobals(report) && memory.notice === undefined) {
+			const { memory: _memory, ...ordinary } = result;
+			return ordinary;
+		}
+		return { ...result, memory };
 	}
 
 	/**

package/src/kernels/shared/process-cpu.ts

@@ -8,9 +8,9 @@
  *   Windows has no process groups; this is the interpreter itself when it is launched directly.
  * - anything else, or Windows under Node: `undefined`, and the caller treats the CPU as unknown.
  */
+import { type BunFfi, loadBunFfi } from "./bun-ffi.ts";
 import { readProcessGroupCpuTime } from "./process-group-cpu.ts";
 
-type BunFfi = typeof import("bun:ffi");
 type CpuReader = (pid: number) => bigint | undefined;
 
 const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
@@ -26,7 +26,7 @@ export function readKernelCpuTime(pid: number): bigint | undefined {
 }
 
 function createWindowsReader(): CpuReader | undefined {
-	const ffi = process.getBuiltinModule("bun:ffi") as BunFfi | undefined;
+	const ffi = loadBunFfi();
 	if (ffi === undefined) return undefined;
 	try {
 		return bindGetProcessTimes(ffi);
@@ -37,7 +37,11 @@ function createWindowsReader(): CpuReader | undefined {
 }
 
 function bindGetProcessTimes({ dlopen, FFIType, ptr }: BunFfi): CpuReader {
-	const library = dlopen("kernel32.dll", {
+	const library = dlopen<{
+		OpenProcess: (access: number, inheritHandle: number, pid: number) => number | null;
+		GetProcessTimes: (handle: number, create: number, exit: number, kernel: number, user: number) => number;
+		CloseHandle: (handle: number) => number;
+	}>("kernel32.dll", {
 		OpenProcess: { args: [FFIType.u32, FFIType.i32, FFIType.u32], returns: FFIType.ptr },
 		GetProcessTimes: {
 			args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr],

package/src/kernels/shared/process-group-cpu.ts

@@ -15,8 +15,8 @@
  */
 import { execFileSync } from "node:child_process";
 import { readdirSync, readFileSync } from "node:fs";
+import { type BunFfi, loadBunFfi } from "./bun-ffi.ts";
 
-type BunFfi = typeof import("bun:ffi");
 type GroupCpuReader = (pgid: number) => bigint | undefined;
 
 const RUSAGE_INFO_V2 = 2;
@@ -59,7 +59,7 @@ export function parsePsCpuTime(text: string): bigint | undefined {
 function createGroupReader(): GroupCpuReader | undefined {
 	if (process.platform === "linux") return linuxGroupReader;
 	if (process.platform !== "darwin") return undefined;
-	const ffi = process.getBuiltinModule("bun:ffi") as BunFfi | undefined;
+	const ffi = loadBunFfi();
 	if (ffi === undefined) return darwinPsGroupReader;
 	try {
 		return darwinGroupReader(ffi);
@@ -116,7 +116,10 @@ function linuxGroupReader(pgid: number): bigint | undefined {
 }
 
 function darwinGroupReader({ dlopen, FFIType, ptr }: BunFfi): GroupCpuReader {
-	const library = dlopen("libSystem.B.dylib", {
+	const library = dlopen<{
+		proc_listpgrppids: (pgid: number, buffer: number, byteLength: number) => number;
+		proc_pid_rusage: (pid: number, flavor: number, buffer: number) => number;
+	}>("libSystem.B.dylib", {
 		proc_listpgrppids: { args: [FFIType.i32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
 		proc_pid_rusage: { args: [FFIType.i32, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
 	});

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

@@ -1,3 +1,4 @@
+// allow: SIZE_OK — subprocess protocol, FIFO ownership, retirement, and replacement form one serialized state machine.
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelInterruptHandle, PendingCell } from "../../tool/types.ts";
@@ -7,6 +8,7 @@ import { applySessionEnvironment } from "../session-env.ts";
 import { describeExit } from "./kernel-death.ts";
 import { KernelMemoryHost } from "./kernel-memory-host.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
+import { SubprocessMemoryGlobals } from "./subprocess-memory-globals.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
 import { SubprocessRunQueue } from "./subprocess-queue.ts";
 import {
@@ -39,6 +41,7 @@ export class SubprocessKernel {
 	private readonly onMessage?: (message: KernelToHostMessage) => void;
 	private readonly runs = new SubprocessRunQueue();
 	private readonly memory: KernelMemoryHost | null;
+	private readonly globals = new SubprocessMemoryGlobals();
 	private process: SubprocessProcess | null = null;
 	private processReady = false;
 	private startup: SubprocessStartupWatchdog | null = null;
@@ -90,8 +93,10 @@ export class SubprocessKernel {
 			this.runs.settleAll(new CellInterruptedError(reason));
 			return { stateRetained: Promise.resolve(true) };
 		}
+		if (this.globals.completeWithoutGlobals()) return { stateRetained: Promise.resolve(true) };
 		const process = this.process;
 		process?.retire();
+		this.globals.reset();
 		this.runs.clearToolCalls();
 		const run = this.runs.active;
 		if (!run) return { stateRetained: Promise.resolve(true) };
@@ -126,6 +131,7 @@ export class SubprocessKernel {
 
 	async reset(): Promise<void> {
 		if (this.closed) throw new KernelClosedError();
+		this.globals.reset();
 		this.settleAll(new KernelResetError());
 		this.runs.clearToolCalls();
 		await this.restartProcess(this.process);
@@ -135,6 +141,7 @@ export class SubprocessKernel {
 	async close(): Promise<void> {
 		const wasClosed = this.closed;
 		this.closed = true;
+		this.globals.reset();
 		this.startup?.stop();
 		if (!wasClosed) {
 			this.settleAll(new KernelClosingError());
@@ -175,6 +182,7 @@ export class SubprocessKernel {
 		if (this.runs.active !== run || run.settled) return;
 		const process = this.process;
 		process?.retire();
+		this.globals.reset();
 		this.runs.clearToolCalls();
 		this.runs.releaseActive(run);
 		this.runs.settle(run, timeoutResult(run, timeoutMs));
@@ -199,6 +207,7 @@ export class SubprocessKernel {
 			},
 		});
 		this.process = process;
+		this.globals.reset();
 		this.processReady = false;
 		this.startup?.stop();
 		const startup = this.options.startup;
@@ -237,6 +246,7 @@ export class SubprocessKernel {
 		if (!this.accepts(process)) return;
 		if (!this.processReady) this.startup?.observe(message);
 		if (message.type === "ready") {
+			this.globals.reset(message.memoryGlobals === true);
 			this.startup?.stop();
 			this.processReady = true;
 			this.runs.handleMessage(message, this.onMessage);
@@ -248,9 +258,23 @@ export class SubprocessKernel {
 			this.failClosed(new KernelStartupError(message.error.message));
 			return;
 		}
-		const ownResult = message.type === "result" && this.runs.active?.input.cellId === message.cellId;
-		const settled = ownResult && this.memory ? this.memory.annotate(message, process.child.pid) : message;
-		if (!this.runs.handleMessage(settled, this.onMessage)) return;
+		const run = this.runs.active;
+		if (message.type === "memory-globals-result") {
+			if (this.memory) this.globals.reply({ process, run }, message, this.memory);
+			return;
+		}
+		if (message.type === "result" && run?.input.cellId === message.cellId && this.memory) {
+			this.globals.request({ process, run, result: message }, this.memory, (result) => {
+				if (!this.accepts(process) || this.runs.active !== run || run.settled) return;
+				this.settleMessage(result);
+			});
+			return;
+		}
+		this.settleMessage(message);
+	}
+
+	private settleMessage(message: KernelToHostMessage): void {
+		if (!this.runs.handleMessage(message, this.onMessage)) return;
 		this.pumpRuns();
 		this.recycleOverCeilingWhenIdle();
 	}
@@ -270,6 +294,7 @@ export class SubprocessKernel {
 			return;
 		}
 		this.process = null;
+		this.globals.reset();
 		this.processReady = false;
 		const error = new KernelExitedError(signal ?? code ?? "unknown");
 		if (this.options.onDeath) this.die(error, describeExit(code, signal), this.options.onDeath);
@@ -362,6 +387,7 @@ export class SubprocessKernel {
 
 	private failClosed(error: Error): void {
 		this.startup?.stop();
+		this.globals.reset();
 		const process = this.process;
 		this.failure = error;
 		this.closed = true;

package/src/kernels/shared/subprocess-memory-globals.ts

@@ -0,0 +1,101 @@
+import type { KernelMemoryReport } from "../../bridge/memory-protocol.ts";
+import { encodeBridgeFrame, type KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelMemoryHost } from "./kernel-memory-host.ts";
+import type { KernelResult } from "./subprocess-contract.ts";
+import type { SubprocessProcess } from "./subprocess-process.ts";
+import type { PendingRun } from "./subprocess-run.ts";
+
+const GLOBALS_TIMEOUT_MS = 5_000;
+type GlobalsProcess = Pick<SubprocessProcess, "send"> & {
+	readonly child: { readonly pid?: number };
+};
+
+interface PendingGlobals {
+	readonly process: GlobalsProcess;
+	readonly run: PendingRun;
+	readonly result: KernelResult;
+	readonly report: KernelMemoryReport;
+	readonly memory: KernelMemoryHost;
+	readonly finish: (result: KernelResult) => void;
+	readonly timer: ReturnType<typeof setTimeout>;
+}
+
+/** Holds FIFO cell ownership until its bounded diagnostic is returned or its deadline expires. */
+export class SubprocessMemoryGlobals {
+	#pending: PendingGlobals | null = null;
+	#available = false;
+
+	reset(available = false): void {
+		if (this.#pending !== null) clearTimeout(this.#pending.timer);
+		this.#pending = null;
+		this.#available = available;
+	}
+
+	request(
+		owner: {
+			readonly process: GlobalsProcess;
+			readonly run: PendingRun;
+			readonly result: KernelResult;
+		},
+		memory: KernelMemoryHost,
+		finish: (result: KernelResult) => void,
+	): void {
+		if (this.#pending !== null) return;
+		const report = memory.readReport(owner.result, owner.process.child.pid);
+		if (!this.#available || report === undefined || !memory.needsGlobals(report)) {
+			finish(memory.annotateReport(owner.result, report));
+			return;
+		}
+		const pending: PendingGlobals = {
+			...owner,
+			report,
+			memory,
+			finish,
+			timer: setTimeout(() => {
+				if (this.#pending !== pending) return;
+				this.#pending = null;
+				pending.finish(memory.annotateReport(pending.result, report));
+			}, GLOBALS_TIMEOUT_MS),
+		};
+		this.#pending = pending;
+		owner.process.send(
+			encodeBridgeFrame({
+				type: "memory-globals",
+				cellId: owner.result.cellId,
+			}),
+		);
+	}
+
+	/** Settles an already-finished cell immediately when stop arrives during its optional diagnostic. */
+	completeWithoutGlobals(): boolean {
+		const pending = this.#pending;
+		if (pending === null) return false;
+		clearTimeout(pending.timer);
+		this.#pending = null;
+		pending.finish(pending.memory.annotateReport(pending.result, pending.report));
+		return true;
+	}
+
+	reply(
+		owner: {
+			readonly process: GlobalsProcess;
+			readonly run: PendingRun | null;
+		},
+		message: Extract<KernelToHostMessage, { type: "memory-globals-result" }>,
+		memory: KernelMemoryHost,
+	): void {
+		const pending = this.#pending;
+		if (
+			pending === null ||
+			pending.process !== owner.process ||
+			pending.run !== owner.run ||
+			pending.result.cellId !== message.cellId
+		)
+			return;
+		clearTimeout(pending.timer);
+		this.#pending = null;
+		const report = message.globals.length === 0 ? pending.report : { ...pending.report, globals: message.globals };
+		const result = memory.annotateReport(pending.result, report);
+		pending.finish(result);
+	}
+}