@code-yeongyu/senpi-codemode 2026.10.5 → 2026.10.6

package/src/kernels/jl/runner.jl

@@ -1,4 +1,6 @@
 # allow: SIZE_OK — parser, stream capture, bridge calls, and the persistent execution loop share Main globals.
+write(stdout, "{\"type\":\"status\",\"event\":{\"op\":\"kernel-startup\",\"stage\":\"stdlib-imports\"}}\n")
+flush(stdout)
 using Sockets
 
 const SENPI_ORIGINAL_STDOUT = stdout
@@ -7,6 +9,8 @@ out_read, out_write = redirect_stdout()
 err_read, err_write = redirect_stderr()
 redirect_stdin(devnull)
 
+write(SENPI_ORIGINAL_STDOUT, "{\"type\":\"status\",\"event\":{\"op\":\"kernel-startup\",\"stage\":\"runtime-init\"}}\n")
+flush(SENPI_ORIGINAL_STDOUT)
 include("prelude.jl")
 
 const senpi_connection = Dict{String, Any}()
@@ -281,6 +285,152 @@ function senpi_set_connection(value)
     end
 end
 
+const senpi_memory = Ref{Any}(nothing)
+
+const SENPI_MEMORY_INTERNALS = Set([:senpi_current_cell, :senpi_memory, :senpi_connection, :senpi_frame_io, :senpi_stdout_capture, :senpi_stderr_capture, :senpi_protocol_stdin])
+
+const SENPI_SIZER_SAMPLE = 1_000
+const SENPI_SIZER_NODE_BUDGET = 5_000
+const SENPI_SIZER_MAX_DEPTH = 64
+const SENPI_SIZER_POINTER = 8
+const SENPI_SIZER_OBJECT = 16
+const SENPI_SIZER_MIN_REPORTED = 1024 * 1024
+
+# Sizes a global with sampling and a node budget per global (leaves count too), so one deep global
+# never hides the ones measured after it and a huge container costs a bounded walk. Only concrete Base
+# containers are iterated; any other AbstractDict or AbstractSet is sized as an opaque struct, so no user
+# length or iterate method runs during a memory report.
+mutable struct SenpiSizer
+    seen::IdDict{Any, Nothing}
+    nodes::Int
+    approximate::Bool
+end
+SenpiSizer() = SenpiSizer(IdDict{Any, Nothing}(), 0, false)
+
+senpi_over_budget(sizer::SenpiSizer) = sizer.nodes >= SENPI_SIZER_NODE_BUDGET
+
+function senpi_size(sizer::SenpiSizer, value, depth::Int)::Int
+    sizer.nodes += 1
+    value isa Type && return 0
+    value isa Union{Number, Char, Bool, Symbol, Nothing} && return isbits(value) ? sizeof(value) : 0
+    value isa String && return SENPI_SIZER_OBJECT + sizeof(value)
+    if ismutable(value)
+        haskey(sizer.seen, value) && return 0
+        sizer.seen[value] = nothing
+    end
+    if depth >= SENPI_SIZER_MAX_DEPTH || senpi_over_budget(sizer)
+        sizer.approximate = true
+        return SENPI_SIZER_OBJECT
+    end
+    if value isa Array
+        isbitstype(eltype(value)) && return SENPI_SIZER_OBJECT + sizeof(value)
+        return SENPI_SIZER_OBJECT + length(value) * SENPI_SIZER_POINTER +
+            senpi_sampled(sizer, length(value), depth) do index
+                isassigned(value, index) ? value[index] : nothing
+            end
+    elseif value isa Union{Dict, IdDict}
+        count = length(value)
+        total = 0
+        taken = 0
+        for (key, item) in value
+            senpi_over_budget(sizer) && break
+            total += senpi_size(sizer, key, depth + 1) + senpi_size(sizer, item, depth + 1)
+            taken += 1
+            taken >= SENPI_SIZER_SAMPLE && break
+        end
+        taken < count && (sizer.approximate = true)
+        return SENPI_SIZER_OBJECT + count * 2 * SENPI_SIZER_POINTER + (taken == 0 ? 0 : div(total * count, taken))
+    elseif value isa Union{Set, Tuple}
+        count = length(value)
+        total = 0
+        taken = 0
+        for item in value
+            senpi_over_budget(sizer) && break
+            total += senpi_size(sizer, item, depth + 1)
+            taken += 1
+            taken >= SENPI_SIZER_SAMPLE && break
+        end
+        taken < count && (sizer.approximate = true)
+        return SENPI_SIZER_OBJECT + count * SENPI_SIZER_POINTER + (taken == 0 ? 0 : div(total * count, taken))
+    end
+    isbits(value) && return sizeof(value)
+    fields = fieldcount(typeof(value))
+    return SENPI_SIZER_OBJECT + fields * SENPI_SIZER_POINTER +
+        senpi_sampled(sizer, fields, depth) do index
+            isdefined(value, index) ? getfield(value, index) : nothing
+        end
+end
+
+# Up to SENPI_SIZER_SAMPLE evenly spaced elements; once the budget runs out part-way, the elements measured
+# so far stand in for the rest.
+function senpi_sampled(at, sizer::SenpiSizer, count::Int, depth::Int)::Int
+    count == 0 && return 0
+    picks = min(count, SENPI_SIZER_SAMPLE)
+    picks < count && (sizer.approximate = true)
+    step = count / picks
+    total = 0
+    measured = 0
+    for sample in 1:picks
+        if senpi_over_budget(sizer)
+            sizer.approximate = true
+            break
+        end
+        total += senpi_size(sizer, at(1 + floor(Int, (sample - 1) * step)), depth + 1)
+        measured += 1
+    end
+    return measured == 0 ? 0 : round(Int, total / measured * count)
+end
+
+function senpi_largest_globals(limit::Int)
+    try
+        sizer = SenpiSizer()
+        candidates = Tuple{String, Int, Bool}[]
+        Base.invokelatest() do
+            for name in names(Main, all = true)
+                name in SENPI_MEMORY_INTERNALS && continue
+                name in (:Main, :Base, :Core, :Ans, :ans) && continue
+                lowered = lowercase(string(name))
+                startswith(lowered, "senpi_") && continue
+                startswith(string(name), "Senpi") && continue
+                startswith(string(name), "#") && continue
+                isdefined(Main, name) || continue
+                value = getfield(Main, name)
+                value isa Module && continue
+                value isa IO && continue
+                value isa Type && continue
+                value isa Function && continue
+                sizer.approximate = false
+                sizer.nodes = 0
+                bytes = try
+                    senpi_size(sizer, value, 0) + SENPI_SIZER_POINTER
+                catch
+                    0
+                end
+                bytes >= SENPI_SIZER_MIN_REPORTED && push!(candidates, (string(name), bytes, sizer.approximate))
+            end
+        end
+        sort!(candidates, by = entry -> entry[2], rev = true)
+        [approximate ? Dict{String, Any}("name" => name, "bytes" => bytes, "approximate" => true) : Dict{String, Any}("name" => name, "bytes" => bytes) for (name, bytes, approximate) in candidates[1:min(limit, end)]]
+    catch
+        Dict{String, Any}[]
+    end
+end
+
+function senpi_memory_report()
+    try
+        senpi_memory[] === nothing && return nothing
+        # The host reads the interpreter's current footprint and decides on the notice; the runner only
+        # names its largest globals, with a bounded walk, so a cell never pays for an unbounded scan.
+        named = senpi_largest_globals(5)
+        # The host replaces liveBytes with the interpreter footprint it reads itself; only globals is used.
+        report = Dict{String, Any}("liveBytes" => 0, "measure" => "footprint")
+        isempty(named) || (report["globals"] = named)
+        report
+    catch
+        nothing
+    end
+end
+
 function senpi_run_cell(message)
     cell_id = string(get(message, "cellId", ""))
     code = string(get(message, "code", ""))
