@code-yeongyu/senpi-codemode 2026.10.1 → 2026.10.2

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

@@ -0,0 +1,185 @@
+import { Buffer } from "node:buffer";
+import { syncBuiltinESMExports } from "node:module";
+import { isAbsolute, resolve, sep } from "node:path";
+import { isMainThread } from "node:worker_threads";
+
+// A worker thread cannot chdir (process.chdir throws ERR_WORKER_UNSUPPORTED_OPERATION under Node
+// and Bun), so every relative path a cell used resolved against the host process directory: in a
+// shared RPC host that is the host's state dir, not the session's project (omo#9371). The worker
+// therefore applies the session directory to the path-taking APIs itself. Patches touch only this
+// worker's module instances and globals; the host thread and its bash tool keep their own cwd.
+
+// Indexes of the path arguments each fs function takes; `symlink`'s target stays relative to the link.
+const FS_PATH_ARGS = {
+	access: [0],
+	appendFile: [0],
+	chmod: [0],
+	chown: [0],
+	copyFile: [0, 1],
+	cp: [0, 1],
+	createReadStream: [0],
+	createWriteStream: [0],
+	exists: [0],
+	lchmod: [0],
+	lchown: [0],
+	link: [0, 1],
+	lstat: [0],
+	lutimes: [0],
+	mkdir: [0],
+	mkdtemp: [0],
+	open: [0],
+	openAsBlob: [0],
+	opendir: [0],
+	readdir: [0],
+	readFile: [0],
+	readlink: [0],
+	realpath: [0],
+	rename: [0, 1],
+	rm: [0],
+	rmdir: [0],
+	stat: [0],
+	statfs: [0],
+	symlink: [1],
+	truncate: [0],
+	unlink: [0],
+	unwatchFile: [0],
+	utimes: [0],
+	watch: [0],
+	watchFile: [0],
+	writeFile: [0],
+};
+
+const CHILD_PROCESS_FILE_ARGS = ["spawn", "spawnSync", "execFile", "execFileSync", "fork"];
+const CHILD_PROCESS_COMMAND_ARGS = ["exec", "execSync"];
+
+export function installSessionCwd(cwd) {
+	if (isMainThread) throw new Error("installSessionCwd must only run inside a kernel worker thread");
+	const root = resolve(cwd);
+	const rootBytes = Buffer.from(root.endsWith(sep) ? root : `${root}${sep}`);
+	// fs also takes Buffer/Uint8Array paths; a relative one gets the session root prepended as bytes,
+	// so non-UTF-8 names survive. A file: URL is always absolute, so URLs pass through unchanged.
+	const at = (path) => {
+		if (typeof path === "string") return isAbsolute(path) ? path : resolve(root, path);
+		if (path instanceof Uint8Array && !isAbsolute(Buffer.from(path).toString("latin1"))) {
+			return Buffer.concat([rootBytes, path]);
+		}
+		return path;
+	};
+	process.cwd = () => root;
+	const path = process.getBuiltinModule("node:path");
+	const resolveFromProcess = path.resolve;
+	path.resolve = (...segments) => resolveFromProcess(root, ...segments);
+	patchFs(process.getBuiltinModule("node:fs"), process.getBuiltinModule("node:fs/promises"), at, root);
+	patchChildProcess(process.getBuiltinModule("node:child_process"), at, root);
+	patchBun(globalThis.Bun, at, root);
+	syncBuiltinESMExports();
+}
+
+function patchFs(fs, promises, at, root) {
+	const promiseModules = [...new Set([fs.promises, promises])];
+	for (const [name, indexes] of Object.entries(FS_PATH_ARGS)) {
+		replace(fs, name, (fn) => resolvingArgs(fn, indexes, at));
+		replace(fs, `${name}Sync`, (fn) => resolvingArgs(fn, indexes, at));
+		for (const target of promiseModules) replace(target, name, (fn) => resolvingArgs(fn, indexes, at));
+	}
+	replace(fs.realpath, "native", (fn) => resolvingArgs(fn, [0], at));
+	replace(fs.realpathSync, "native", (fn) => resolvingArgs(fn, [0], at));
+	for (const target of [fs, ...promiseModules]) {
+		for (const name of ["glob", "globSync"]) replace(target, name, (fn) => withOptionsCwd(fn, () => 1, root));
+	}
+}
+
+function patchChildProcess(childProcess, at, root) {
+	for (const name of CHILD_PROCESS_FILE_ARGS) {
+		replace(childProcess, name, (fn) => {
+			const withCwd = withOptionsCwd(fn, fileOptionsIndex, root);
+			return name === "fork" ? resolvingArgs(withCwd, [0], at) : withCwd;
+		});
+	}
+	for (const name of CHILD_PROCESS_COMMAND_ARGS) replace(childProcess, name, (fn) => withOptionsCwd(fn, () => 1, root));
+}
+
+function patchBun(bun, at, root) {
+	if (bun === null || typeof bun !== "object") return;
+	replace(bun, "file", (fn) => resolvingArgs(fn, [0], at));
+	replace(bun, "write", (fn) => resolvingArgs(fn, [0], at));
+	replace(bun, "spawn", (fn) => withBunSpawnCwd(fn, root));
+	replace(bun, "spawnSync", (fn) => withBunSpawnCwd(fn, root));
+	if (typeof bun.$?.cwd === "function") bun.$.cwd(root);
+	const glob = bun.Glob?.prototype;
+	if (glob) {
+		for (const name of ["scan", "scanSync"]) {
+			replace(glob, name, (fn) =>
+				function scan(options) {
+					return fn.call(this, globScanOptions(options, root));
+				},
+			);
+		}
+	}
+}
+
+function replace(target, name, wrap) {
+	const original = target?.[name];
+	if (typeof original !== "function") return;
+	target[name] = copyOwnProperties(original, wrap(original));
+}
+
+function copyOwnProperties(original, wrapped) {
+	for (const key of Reflect.ownKeys(original)) {
+		if (key === "length" || key === "name" || key === "prototype" || Object.hasOwn(wrapped, key)) continue;
+		const descriptor = Object.getOwnPropertyDescriptor(original, key);
+		if (descriptor) Object.defineProperty(wrapped, key, descriptor);
+	}
+	return wrapped;
+}
+
+function resolvingArgs(fn, indexes, at) {
+	return function resolvingPathArguments(...args) {
+		for (const index of indexes) if (index < args.length) args[index] = at(args[index]);
+		return fn.apply(this, args);
+	};
+}
+
+// spawn(file, args?, options?) and friends: options follow an args array, or an explicit
+// undefined args slot, otherwise they sit right after the file.
+function fileOptionsIndex(args) {
+	return Array.isArray(args[1]) || (args[1] == null && args.length > 2) ? 2 : 1;
+}
+
+function withOptionsCwd(fn, optionsIndex, root) {
+	return function withSessionCwd(...args) {
+		const index = optionsIndex(args);
+		const options = args[index];
+		if (options === undefined || options === null) args[index] = { cwd: root };
+		else if (typeof options === "function") args.splice(index, 0, { cwd: root });
+		else if (typeof options === "object") args[index] = { ...options, cwd: cwdFrom(options.cwd, root) };
+		return fn.apply(this, args);
+	};
+}
+
+function withBunSpawnCwd(fn, root) {
+	return function spawnInSessionCwd(...args) {
+		const [first, second] = args;
+		if (Array.isArray(first)) {
+			const options = second === undefined || second === null ? {} : second;
+			if (typeof options !== "object") return fn.apply(this, args);
+			return fn.call(this, first, { ...options, cwd: cwdFrom(options.cwd, root) }, ...args.slice(2));
+		}
+		if (first !== null && typeof first === "object") {
+			return fn.call(this, { ...first, cwd: cwdFrom(first.cwd, root) }, ...args.slice(1));
+		}
+		return fn.apply(this, args);
+	};
+}
+
+function globScanOptions(options, root) {
+	if (options === undefined || options === null) return { cwd: root };
+	if (typeof options === "string") return cwdFrom(options, root);
+	if (typeof options === "object") return { ...options, cwd: cwdFrom(options.cwd, root) };
+	return options;
+}
+
+function cwdFrom(cwd, root) {
+	if (cwd === undefined || cwd === null) return root;
+	return typeof cwd === "string" && !isAbsolute(cwd) ? resolve(root, cwd) : cwd;
+}

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