@@ -297,6 +447,8 @@ function senpi_run_cell(message)
         yield()
         frame = Dict{String, Any}("type" => "result", "cellId" => cell_id, "ok" => true, "durationMs" => round(Int, (time() - started) * 1000))
         value !== nothing && senpi_should_display_result(parsed) && (frame["valueRepr"] = senpi_json(value))
+        memory = senpi_memory_report()
+        memory !== nothing && (frame["memory"] = memory)
         senpi_emit(frame)
     catch error
         senpi_emit(Dict("type" => "result", "cellId" => cell_id, "ok" => false, "error" => senpi_error(error), "durationMs" => round(Int, (time() - started) * 1000)))
@@ -313,7 +465,9 @@ while !eof(SENPI_ORIGINAL_STDIN)
         message isa AbstractDict || error("Bridge frame must be an object")
         kind = get(message, "type", nothing)
         if kind == "init"
+            senpi_emit(Dict("type" => "status", "event" => Dict("op" => "kernel-startup", "stage" => "host-init")))
             senpi_set_connection(get(message, "connection", nothing))
+            senpi_memory[] = get(message, "memory", nothing)
             senpi_emit(Dict("type" => "ready"))
         elseif kind == "run"
             senpi_run_cell(message)

package/src/kernels/js/context-manager.ts

@@ -1,6 +1,7 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { CHILD_LIFECYCLE_OP, INTERRUPT_ACK_OP } from "../../bridge/reserved.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
+import { KernelToolHostPump } from "../shared/kernel-tools-pump.ts";
 import { ActiveCellControl } from "./active-cell-control.ts";
 import { DEFAULT_INTERRUPT_BOUNDS, type WorkerRetirement } from "./interrupt-bounds.ts";
 import {
@@ -14,7 +15,6 @@ import {
 } from "./kernel-contract.ts";
 import { type JavaScriptMemoryReading, KernelMemoryBridge } from "./kernel-memory-bridge.ts";
 import { kernelToolError } from "./kernel-tools-errors.ts";
-import { KernelToolHostPump } from "./kernel-tools-host.ts";
 import type {
 	KernelToolsDescribeResult,
 	KernelToolsInvokeOptions,

package/src/kernels/js/kernel-tools-types.ts

@@ -1,4 +1,5 @@
 import type { ExtensionKernelTools, KernelToolInvokeOptions, KernelToolInvokeScope } from "@code-yeongyu/senpi";
+import type { EvalLanguage } from "../../tool/types.ts";
 import type { KernelToolErrorCode, KernelToolHostDenial, KernelToolHostDenialReason } from "./kernel-tools-errors.ts";
 
 export type { KernelToolErrorCode, KernelToolHostDenial, KernelToolHostDenialReason };
@@ -7,7 +8,7 @@ export type KernelToolDescriptor = {
 	readonly name: string;
 	readonly description: string;
 	readonly input_schema: unknown;
-	readonly language: "js";
+	readonly language: EvalLanguage;
 	readonly kernel_generation: number;
 	readonly definition_revision: number;
 };

package/src/kernels/js/worker-global-sizes.js

@@ -9,6 +9,54 @@ const FUNCTION_BYTES = 64;
 const INTERNAL_GLOBAL_PREFIX = "__senpi";
 const MIN_REPORTED_BYTES = 1024 * 1024;
 
+function intrinsicGetter(prototype, name) {
+	return Object.getOwnPropertyDescriptor(prototype, name)?.get;
+}
+
+// Built-in getters captured at load: a user subclass that overrides `byteLength` or `size` is never called.
+const TYPED_ARRAY_BYTE_LENGTH = intrinsicGetter(Object.getPrototypeOf(Uint8Array.prototype), "byteLength");
+const DATA_VIEW_BYTE_LENGTH = intrinsicGetter(DataView.prototype, "byteLength");
+const ARRAY_BUFFER_BYTE_LENGTH = intrinsicGetter(ArrayBuffer.prototype, "byteLength");
+const SHARED_ARRAY_BUFFER_BYTE_LENGTH =
+	typeof SharedArrayBuffer === "function" ? intrinsicGetter(SharedArrayBuffer.prototype, "byteLength") : undefined;
+const MAP_SIZE = intrinsicGetter(Map.prototype, "size");
+const SET_SIZE = intrinsicGetter(Set.prototype, "size");
+const BLOB_SIZE = typeof Blob === "function" ? intrinsicGetter(Blob.prototype, "size") : undefined;
+// Iteration captured at load too: a user who replaces Map.prototype.entries or an iterator's next() is never called.
+const MAP_ENTRIES = Map.prototype.entries;
+const SET_VALUES = Set.prototype.values;
+const MAP_ITERATOR_NEXT = Object.getPrototypeOf(new Map().entries()).next;
+const SET_ITERATOR_NEXT = Object.getPrototypeOf(new Set().values()).next;
+
+function read(getter, value) {
+	return Reflect.apply(getter, value, []);
+}
+
+const GET_PROTOTYPE_OF = Object.getPrototypeOf;
+const BLOB_PROTOTYPE = typeof Blob === "function" ? Blob.prototype : undefined;
+
+function inheritsFromBlob(value) {
+	for (let prototype = GET_PROTOTYPE_OF(value); prototype !== null; prototype = GET_PROTOTYPE_OF(prototype)) {
+		// A Proxy in the chain would run its getPrototypeOf trap on the next step.
+		if (types.isProxy(prototype)) return false;
+		if (prototype === BLOB_PROTOTYPE) return true;
+	}
+	return false;
+}
+
+// The Blob brand: a cheap prototype-chain pre-check (no user hook; proxies never reach here) so ordinary
+// objects skip the try, then the size getter as the proof, which throws on a forged look-alike.
+// instanceof would call a user-redefinable Symbol.hasInstance.
+function isBlob(value) {
+	if (BLOB_SIZE === undefined || !inheritsFromBlob(value)) return false;
+	try {
+		read(BLOB_SIZE, value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 export function captureGlobalBaseline() {
 	return new Set(Object.getOwnPropertyNames(globalThis));
 }
@@ -55,11 +103,12 @@ function createSizer() {
 		return (total / SAMPLED_ELEMENTS) * length;
 	}
 
-	function entriesOf(iterable, count, depth, sizeOf) {
+	function entriesOf(iterator, next, count, depth, sizeOf) {
 		const taken = [];
-		for (const entry of iterable) {
-			taken.push(entry);
-			if (taken.length >= SAMPLED_ELEMENTS) break;
+		while (taken.length < SAMPLED_ELEMENTS) {
+			const step = Reflect.apply(next, iterator, []);
+			if (step.done) break;
+			taken.push(step.value);
 		}
 		if (taken.length < count) approximate = true;
 		let total = 0;
@@ -67,21 +116,42 @@ function createSizer() {
 		return total * (count / Math.max(1, taken.length));
 	}
 
+	// An own data element, never a getter: an accessor is left unsized and makes the estimate approximate.
+	function elementOf(array, index) {
+		const descriptor = Object.getOwnPropertyDescriptor(array, index);
+		if (descriptor === undefined) return undefined;
+		if ("value" in descriptor) return descriptor.value;
+		approximate = true;
+		return undefined;
+	}
+
 	function objectSize(value, depth) {
 		if (types.isProxy(value)) return OBJECT_BYTES;
-		if (ArrayBuffer.isView(value)) return value.byteLength;
-		if (types.isAnyArrayBuffer(value)) return value.byteLength;
-		if (typeof Blob === "function" && value instanceof Blob) return value.size;
-		if (Array.isArray(value)) return OBJECT_BYTES + value.length * POINTER_BYTES + sampled(value.length, (index) => value[index], depth);
-		if (value instanceof Map) {
-			const entries = Map.prototype.entries.call(value);
-			return OBJECT_BYTES + value.size * 2 * POINTER_BYTES + entriesOf(entries, value.size, depth, ([key, item], at) => size(key, at) + size(item, at));
+		if (types.isTypedArray(value)) return read(TYPED_ARRAY_BYTE_LENGTH, value);
+		if (types.isDataView(value)) return read(DATA_VIEW_BYTE_LENGTH, value);
+		if (types.isArrayBuffer(value)) return read(ARRAY_BUFFER_BYTE_LENGTH, value);
+		if (types.isSharedArrayBuffer(value) && SHARED_ARRAY_BUFFER_BYTE_LENGTH) return read(SHARED_ARRAY_BUFFER_BYTE_LENGTH, value);
+		if (isBlob(value)) return read(BLOB_SIZE, value);
+		if (Array.isArray(value)) {
+			const length = value.length;
+			return OBJECT_BYTES + length * POINTER_BYTES + sampled(length, (index) => elementOf(value, index), depth);
+		}
+		if (types.isMap(value)) {
+			const count = read(MAP_SIZE, value);
+			const entries = Reflect.apply(MAP_ENTRIES, value, []);
+			return OBJECT_BYTES + count * 2 * POINTER_BYTES + entriesOf(entries, MAP_ITERATOR_NEXT, count, depth, ([key, item], at) => size(key, at) + size(item, at));
+		}
+		if (types.isSet(value)) {
+			const count = read(SET_SIZE, value);
+			return OBJECT_BYTES + count * POINTER_BYTES + entriesOf(Reflect.apply(SET_VALUES, value, []), SET_ITERATOR_NEXT, count, depth, size);
 		}
-		if (value instanceof Set) return OBJECT_BYTES + value.size * POINTER_BYTES + entriesOf(Set.prototype.values.call(value), value.size, depth, size);
 		const keys = Object.keys(value);
 		const propertyValue = (index) => {
 			const descriptor = Object.getOwnPropertyDescriptor(value, keys[index]);
-			return descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+			if (descriptor === undefined) return undefined;
+			if ("value" in descriptor) return descriptor.value;
+			approximate = true;
+			return undefined;
 		};
 		return OBJECT_BYTES + keys.length * POINTER_BYTES + sampled(keys.length, propertyValue, depth);
 	}
@@ -114,7 +184,7 @@ function createSizer() {
 			try {
 				return { bytes: POINTER_BYTES + size(value, 0), approximate };
 			} catch (error) {
-				// A user value can still throw from an exotic element read (an index getter); it is left unsized.
+				// A forged built-in look-alike (a Blob-prototype object without its slot) throws from the intrinsic getter; it is left unsized.
 				if (error instanceof Error) return undefined;
 				throw error;
 			}

package/src/kernels/py/prelude.py

@@ -354,6 +354,11 @@ def write(path: str | Path, content: str) -> Path:
     return target
 
 
+# The bridge is a loopback call: urllib's default opener would route it through a configured proxy
+# (the environment everywhere, the registry on Windows), which a 127.0.0.1 request must never use.
+_BRIDGE_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+
 def bridge_post(path: str, payload: dict[str, Any]) -> Any:
     port = CONNECTION.get("port")
     token = CONNECTION.get("token")
@@ -369,7 +374,7 @@ def bridge_post(path: str, payload: dict[str, Any]) -> Any:
     emit_status(TIMEOUT_PAUSE_OP, force=True)
     try:
         try:
-            with urllib.request.urlopen(request, timeout=60) as response:
+            with _BRIDGE_OPENER.open(request, timeout=60) as response:
                 response_data = response.read()
         except urllib.error.HTTPError as exc:
             response_data = exc.read()

package/src/kernels/rb/kernel.ts

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { SessionEnvironment } from "../session-env.ts";
 import type { KernelLifecycle } from "../shared/kernel-death.ts";
+import { readProcessGroupCpuTime } from "../shared/process-group-cpu.ts";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { SubprocessKernel, type SubprocessKernelMemory, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
 
@@ -14,7 +15,7 @@ export interface RubyKernelStartOptions extends KernelLifecycle {
 	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). */
+	/** Memory management: the runner reports its largest globals and the host reads the interpreter footprint for the ceiling. */
 	readonly memory?: SubprocessKernelMemory;
 }
 
@@ -43,6 +44,7 @@ export class RubyKernel extends SubprocessKernel {
 			onMessage: options.onMessage,
 			memory: options.memory && { language: "rb", ...options.memory },
 			onDeath: options.onDeath,
+			startup: { label: "Ruby", readGroupCpuTime: readProcessGroupCpuTime },
 		});
 	}
 }

package/src/kernels/rb/runner.rb

@@ -1,6 +1,10 @@
+$stdout.write("{\"type\":\"status\",\"event\":{\"op\":\"kernel-startup\",\"stage\":\"stdlib-imports\"}}\n")
+$stdout.flush
 require "json"
 require "net/http"
 require "uri"
+$stdout.write("{\"type\":\"status\",\"event\":{\"op\":\"kernel-startup\",\"stage\":\"runtime-init\"}}\n")
+$stdout.flush
 
 $__senpi_binding = TOPLEVEL_BINDING
 $__senpi_frame_mutex = Mutex.new
@@ -119,6 +123,135 @@ 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
+SENPI_SIZER_POINTER = 8
+SENPI_SIZER_OBJECT = 40
+SENPI_SIZER_MIN_REPORTED = 1024 * 1024
+SENPI_ARRAY_AT = Array.instance_method(:[])
+SENPI_ARRAY_SIZE = Array.instance_method(:size)
+SENPI_HASH_SIZE = Hash.instance_method(:size)
+SENPI_HASH_EACH = Hash.instance_method(:each_pair)
+SENPI_STRING_BYTESIZE = String.instance_method(:bytesize)
+SENPI_IVARS = Kernel.instance_method(:instance_variables)
+SENPI_IVAR_GET = Kernel.instance_method(:instance_variable_get)
+
+# Sizes a global without running user code: built-ins are read through their own unbound methods, so an
+# override in a subclass is never called. Collections are sampled, and each global gets its own node
+# budget (leaves count against it too), so one deep global never hides the ones measured after it.
+class SenpiGlobalSizer
+  attr_reader :approximate
+
+  def initialize
+    @seen = {}.compare_by_identity
+    @nodes = 0
+    @approximate = false
+  end
+
+  def measure(value)
+    @approximate = false
+    @nodes = 0
+    SENPI_SIZER_POINTER + size(value, 0)
+  end
+
+  private
+
+  def size(value, depth)
+    @nodes += 1
+    return 0 if NilClass === value || TrueClass === value || FalseClass === value || Symbol === value
+    return ObjectSpace.memsize_of(value) if Integer === value || Float === value
+    return 0 if @seen.key?(value)
+    @seen[value] = true
+    return SENPI_SIZER_OBJECT + SENPI_STRING_BYTESIZE.bind_call(value) if String === value
+    if depth >= SENPI_SIZER_MAX_DEPTH || @nodes >= SENPI_SIZER_NODE_BUDGET
+      @approximate = true
+      return ObjectSpace.memsize_of(value)
+    end
+    if Array === value
+      length = SENPI_ARRAY_SIZE.bind_call(value)
+      SENPI_SIZER_OBJECT + length * SENPI_SIZER_POINTER + sampled(length, depth) { |index| SENPI_ARRAY_AT.bind_call(value, index) }
+    elsif Hash === value
+      hash_size(value, depth)
+    else
+      ivars = SENPI_IVARS.bind_call(value)
+      ObjectSpace.memsize_of(value) + sampled(ivars.length, depth) { |index| SENPI_IVAR_GET.bind_call(value, ivars[index]) }
+    end
+  end
+
+  def hash_size(hash, depth)
+    count = SENPI_HASH_SIZE.bind_call(hash)
+    taken = 0
+    total = 0
+    SENPI_HASH_EACH.bind_call(hash) do |key, item|
+      total += size(key, depth + 1) + size(item, depth + 1)
+      taken += 1
+      break if taken >= SENPI_SIZER_SAMPLE
+    end
+    @approximate = true if taken < count
+    SENPI_SIZER_OBJECT + count * 2 * SENPI_SIZER_POINTER + (taken.zero? ? 0 : total * count / taken)
+  end
+
+  # Up to SENPI_SIZER_SAMPLE evenly spaced elements; when the walk budget runs out part-way, the elements
+  # measured so far stand in for the rest, so a cut-short container is scaled up, not under-counted.
+  def sampled(length, depth)
+    return 0 if length.zero?
+    picks = [length, SENPI_SIZER_SAMPLE].min
+    @approximate = true if picks < length
+    step = length.to_f / picks
+    total = 0
+    measured = 0
+    picks.times do |sample|
+      if @nodes >= SENPI_SIZER_NODE_BUDGET
+        @approximate = true
+        break
+      end
+      total += size(yield((sample * step).floor), depth + 1)
+      measured += 1
+    end
+    measured.zero? ? 0 : (total.to_f / measured * length).round
+  end
+end
+
+def __senpi_largest_globals(limit)
+  require "objspace"
+  sizer = SenpiGlobalSizer.new
+  sized = []
+  measure = lambda do |name, value|
+    bytes = sizer.measure(value)
+    next if bytes < SENPI_SIZER_MIN_REPORTED
+    entry = { "name" => name, "bytes" => bytes }
+    entry["approximate"] = true if sizer.approximate
+    sized << entry
+  end
+  $__senpi_binding.local_variables.each do |name|
+    next if $__senpi_memory_baseline_locals.include?(name)
+    measure.call(name.to_s, $__senpi_binding.local_variable_get(name))
+  end
+  global_variables.each do |name|
+    next if $__senpi_memory_baseline_globals.include?(name) || name.to_s.start_with?("$__senpi_")
+    measure.call(name.to_s, eval(name.to_s))
+  end
+  sized.sort_by { |entry| -entry["bytes"] }.first(limit)
+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
@@ -172,6 +305,8 @@ 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({
@@ -187,11 +322,17 @@ def __senpi_run_cell(message)
   end
 end
 
+# Everything defined so far belongs to the runner or the interpreter, never to the user's cells.
+$__senpi_memory_baseline_locals = $__senpi_binding.local_variables
+$__senpi_memory_baseline_globals = global_variables
+
 $__senpi_protocol_stdin.each_line do |line|
   message = JSON.parse(line)
   case message["type"]
   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" })
   when "run"
     __senpi_run_cell(message)

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

@@ -10,8 +10,9 @@ export type FootprintReader = (pid: number) => { readonly bytes: number } | unde
 
 export interface KernelMemoryHostOptions {
 	/**
-	 * Host-measured kernel (rb, jl): the kernel reports no memory itself, so the host reads the
-	 * interpreter's footprint after each result. Such a kernel gets the ceiling only - no notice, no globals.
+	 * 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
+	 * notice and the ceiling both apply, with every reading counting (no collection precedes it).
 	 */
 	readonly readFootprint?: FootprintReader;
 }
@@ -31,12 +32,15 @@ export class KernelMemoryHost {
 		this.#policy =
 			this.#readFootprint === undefined
 				? new KernelMemoryPolicy(language, thresholds)
-				: new KernelMemoryPolicy(language, { ...thresholds, noticeBytes: 0 }, { collects: false });
+				: new KernelMemoryPolicy(language, thresholds, { collects: false });
 	}
 
 	annotate(result: ResultMessage, pid?: number): ResultMessage {
+		const runnerReport = result.memory;
 		const report =
-			this.#readFootprint === undefined ? result.memory : this.#footprintReport(this.#readFootprint, pid);
+			this.#readFootprint === undefined
+				? runnerReport
+				: this.#footprintReport(this.#readFootprint, pid, runnerReport);
 		return report === undefined ? result : { ...result, memory: this.#policy.annotate(report) };
 	}
 
@@ -54,10 +58,14 @@ export class KernelMemoryHost {
 		this.#policy.kernelRetired();
 	}
 
-	#footprintReport(read: FootprintReader, pid: number | undefined) {
+	#footprintReport(read: FootprintReader, pid: number | undefined, runnerReport: ResultMessage["memory"]) {
 		if (pid === undefined) return undefined;
 		const footprint = read(pid);
 		if (footprint === undefined) return undefined;
-		return { liveBytes: Math.round(footprint.bytes), measure: "footprint" as const };
+		return {
+			liveBytes: Math.round(footprint.bytes),
+			measure: "footprint" as const,
+			...(runnerReport?.globals === undefined ? {} : { globals: runnerReport.globals }),
+		};
 	}
 }

package/src/kernels/{js/kernel-tools-host.ts → shared/kernel-tools-pump.ts}

@@ -1,13 +1,13 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { generateCorrelationId } from "../../bridge/protocol.ts";
 import { RESERVED_AGENT_TOOL } from "../../bridge/reserved.ts";
-import { kernelToolError } from "./kernel-tools-errors.ts";
+import { kernelToolError } from "../js/kernel-tools-errors.ts";
 import type {
 	KernelToolsDescribeResult,
 	KernelToolsInvokeOptions,
 	KernelToolsInvokeRequest,
 	KernelToolsInvokeScope,
-} from "./kernel-tools-types.ts";
+} from "../js/kernel-tools-types.ts";
 
 type KernelToolReply = Extract<
 	KernelToHostMessage,