@@ -1,8 +1,16 @@
+import type { EventEmitter } from "node:events";
 import { Worker } from "node:worker_threads";
 import type { KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { WorkerLike } from "./inline-worker.ts";
 import type { JavaScriptKernelMode } from "./kernel-contract.ts";
 
+declare global {
+	// Inert outside the gate. Bun does not refresh named builtin constructor exports.
+	var __senpiCodemodeGateObserveResource:
+		| ((kind: "processes" | "workers" | "handles", resource: EventEmitter, closeEvent: "exit" | "close") => void)
+		| undefined;
+}
+
 export class WorkerStartupCancelledError extends Error {
 	readonly name = "WorkerStartupCancelledError";
 
@@ -27,12 +35,9 @@ export function spawnNodeWorker(
 	parallelPoolWidth: number,
 	mode: JavaScriptKernelMode = "worker",
 ): WorkerLike {
-	return wrapNodeWorker(
-		new Worker(url, {
-			workerData: { cwd, parallelPoolWidth },
-		}),
-		mode,
-	);
+	const worker = new Worker(url, { workerData: { cwd, parallelPoolWidth } });
+	globalThis.__senpiCodemodeGateObserveResource?.("workers", worker, "exit");
+	return wrapNodeWorker(worker, mode);
 }
 
 export function waitForReady(worker: WorkerLike, signal: AbortSignal): Promise<void> {

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

@@ -30,13 +30,16 @@ export class JsWorkerRuntime {
 	#hooks = null;
 	#pendingDisplays = [];
 	#children = new Set();
+	#shellWaits = new Set();
 	#onChildEvent;
+	#onShellWaitChange;
 	#tools;
 
 	constructor(options) {
 		this.#cwd = options.cwd;
 		this.#parallelPoolWidth = options.parallelPoolWidth;
 		this.#onChildEvent = typeof options.onChildEvent === "function" ? options.onChildEvent : null;
+		this.#onShellWaitChange = options.onShellWaitChange;
 		this.#localRoots = { ...(options.localRoots ?? {}) };
 		if (options.artifactsDir && !this.#localRoots.local) this.#localRoots.local = join(options.artifactsDir, "local");
 		this.#tools = createKernelToolRegistry({
@@ -51,7 +54,12 @@ export class JsWorkerRuntime {
 		return this.#tools;
 	}
 
+	get shellWaitActive() {
+		return this.#shellWaits.size > 0;
+	}
+
 	async run(code, cellId, hooks) {
+		this.#shellWaits.clear();
 		this.#hooks = hooks;
 		try {
 			let prelude = "";
@@ -158,6 +166,11 @@ export class JsWorkerRuntime {
 			isActive: () => this.#hooks !== null,
 			emitText: (stream, data) => this.#emitText(stream, data),
 			onChild: (child, spawnOptions) => this.#trackChild(child, spawnOptions),
+			onShellWait: (promise, waiting) => {
+				if (waiting) this.#shellWaits.add(promise);
+				else this.#shellWaits.delete(promise);
+				this.#onShellWaitChange?.();
+			},
 		});
 		globalThis.__senpi_restore_console__ = () => {
 			console.log = originalLog;

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

@@ -15,6 +15,8 @@ export interface ShellCaptureOptions {
 	readonly emitText: (stream: ShellCaptureStream, data: string) => void;
 	/** Receives every `Bun.spawn` child created while a cell is active so the runtime can kill it on interrupt. */
 	readonly onChild?: (child: ShellCaptureChild, spawnOptions?: unknown) => void;
+	/** Tracks native shell waits without starting an unawaited ShellPromise. */
+	readonly onShellWait?: (promise: object, waiting: boolean) => void;
 }
 
 export function installShellCapture(options: ShellCaptureOptions): ShellCaptureRestore;

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

@@ -41,7 +41,7 @@ function capturedShell(originalShell, options) {
 	const shell = (strings, ...expressions) => {
 		if (!options.isActive()) return originalShell(strings, ...expressions);
 		const promise = originalShell(isolateStdin(strings), ...expressions);
-		return captureShellPromise(promise, options.emitText);
+		return captureShellPromise(promise, options);
 	};
 	for (const key of Object.keys(originalShell)) shell[key] = originalShell[key];
 	for (const method of SHELL_CONFIG_METHODS) {
@@ -65,13 +65,20 @@ function isolateStdin(strings) {
 	return Object.freeze(Object.assign(cooked, { raw: Object.freeze(raw) }));
 }
 
-function captureShellPromise(promise, emitText) {
+function captureShellPromise(promise, options) {
 	const prototype = Object.getPrototypeOf(promise);
+	let waiting = false;
+	let settled = false;
+	const finish = () => {
+		settled = true;
+		if (waiting) options.onShellWait?.(promise, false);
+		waiting = false;
+	};
 	let echo = true;
 	const echoOnce = (output) => {
 		if (!echo) return;
 		echo = false;
-		emitShellOutput(output, emitText);
+		emitShellOutput(output, options.emitText);
 	};
 	prototype.quiet.call(promise);
 	promise.quiet = function quiet() {
@@ -86,13 +93,19 @@ function captureShellPromise(promise, emitText) {
 		};
 	}
 	promise.then = function then(onFulfilled, onRejected) {
+		if (!waiting && !settled) {
+			waiting = true;
+			options.onShellWait?.(promise, true);
+		}
 		return prototype.then.call(
 			this,
 			(output) => {
+				finish();
 				echoOnce(output);
 				return onFulfilled ? onFulfilled(output) : output;
 			},
 			(error) => {
+				finish();
 				echoOnce(error);
 				if (onRejected) return onRejected(error);
 				throw error;

package/src/kernels/py/kernel-contract.ts

@@ -3,6 +3,7 @@ import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/p
 import type { EvalKernelRunInput } from "../../tool/types.ts";
 import type { SessionEnvironment } from "../session-env.ts";
 import type { KernelSpawnProcess } from "./process.ts";
+import type { PythonStartupStage } from "./startup.ts";
 import type { PythonTransportResult } from "./transport.ts";
 
 export interface PythonKernelStartOptions {
@@ -13,7 +14,10 @@ export interface PythonKernelStartOptions {
 	readonly env?: NodeJS.ProcessEnv;
 	/** Per-session PI_* values merged into the interpreter environment at spawn. */
 	readonly sessionEnv?: SessionEnvironment;
+	/** Python bootstrap inactivity guard per advancing stage, not a total readiness deadline. */
 	readonly startupTimeoutMs?: number;
+	/** Observes bootstrap control events without mixing them into cell output callbacks. */
+	readonly onStartupProgress?: (stage: PythonStartupStage) => void;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly spawnProcess?: KernelSpawnProcess;
 	/** Post-cell collection, notice, and ceiling thresholds sent on `init`; absent leaves memory unmanaged. */

package/src/kernels/py/kernel.ts

@@ -1,15 +1,16 @@
+// allow: SIZE_OK — one persistent Python lifecycle state machine owns queue, generation, and retirement.
 import type { KernelInterruptHandle } from "../../tool/types.ts";
 import type { KernelToolsInvokeOptions } from "../js/kernel-tools-types.ts";
 import { rejectKernelToolsUnavailable } from "../kernel-tools-unavailable.ts";
 import { KernelMemoryHost } from "../shared/kernel-memory-host.ts";
 import { KernelPreludeTracker } from "../shared/kernel-prelude-plan.ts";
 import type { PendingRun, PythonKernelRunOptions, PythonKernelStartOptions, ResultMessage } from "./kernel-contract.ts";
+import { pythonStartupHangGuardMs } from "./startup.ts";
 import { failedPythonResult, PythonKernelTransport } from "./transport.ts";
 
 export type { PythonKernelRunOptions, PythonKernelStartOptions } from "./kernel-contract.ts";
 export type { KernelChild, KernelSpawnOptions, KernelSpawnProcess } from "./process.ts";
 
-const startupTimeoutMs = 5_000;
 const interruptEscalationMs = 5_000;
 
 export class PythonKernel {
@@ -229,7 +230,7 @@ export class PythonKernel {
 						: (this.#active?.input.onMessage ?? this.#options.onMessage);
 				callback?.(message);
 			},
-			startupTimeoutMs: this.#options.startupTimeoutMs ?? startupTimeoutMs,
+			startupTimeoutMs: this.#options.startupTimeoutMs ?? pythonStartupHangGuardMs,
 			isOwned: () => !this.#closed && generation === this.#generation,
 			onRetirementFailure: (transport, error) => {
 				if (!this.#transport) this.#transport = transport;

package/src/kernels/py/prelude.py

@@ -1,6 +1,13 @@
 from __future__ import annotations
 
 # noqa: SIZE_OK — this dependency-free subprocess prelude must ship as one file.
+import sys
+
+# Emit before importing the stdlib graph: a cold interpreter can still be making
+# progress after the former five-second total startup deadline.
+sys.__stdout__.write('{"type":"status","event":{"op":"kernel-startup","stage":"stdlib-imports"}}\n')
+sys.__stdout__.flush()
+
 import ast
 import asyncio  # noqa: ANYIO_OK — stdlib-only embedded kernel runner.
 import base64
@@ -15,7 +22,6 @@ import os
 import re
 import signal
 import subprocess
-import sys
 import time
 import traceback
 import types
@@ -29,6 +35,9 @@ from threading import Lock, Thread
 from typing import Any, Callable, Union
 from urllib.parse import unquote
 
+sys.__stdout__.write('{"type":"status","event":{"op":"kernel-startup","stage":"runtime-init"}}\n')
+sys.__stdout__.flush()
+
 CONNECTION: dict[str, Any] = {}
 USER_NS: dict[str, Any] = {"__name__": "__main__", "__doc__": None, "__builtins__": __builtins__}
 LOOP = asyncio.new_event_loop()
@@ -1463,6 +1472,7 @@ def _start_parent_watch() -> None:
 
 
 def main() -> None:
+    emit_status("kernel-startup", force=True, stage="host-init")
     signal.signal(signal.SIGINT, signal.SIG_IGN)
     _start_parent_watch()
     host_closed = False

package/src/kernels/py/process.ts

@@ -34,13 +34,15 @@ export function defaultSpawn(options: KernelSpawnOptions): KernelChild {
 	// watch for a parent that is already gone by the time the interpreter boots.
 	const env =
 		process.platform === "win32" ? options.env : { ...options.env, SENPI_PY_KERNEL_PARENT_PID: String(process.pid) };
-	return spawn(options.command, [...options.args], {
+	const child = spawn(options.command, [...options.args], {
 		cwd: options.cwd,
 		env,
 		stdio: "pipe",
 		detached: process.platform !== "win32",
 		windowsHide: true,
 	});
+	globalThis.__senpiCodemodeGateObserveResource?.("processes", child, "close");
+	return child;
 }
 
 export function splitCommand(commandLine: string): { readonly command: string; readonly args: readonly string[] } {

package/src/kernels/py/startup.ts

@@ -0,0 +1,75 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+
+// Fresh-cache Windows bootstrap: p99 5,220 ms across 30 samples in Actions run
+// 36882163342. Twice that observation, rounded up to a second, is a hang guard,
+// not a total startup budget: only an advancing kernel stage rearms it.
+export const pythonStartupHangGuardMs = 11_000;
+
+const stages = ["interpreter-launch", "stdlib-imports", "runtime-init", "host-init"] as const;
+export type PythonStartupStage = (typeof stages)[number];
+
+export class PythonKernelStartupError extends Error {
+	readonly stage: PythonStartupStage;
+
+	constructor(stage: PythonStartupStage, reason: string, cause?: Error) {
+		super(`Python kernel startup failed at ${stage}: ${reason}`, { cause });
+		this.name = "PythonKernelStartupError";
+		this.stage = stage;
+	}
+}
+
+/** Owns the ready event and a per-stage inactivity watchdog, never a total deadline. */
+export class PythonStartup {
+	readonly #timeoutMs: number;
+	readonly #failureDetail: () => string;
+	readonly #ready = Promise.withResolvers<void>();
+	readonly ready = this.#ready.promise;
+	#timer: NodeJS.Timeout | undefined;
+	#stageIndex = 0;
+	#settled = false;
+
+	constructor(timeoutMs: number, failureDetail: () => string) {
+		this.#timeoutMs = timeoutMs;
+		this.#failureDetail = failureDetail;
+		this.#arm();
+	}
+
+	progress(message: KernelToHostMessage): PythonStartupStage | undefined {
+		if (this.#settled || message.type !== "status" || message.event.op !== "kernel-startup") return;
+		const stage = stages.find((candidate) => candidate === message.event.stage);
+		if (stage === undefined) return;
+		const next = stages.indexOf(stage);
+		if (next <= this.#stageIndex) return;
+		this.#stageIndex = next;
+		this.#arm();
+		return stage;
+	}
+
+	settle(error?: Error): boolean {
+		if (this.#settled) return false;
+		this.#settled = true;
+		clearTimeout(this.#timer);
+		if (error) {
+			const stage = stages[this.#stageIndex] ?? "interpreter-launch";
+			this.#ready.reject(
+				error instanceof PythonKernelStartupError
+					? error
+					: new PythonKernelStartupError(stage, error.message, error),
+			);
+		} else this.#ready.resolve();
+		return true;
+	}
+
+	#arm(): void {
+		clearTimeout(this.#timer);
+		this.#timer = setTimeout(() => {
+			const detail = this.#failureDetail().trim();
+			this.settle(
+				new PythonKernelStartupError(
+					stages[this.#stageIndex] ?? "interpreter-launch",
+					`no progress for ${this.#timeoutMs}ms${detail ? `; ${detail}` : ""}`,
+				),
+			);
+		}, this.#timeoutMs);
+	}
+}

package/src/kernels/py/transport.ts

@@ -23,8 +23,8 @@ import {
 	splitCommand,
 	sweepProcessGroup,
 	waitForExit,
-	withTimeout,
 } from "./process.ts";
+import { PythonStartup, type PythonStartupStage } from "./startup.ts";
 
 export type PythonTransportResult = Extract<KernelToHostMessage, { type: "result" }>;
 
@@ -44,6 +44,7 @@ export interface PythonTransportOptions {
 	/** Per-session PI_* values merged into the interpreter environment at spawn. */
 	readonly sessionEnv?: SessionEnvironment;
 	readonly startupTimeoutMs: number;
+	readonly onStartupProgress?: (stage: PythonStartupStage) => void;
 	readonly memory?: KernelMemoryThresholds;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly spawnProcess?: KernelSpawnProcess;
@@ -73,7 +74,7 @@ export class PythonKernelTransport {
 	readonly #child: KernelChild;
 	#stdoutBuffer = "";
 	#stderrTail = "";
-	#settleReady: ((error?: Error) => void) | null = null;
+	#startup: PythonStartup | null = null;
 	#detachChildListeners: (() => void) | null = null;
 	#active = true;
 	#exited = false;
@@ -173,9 +174,8 @@ export class PythonKernelTransport {
 	}
 
 	async #initialize(): Promise<void> {
-		const ready = new Promise<void>((resolve, reject) => {
-			this.#settleReady = (error) => (error ? reject(error) : resolve());
-		});
+		const startup = new PythonStartup(this.#options.startupTimeoutMs, () => this.#stderrTail);
+		this.#startup = startup;
 		const onStdout = (chunk: unknown) => this.#onStdout(String(chunk));
 		const onStderr = (chunk: unknown) => this.#onStderr(String(chunk));
 		const onError = (error: unknown) => this.#onError(error instanceof Error ? error : new Error(String(error)));
@@ -192,7 +192,7 @@ export class PythonKernelTransport {
 		this.#child.on("exit", onExit);
 		const { sessionId, connection, memory } = this.#options;
 		this.#write({ type: "init", sessionId, connection, ...(memory === undefined ? {} : { memory }) });
-		await withTimeout(ready, this.#options.startupTimeoutMs, "Python kernel did not become ready");
+		await startup.ready;
 	}
 
 	#write(message: HostToKernelMessage): void {
@@ -225,6 +225,11 @@ export class PythonKernelTransport {
 		}
 		if (!isKernelToHostMessage(decoded.message)) return;
 		const message = decoded.message;
+		if (message.type === "status" && message.event.op === "kernel-startup") {
+			const stage = this.#startup?.progress(message);
+			if (stage !== undefined) this.#options.onStartupProgress?.(stage);
+			return;
+		}
 		if (message.type === "ready") this.#settleStartup();
 		else if (message.type === "init-failed") this.#settleStartup(new Error(message.error.message));
 		else if (message.type === "result") this.#options.onResult(this, message);
@@ -258,11 +263,7 @@ export class PythonKernelTransport {
 	}
 
 	#settleStartup(error?: Error): boolean {
-		const settle = this.#settleReady;
-		if (!settle) return false;
-		this.#settleReady = null;
-		settle(error);
-		return true;
+		return this.#startup?.settle(error) ?? false;
 	}
 }
 

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

@@ -165,10 +165,12 @@ export class SubprocessProcess {
 
 export function spawnSubprocess(spawn: SubprocessSpawn | undefined, request: SubprocessSpawnRequest): SubprocessLike {
 	if (spawn) return spawn(request.command, request.args, { cwd: request.cwd, env: request.env });
-	return nodeSpawn(request.command, [...request.args], {
+	const child = nodeSpawn(request.command, [...request.args], {
 		cwd: request.cwd,
 		detached: true,
 		env: request.env,
 		stdio: ["pipe", "pipe", "pipe"],
 	});
+	globalThis.__senpiCodemodeGateObserveResource?.("processes", child, "close");
+	return child;
 }

package/src/prompt/eval-prompt-template.ts

@@ -29,7 +29,7 @@ Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to it
 A cell that outlives the foreground window detaches and keeps running; further cells on the same language queue behind it in submission order on the same kernel (state is shared, execution is serial) while other languages run at once, up to {{maxDetachedCells}} background cells per session; each detached cell completes as one notification. Do not re-run a detached or queued cell; read, cancel or enumerate them with \`eval({ action: "peek" | "stop", cell_id })\` / \`eval({ action: "list" })\`; list shows live and recently settled cells across languages without consuming notifications. Its own execution time is capped at {{runBudgetSeconds}}s — queue time and time inside host tool calls are not charged; the hard limit stays wall-clock from submission; raise \`timeout\` only for a declared long run — and a killed js cell that cannot settle restarts its kernel with every global lost.
 
 {{#if py}}Python runs on a live event loop: use top-level \`await\`; \`asyncio.run(…)\` raises.{{/if}}
-{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot. Shell out through \`Bun.$\` or \`Bun.spawn\`, never \`Bun.spawnSync\`: a synchronous child blocks the worker and cannot be interrupted.{{#if bunSkillPath}} MUST READ the bun-1-4 skill at {{bunSkillPath}} before your first js cell — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
+{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot. Shell out through \`Bun.$\` or \`Bun.spawn\`, never \`Bun.spawnSync\`: a synchronous child blocks the worker and cannot be interrupted.{{#if bunSkillPath}} Before a cell that installs a package, spawns a server or PTY, or starts a long run, read the bun-1-4 skill at {{bunSkillPath}} — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
 {{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
 {{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
 On error, fix and re-run only the failing step; a normal error keeps state, while a timeout or stop message says whether the kernel restarted.

package/src/skill/bun-1-4/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: bun-1-4
-description: "MUST READ before your first js eval cell: this session's eval js kernel runs Bun 1.4+ (this skill is present only when it does). Also read before any bun -e, script, server, CLI, test, bundle, or package-management work. Bun 1.4 ships builtins that replace 15+ npm deps — check here BEFORE installing sharp, puppeteer/playwright (scraping), marked, node-cron, node-pty, concurrently, serve-static, tar, json5, fast-xml-parser, string-width. Triggers: eval js, bun, Bun.serve, bun test, bun build, bun install, bun run, image resize, headless browser, markdown render, cron, PTY."
+description: "Read before a js eval cell that installs a package, spawns a server or PTY, or starts a long run, and before any bun -e, script, server, CLI, test, bundle, or package-management work: this session's eval js kernel runs Bun 1.4+ (this skill is present only when it does). Bun 1.4 ships builtins that replace 15+ npm deps — check here BEFORE installing sharp, puppeteer/playwright (scraping), marked, node-cron, node-pty, concurrently, serve-static, tar, json5, fast-xml-parser, string-width. Triggers: eval js, bun, Bun.serve, bun test, bun build, bun install, bun run, image resize, headless browser, markdown render, cron, PTY."
 ---
 
 # Bun 1.4 — Use the Builtins First

package/src/tool/cell-handler.ts

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import {
 	type AgentToolResult,
 	type ExtensionContext,
@@ -54,11 +55,18 @@ export class CellHandler {
 	readonly #state: CellState;
 	readonly #runtime: CellBridgeRuntime;
 	readonly #resultBuilder: CellResultBuilder;
+	readonly #dispatchContext: ReturnType<typeof AsyncLocalStorage.snapshot>;
 
 	constructor(kernel: EvalKernel, state: CellState, runtime: CellBridgeRuntime) {
 		this.#kernel = kernel;
 		this.#state = state;
 		this.#runtime = runtime;
+		// Construct in the submitting cell's host context; worker callbacks cannot supply it (#2512).
+		// Bind this cell's capability once; undefined clears any enclosing JS grant for non-JS cells.
+		this.#dispatchContext =
+			runtime.kernelTools === undefined
+				? kernelToolsStorage.exit(() => AsyncLocalStorage.snapshot())
+				: kernelToolsStorage.run(runtime.kernelTools, () => AsyncLocalStorage.snapshot());
 		const settings = runtime.settings.outputSink;
 		this.#resultBuilder = new CellResultBuilder({
 			state,
@@ -89,7 +97,8 @@ export class CellHandler {
 				this.#resultBuilder.display(message);
 				return;
 			case "tool-call": {
-				const pending = this.#dispatchToolCall(message);
+				// A retained worker carries its creation context, not this cell's RPC connection.
+				const pending = this.#dispatchContext(() => this.#handleToolCall(message));
 				this.#state.pendingBridgeCalls.push(pending);
 				await pending;
 				return;
@@ -122,19 +131,6 @@ export class CellHandler {
 		return this.#resultBuilder.liveResult();
 	}
 
-	/**
-	 * The worker's message loop fires outside the async context `run-eval-cell.ts` enters around the
-	 * awaited run chain, so the capability has to be entered here — around the whole dispatch, including
-	 * the reserved agent()/output() bridges where a host task tool resolves the parent's kernel tools —
-	 * for exactly the duration of each host tool call this cell makes (#1754). Without a capability
-	 * (py/rb/jl) the store stays empty and `ctx.kernelTools` remains undefined.
-	 */
-	async #dispatchToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
-		const kernelTools = this.#runtime.kernelTools;
-		if (kernelTools === undefined) return await this.#handleToolCall(message);
-		return await kernelToolsStorage.run(kernelTools, async () => await this.#handleToolCall(message));
-	}
-
 	async #handleToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
 		const startedAt = Date.now();
 		const metric = createToolCallMetric(message.toolName, startedAt);