@code-yeongyu/senpi-codemode 2026.8.26 → 2026.8.28-2

package/CHANGELOG.md

@@ -12,6 +12,62 @@
 
 ### Removed
 
+## [2026.8.28-2] - 2026-08-28
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.8.28] - 2026-08-28
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- JavaScript and Python eval kernels resolve worker and prelude assets from the executable sidecar in Bun-compiled distributions instead of passing unusable `$bunfs` paths to `Worker` and `python3`.
+
+### Removed
+
+## [2026.8.27] - 2026-08-27
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- Eval tool description examples are now a JS-first mixed set: set up once in JavaScript, fan out batched `Promise.all` session-tool calls in the next cell, then hop to Python when the JS kernel is busy with a detached cell. The detach paragraph now states in the same sentence that another language can continue.
+
+### Fixed
+
+- Detached-eval same-language busy errors now name each idle enabled kernel and tell the agent to continue the step there (`continue this step in an idle kernel: js`), instead of only pointing at peek and the output tail. A busy Python kernel no longer reads as "eval is unavailable", which previously sent agents to `bash`+`python3` while JavaScript (or another idle kernel) was free. Single-language sessions and fully-busy sessions omit the idle-kernel claim.
+- JavaScript eval cells now persist only top-level declarations, including destructuring bindings and uninitialized variables, without rewriting declaration-shaped text inside literals or comments.
+- Eval completion and detached-cell handling retain explicit lifecycle observability: nested tool counts, wall/kernel timing, detach state, `peek`, `stop`, hard limits, and crash recovery remain bounded and machine-readable for hosts and telemetry consumers.
+
+### Removed
+
+## [2026.8.26-2] - 2026-08-26
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.8.26] - 2026-08-26
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.8.26",
+	"version": "2026.8.28-2",
 	"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.8.26",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.8.28-2",
 		"typebox": "1.3.18"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.8.26"
+		"@code-yeongyu/senpi": "2026.8.28-2"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.8.26"
+		"@code-yeongyu/senpi": "2026.8.28-2"
 	},
 	"keywords": [
 		"senpi",

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

@@ -1,5 +1,8 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
+import { type CodemodeRuntimeAssetEnvironment, resolveCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
 import {
 	assertJavaScriptKernelOpen,
@@ -16,6 +19,15 @@ import { bridgeError, spawnNodeWorker, WorkerStartupCancelledError, waitForReady
 export { JavaScriptKernelClosedError, type JavaScriptKernelMode, type JavaScriptRunInput } from "./kernel-contract.ts";
 export type { JavaScriptKernelOptions } from "./local-module-loader.ts";
 
+export interface JavaScriptWorkerEntryUrlOptions extends CodemodeRuntimeAssetEnvironment {
+	readonly localPath?: string;
+}
+
+export function resolveJsWorkerEntryUrl(options: JavaScriptWorkerEntryUrlOptions = {}): URL {
+	const localPath = options.localPath ?? join(dirname(fileURLToPath(import.meta.url)), "worker-entry.js");
+	return pathToFileURL(resolveCodemodeRuntimeAsset(localPath, join("kernels", "js", "worker-entry.js"), options));
+}
+
 export class JavaScriptKernel {
 	readonly #options: JavaScriptKernelOptions;
 	readonly #moduleLoader: LocalModuleLoader;
@@ -161,7 +173,7 @@ export class JavaScriptKernel {
 
 	#spawnWorker(): WorkerLike {
 		try {
-			const url = this.#options.workerEntryUrl ?? new URL("./worker-entry.js", import.meta.url);
+			const url = this.#options.workerEntryUrl ?? resolveJsWorkerEntryUrl();
 			return spawnNodeWorker(url, this.#options.cwd, this.#options.parallelPoolWidth);
 		} catch (error) {
 			if (!(error instanceof Error)) throw error;

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

@@ -1,7 +1,21 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { type CodemodeRuntimeAssetEnvironment, resolveCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import type { JavaScriptKernelMode } from "./kernel-contract.ts";
 import { spawnNodeWorker } from "./worker-host.ts";
 
+export interface JavaScriptInlineWorkerEntryUrlOptions extends CodemodeRuntimeAssetEnvironment {
+	readonly localPath?: string;
+}
+
+export function resolveInlineWorkerEntryUrl(options: JavaScriptInlineWorkerEntryUrlOptions = {}): URL {
+	const localPath = options.localPath ?? join(dirname(fileURLToPath(import.meta.url)), "inline-worker-entry.js");
+	return pathToFileURL(
+		resolveCodemodeRuntimeAsset(localPath, join("kernels", "js", "inline-worker-entry.js"), options),
+	);
+}
+
 export interface WorkerLike {
 	readonly mode: JavaScriptKernelMode;
 	postMessage(message: HostToKernelMessage): void;
@@ -11,5 +25,5 @@ export interface WorkerLike {
 }
 
 export function createInlineWorker(cwd: string, parallelPoolWidth: number): WorkerLike {
-	return spawnNodeWorker(new URL("./inline-worker-entry.js", import.meta.url), cwd, parallelPoolWidth, "inline");
+	return spawnNodeWorker(resolveInlineWorkerEntryUrl(), cwd, parallelPoolWidth, "inline");
 }

package/src/kernels/js/worker-indirect-eval.js

@@ -10,11 +10,721 @@ export async function awaitMaybePromise(value) {
 }
 
 export function wrapUserCode(code) {
-	const persistentCode = code.replace(/(^|\n)\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/gu, "$1globalThis.$2 =");
+	const persistentCode = persistTopLevelDeclarations(code);
 	if (/\breturn\b/u.test(persistentCode)) return `(async () => {\n${persistentCode}\n})()`;
 	return `(async () => {\n${captureLastExpression(persistentCode)}\n})()`;
 }
 
+const IDENTIFIER_START_RE = /[$_\p{ID_Start}]/u;
+const IDENTIFIER_CONTINUE_RE = /[$_\p{ID_Continue}\u200c\u200d]/u;
+const IDENTIFIER_RE = /^[\p{ID_Start}$_][\p{ID_Continue}\u200c\u200d]*$/u;
+const DECLARATION_KEYWORDS = new Set(["const", "let", "var"]);
+const REGEX_PREFIX_KEYWORDS = new Set([
+	"await",
+	"case",
+	"delete",
+	"do",
+	"else",
+	"in",
+	"instanceof",
+	"new",
+	"of",
+	"return",
+	"throw",
+	"typeof",
+	"void",
+	"yield",
+]);
+const EXPRESSION_PREFIX_KEYWORDS = new Set(["await", "delete", "new", "throw", "typeof", "void", "yield"]);
+
+function persistTopLevelDeclarations(code) {
+	const edits = [];
+	let round = 0;
+	let square = 0;
+	let curly = 0;
+	let statementStart = true;
+	let canStartRegex = true;
+
+	for (let index = 0; index < code.length; index += 1) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (char === "/" && next === "/") {
+			index = skipLineComment(code, index) - 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index = skipBlockComment(code, index) - 1;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			index = skipQuotedLiteral(code, index) - 1;
+			statementStart = false;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "`") {
+			index = skipTemplateLiteral(code, index) - 1;
+			statementStart = false;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "/" && canStartRegex) {
+			index = skipRegexLiteral(code, index) - 1;
+			statementStart = false;
+			canStartRegex = false;
+			continue;
+		}
+		if (isIdentifierStart(char)) {
+			const end = readIdentifier(code, index);
+			const token = code.slice(index, end);
+			if (round === 0 && square === 0 && curly === 0 && statementStart && DECLARATION_KEYWORDS.has(token)) {
+				const declarationEnd = findDeclarationEnd(code, end);
+				const replacement = rewriteDeclaration(code, index, end, declarationEnd, token);
+				if (replacement !== undefined) edits.push({ start: index, end: declarationEnd, text: replacement });
+			}
+			statementStart = false;
+			canStartRegex = REGEX_PREFIX_KEYWORDS.has(token);
+			index = end - 1;
+			continue;
+		}
+		if (isDecimalDigit(char)) {
+			index = skipNumberLiteral(code, index) - 1;
+			statementStart = false;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "(") {
+			round += 1;
+			statementStart = false;
+			canStartRegex = true;
+			continue;
+		}
+		if (char === ")") {
+			round = Math.max(0, round - 1);
+			statementStart = false;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "[") {
+			square += 1;
+			statementStart = false;
+			canStartRegex = true;
+			continue;
+		}
+		if (char === "]") {
+			square = Math.max(0, square - 1);
+			statementStart = false;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "{") {
+			curly += 1;
+			statementStart = false;
+			canStartRegex = true;
+			continue;
+		}
+		if (char === "}") {
+			curly = Math.max(0, curly - 1);
+			statementStart = curly === 0 && round === 0 && square === 0;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === ";") {
+			statementStart = round === 0 && square === 0 && curly === 0;
+			canStartRegex = true;
+			continue;
+		}
+		if (isLineTerminator(char) && round === 0 && square === 0 && curly === 0) {
+			statementStart = true;
+			canStartRegex = true;
+			continue;
+		}
+		if (!/\s/u.test(char)) {
+			statementStart = false;
+			canStartRegex = isExpressionOperator(char);
+		}
+	}
+
+	return applyTextEdits(code, edits);
+}
+
+function findDeclarationEnd(code, start) {
+	let round = 0;
+	let square = 0;
+	let curly = 0;
+	let canEnd = false;
+	let canStartRegex = true;
+
+	for (let index = start; index < code.length; index += 1) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (char === "/" && next === "/") {
+			index = skipLineComment(code, index) - 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index = skipBlockComment(code, index) - 1;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			index = skipQuotedLiteral(code, index) - 1;
+			canEnd = true;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "`") {
+			index = skipTemplateLiteral(code, index) - 1;
+			canEnd = true;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "/" && canStartRegex) {
+			index = skipRegexLiteral(code, index) - 1;
+			canEnd = true;
+			canStartRegex = false;
+			continue;
+		}
+		if (isIdentifierStart(char)) {
+			const end = readIdentifier(code, index);
+			const token = code.slice(index, end);
+			canEnd = !EXPRESSION_PREFIX_KEYWORDS.has(token);
+			canStartRegex = REGEX_PREFIX_KEYWORDS.has(token);
+			index = end - 1;
+			continue;
+		}
+		if (isDecimalDigit(char)) {
+			index = skipNumberLiteral(code, index) - 1;
+			canEnd = true;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "(") {
+			round += 1;
+			canEnd = false;
+			canStartRegex = true;
+			continue;
+		}
+		if (char === ")") {
+			round = Math.max(0, round - 1);
+			canEnd = true;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "[") {
+			square += 1;
+			canEnd = false;
+			canStartRegex = true;
+			continue;
+		}
+		if (char === "]") {
+			square = Math.max(0, square - 1);
+			canEnd = true;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "{") {
+			curly += 1;
+			canEnd = false;
+			canStartRegex = true;
+			continue;
+		}
+		if (char === "}") {
+			curly = Math.max(0, curly - 1);
+			canEnd = true;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === ";" && round === 0 && square === 0 && curly === 0) return index + 1;
+		if (char === "," && round === 0 && square === 0 && curly === 0) {
+			canEnd = false;
+			canStartRegex = true;
+			continue;
+		}
+		if (isLineTerminator(char) && round === 0 && square === 0 && curly === 0 && canEnd) {
+			const nextIndex = nextSignificantIndex(code, index + 1);
+			if (nextIndex >= code.length || !isDeclarationContinuation(code[nextIndex])) return index;
+		}
+		if (!/\s/u.test(char)) {
+			canEnd = false;
+			canStartRegex = isExpressionOperator(char);
+		}
+	}
+	return code.length;
+}
+
+function rewriteDeclaration(code, declarationStart, start, end, keyword) {
+	const source = code.slice(declarationStart, end);
+	const assignments = [];
+	const preserveDeclaration = source.includes("//") || source.includes("/*");
+	for (const [segmentStart, segmentEnd] of splitDeclarators(code, start, end)) {
+		const segment = code.slice(segmentStart, segmentEnd);
+		if (!segment.trim()) continue;
+		const initializerStart = findTopLevelEquals(segment);
+		if (initializerStart < 0 && keyword === "const") return undefined;
+		const pattern = trimPattern(initializerStart < 0 ? segment : segment.slice(0, initializerStart));
+		const bindings = [];
+		collectPatternNames(pattern, bindings);
+		if (bindings.length === 0) return undefined;
+		const target = rewriteBindingPattern(pattern);
+		if (target === undefined) return undefined;
+		const initializer = initializerStart < 0 ? "undefined" : segment.slice(initializerStart + 1).trim();
+		const [assignmentInitializer, comment] = splitTrailingLineComment(initializer);
+		const assignmentComment = preserveDeclaration ? "" : comment;
+		assignments.push(
+			`${target.startsWith("{") || target.startsWith("[") ? `(${target} = ${assignmentInitializer})` : `${target} = ${assignmentInitializer}`};${assignmentComment}`,
+		);
+	}
+	if (assignments.length === 0) return undefined;
+	return preserveDeclaration ? `${source}\n${assignments.join("\n")}` : assignments.join("\n");
+}
+
+function rewriteBindingPattern(source) {
+	const pattern = trimPattern(source);
+	if (!pattern) return undefined;
+	const defaultStart = findTopLevelEquals(pattern);
+	if (defaultStart >= 0) {
+		const target = rewriteBindingPattern(pattern.slice(0, defaultStart));
+		return target === undefined ? undefined : `${target} = ${pattern.slice(defaultStart + 1).trim()}`;
+	}
+	if (IDENTIFIER_RE.test(pattern)) return `globalThis[${JSON.stringify(pattern)}]`;
+	if (pattern.startsWith("{") && pattern.endsWith("}")) {
+		const properties = splitPatternElements(pattern.slice(1, -1)).map((property) => rewriteObjectBinding(property));
+		if (properties.some((property) => property === undefined)) return undefined;
+		return `{${properties.filter((property) => property !== undefined).join(", ")}}`;
+	}
+	if (pattern.startsWith("[") && pattern.endsWith("]")) {
+		const elements = splitPatternElements(pattern.slice(1, -1)).map((element) => {
+			if (!element.trim()) return "";
+			const rest = trimPattern(element).startsWith("...");
+			const target = rewriteBindingPattern(rest ? trimPattern(element).slice(3) : element);
+			return target === undefined ? undefined : rest ? `...${target}` : target;
+		});
+		if (elements.some((element) => element === undefined)) return undefined;
+		return `[${elements.join(", ")}]`;
+	}
+	return undefined;
+}
+
+function rewriteObjectBinding(source) {
+	const property = trimPattern(source);
+	if (!property) return "";
+	if (property.startsWith("...")) {
+		const target = rewriteBindingPattern(property.slice(3));
+		return target === undefined ? undefined : `...${target}`;
+	}
+	const initializerStart = findTopLevelEquals(property);
+	const colon = findTopLevelColon(property);
+	if (colon >= 0 && (initializerStart < 0 || colon < initializerStart)) {
+		const target = rewriteBindingPattern(property.slice(colon + 1));
+		return target === undefined ? undefined : `${property.slice(0, colon + 1).trim()} ${target}`;
+	}
+	if (initializerStart >= 0) {
+		const target = rewriteBindingPattern(property.slice(0, initializerStart));
+		return target === undefined ? undefined : `${property.slice(0, initializerStart).trim()}: ${target} = ${property.slice(initializerStart + 1).trim()}`;
+	}
+	const target = rewriteBindingPattern(property);
+	return target === undefined ? undefined : `${property}: ${target}`;
+}
+
+function collectPatternNames(source, bindings) {
+	const pattern = trimPattern(source);
+	if (!pattern) return;
+	const defaultStart = findTopLevelEquals(pattern);
+	if (defaultStart >= 0) {
+		collectPatternNames(pattern.slice(0, defaultStart), bindings);
+		return;
+	}
+	if (pattern.startsWith("{") && pattern.endsWith("}")) {
+		for (const property of splitPatternElements(pattern.slice(1, -1))) {
+			const trimmed = trimPattern(property);
+			if (!trimmed) continue;
+			if (trimmed.startsWith("...")) {
+				collectPatternNames(trimmed.slice(3), bindings);
+				continue;
+			}
+			const equals = findTopLevelEquals(trimmed);
+			const colon = findTopLevelColon(trimmed);
+			if (colon >= 0 && (equals < 0 || colon < equals)) collectPatternNames(trimmed.slice(colon + 1), bindings);
+			else collectPatternNames(equals < 0 ? trimmed : trimmed.slice(0, equals), bindings);
+		}
+		return;
+	}
+	if (pattern.startsWith("[") && pattern.endsWith("]")) {
+		for (const element of splitPatternElements(pattern.slice(1, -1))) {
+			const trimmed = trimPattern(element);
+			if (!trimmed) continue;
+			collectPatternNames(trimmed.startsWith("...") ? trimmed.slice(3) : trimmed, bindings);
+		}
+		return;
+	}
+	const equals = findTopLevelEquals(pattern);
+	const name = trimPattern(equals < 0 ? pattern : pattern.slice(0, equals));
+	if (IDENTIFIER_RE.test(name)) bindings.push(name);
+}
+
+function splitDeclarators(code, start, end) {
+	const ranges = [];
+	let segmentStart = start;
+	let round = 0;
+	let square = 0;
+	let curly = 0;
+	let canStartRegex = true;
+	for (let index = start; index < end; index += 1) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (char === "/" && next === "/") {
+			index = Math.min(end, skipLineComment(code, index)) - 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index = Math.min(end, skipBlockComment(code, index)) - 1;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			index = Math.min(end, skipQuotedLiteral(code, index)) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "`") {
+			index = Math.min(end, skipTemplateLiteral(code, index)) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "/" && canStartRegex) {
+			index = Math.min(end, skipRegexLiteral(code, index)) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "(") round += 1;
+		else if (char === ")") round = Math.max(0, round - 1);
+		else if (char === "[") square += 1;
+		else if (char === "]") square = Math.max(0, square - 1);
+		else if (char === "{") curly += 1;
+		else if (char === "}") curly = Math.max(0, curly - 1);
+		else if (char === "," && round === 0 && square === 0 && curly === 0) {
+			ranges.push([segmentStart, index]);
+			segmentStart = index + 1;
+		}
+		if (!/\s/u.test(char)) canStartRegex = isExpressionOperator(char) || char === "(" || char === "[" || char === "{";
+	}
+	if (segmentStart < end && code.slice(segmentStart, end).trim() !== ";") ranges.push([segmentStart, end - (code[end - 1] === ";" ? 1 : 0)]);
+	return ranges;
+}
+
+function splitPatternElements(source) {
+	const elements = [];
+	let start = 0;
+	let round = 0;
+	let square = 0;
+	let curly = 0;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (char === "/" && next === "/") {
+			index = skipLineComment(source, index) - 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index = skipBlockComment(source, index) - 1;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			index = skipQuotedLiteral(source, index) - 1;
+			continue;
+		}
+		if (char === "`") {
+			index = skipTemplateLiteral(source, index) - 1;
+			continue;
+		}
+		if (char === "(") round += 1;
+		else if (char === ")") round = Math.max(0, round - 1);
+		else if (char === "[") square += 1;
+		else if (char === "]") square = Math.max(0, square - 1);
+		else if (char === "{") curly += 1;
+		else if (char === "}") curly = Math.max(0, curly - 1);
+		else if (char === "," && round === 0 && square === 0 && curly === 0) {
+			elements.push(source.slice(start, index));
+			start = index + 1;
+		}
+	}
+	elements.push(source.slice(start));
+	return elements;
+}
+
+function findTopLevelEquals(source) {
+	return findTopLevelCharacter(source, "=");
+}
+
+function findTopLevelColon(source) {
+	return findTopLevelCharacter(source, ":");
+}
+
+function findTopLevelCharacter(source, target) {
+	let round = 0;
+	let square = 0;
+	let curly = 0;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (char === "/" && next === "/") {
+			index = skipLineComment(source, index) - 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index = skipBlockComment(source, index) - 1;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			index = skipQuotedLiteral(source, index) - 1;
+			continue;
+		}
+		if (char === "`") {
+			index = skipTemplateLiteral(source, index) - 1;
+			continue;
+		}
+		if (char === "(") round += 1;
+		else if (char === ")") round = Math.max(0, round - 1);
+		else if (char === "[") square += 1;
+		else if (char === "]") square = Math.max(0, square - 1);
+		else if (char === "{") curly += 1;
+		else if (char === "}") curly = Math.max(0, curly - 1);
+		else if (char === target && round === 0 && square === 0 && curly === 0) return index;
+	}
+	return -1;
+}
+
+function applyTextEdits(code, edits) {
+	let output = code;
+	for (const edit of edits.toSorted((left, right) => right.start - left.start)) {
+		output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+	}
+	return output;
+}
+
+function splitTrailingLineComment(source) {
+	let canStartRegex = true;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (char === "/" && next === "/") return [source.slice(0, index).trimEnd(), source.slice(index)];
+		if (char === "/" && next === "*") {
+			index = skipBlockComment(source, index) - 1;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			index = skipQuotedLiteral(source, index) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "`") {
+			index = skipTemplateLiteral(source, index) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "/" && canStartRegex) {
+			index = skipRegexLiteral(source, index) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (isIdentifierStart(char)) {
+			const end = readIdentifier(source, index);
+			canStartRegex = REGEX_PREFIX_KEYWORDS.has(source.slice(index, end));
+			index = end - 1;
+			continue;
+		}
+		if (isDecimalDigit(char)) {
+			index = skipNumberLiteral(source, index) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (!/\s/u.test(char)) canStartRegex = isExpressionOperator(char) || char === "(" || char === "[" || char === "{";
+	}
+	return [source, ""];
+}
+
+function trimPattern(source) {
+	let start = 0;
+	let end = source.length;
+	while (start < end) {
+		if (/\s/u.test(source[start])) {
+			start += 1;
+			continue;
+		}
+		if (source.startsWith("//", start)) {
+			start = skipLineComment(source, start);
+			continue;
+		}
+		if (source.startsWith("/*", start)) {
+			start = skipBlockComment(source, start);
+			continue;
+		}
+		break;
+	}
+	while (true) {
+		while (end > start && /\s/u.test(source[end - 1])) end -= 1;
+		if (end < start + 2 || source.slice(end - 2, end) !== "*/") break;
+		const commentStart = source.lastIndexOf("/*", end - 2);
+		if (commentStart < start) break;
+		end = commentStart;
+	}
+	return source.slice(start, end);
+}
+
+function nextSignificantIndex(code, start) {
+	for (let index = start; index < code.length; index += 1) {
+		if (/\s/u.test(code[index])) continue;
+		if (code.startsWith("//", index)) {
+			index = skipLineComment(code, index) - 1;
+			continue;
+		}
+		if (code.startsWith("/*", index)) {
+			index = skipBlockComment(code, index) - 1;
+			continue;
+		}
+		return index;
+	}
+	return code.length;
+}
+
+function isDeclarationContinuation(char) {
+	return char !== undefined && /[.[(,+\-*/%&|^?:<>=!~]/u.test(char);
+}
+
+function isExpressionOperator(char) {
+	return /[=,+\-*/%&|^?:<>!~]/u.test(char);
+}
+
+function isIdentifierStart(char) {
+	return char !== undefined && IDENTIFIER_START_RE.test(char);
+}
+
+function readIdentifier(code, start) {
+	let index = start + 1;
+	while (index < code.length && IDENTIFIER_CONTINUE_RE.test(code[index])) index += 1;
+	return index;
+}
+
+function isDecimalDigit(char) {
+	return char !== undefined && /[0-9]/u.test(char);
+}
+
+function skipNumberLiteral(code, start) {
+	let index = start + 1;
+	while (index < code.length && /[0-9A-Fa-f_xXn.eE]/u.test(code[index])) index += 1;
+	return index;
+}
+
+function skipQuotedLiteral(code, start) {
+	const quote = code[start];
+	for (let index = start + 1; index < code.length; index += 1) {
+		if (code[index] === "\\") {
+			index += 1;
+			continue;
+		}
+		if (code[index] === quote) return index + 1;
+	}
+	return code.length;
+}
+
+function skipTemplateLiteral(code, start) {
+	for (let index = start + 1; index < code.length; index += 1) {
+		const char = code[index];
+		if (char === "\\") {
+			index += 1;
+			continue;
+		}
+		if (char === "`") return index + 1;
+		if (char === "$" && code[index + 1] === "{") {
+			index = skipTemplateExpression(code, index + 2) - 1;
+		}
+	}
+	return code.length;
+}
+
+function skipTemplateExpression(code, start) {
+	let curly = 1;
+	let canStartRegex = true;
+	for (let index = start; index < code.length; index += 1) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (char === "/" && next === "/") {
+			index = skipLineComment(code, index) - 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			index = skipBlockComment(code, index) - 1;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			index = skipQuotedLiteral(code, index) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "`") {
+			index = skipTemplateLiteral(code, index) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "/" && canStartRegex) {
+			index = skipRegexLiteral(code, index) - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (isIdentifierStart(char)) {
+			const end = readIdentifier(code, index);
+			canStartRegex = REGEX_PREFIX_KEYWORDS.has(code.slice(index, end));
+			index = end - 1;
+			continue;
+		}
+		if (char === "{") curly += 1;
+		else if (char === "}" && --curly === 0) return index + 1;
+		canStartRegex = char === "(" || char === "[" || char === "{" || isExpressionOperator(char) || char === ",";
+	}
+	return code.length;
+}
+
+function skipRegexLiteral(code, start) {
+	let inClass = false;
+	for (let index = start + 1; index < code.length; index += 1) {
+		const char = code[index];
+		if (char === "\\") {
+			index += 1;
+			continue;
+		}
+		if (char === "[") {
+			inClass = true;
+			continue;
+		}
+		if (char === "]") {
+			inClass = false;
+			continue;
+		}
+		if (char === "/" && !inClass) {
+			let end = index + 1;
+			while (end < code.length && /[A-Za-z]/u.test(code[end])) end += 1;
+			return end;
+		}
+		if (isLineTerminator(char)) return index;
+	}
+	return code.length;
+}
+
+function skipLineComment(code, start) {
+	for (let index = start + 2; index < code.length; index += 1) {
+		if (isLineTerminator(code[index])) return index;
+	}
+	return code.length;
+}
+
+function isLineTerminator(char) {
+	return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
+}
+
+function skipBlockComment(code, start) {
+	const end = code.indexOf("*/", start + 2);
+	return end < 0 ? code.length : end + 2;
+}
+
 function captureLastExpression(code) {
 	const start = findLastTopLevelStatementStart(code);
 	const head = code.slice(0, start);

package/src/kernels/py/transport.ts

@@ -8,6 +8,7 @@ import {
 	isKernelToHostMessage,
 	type KernelToHostMessage,
 } from "../../bridge/protocol.ts";
+import { type CodemodeRuntimeAssetEnvironment, resolveCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import {
 	defaultSpawn,
 	hardKill,
@@ -47,6 +48,18 @@ export interface PythonTransportOptions {
 
 const hardKillWaitMs = 500;
 
+export interface PythonPreludePathOptions extends CodemodeRuntimeAssetEnvironment {
+	readonly localPath?: string;
+}
+
+export function resolvePythonPreludePath(options: PythonPreludePathOptions = {}): string {
+	return resolveCodemodeRuntimeAsset(
+		options.localPath ?? join(dirname(fileURLToPath(import.meta.url)), "prelude.py"),
+		join("kernels", "py", "prelude.py"),
+		options,
+	);
+}
+
 export class PythonKernelTransport {
 	readonly #options: PythonTransportOptions;
 	readonly #child: KernelChild;
@@ -64,7 +77,7 @@ export class PythonKernelTransport {
 	}
 
 	static async start(options: PythonTransportOptions): Promise<PythonKernelTransport> {
-		const scriptPath = join(dirname(fileURLToPath(import.meta.url)), "prelude.py");
+		const scriptPath = resolvePythonPreludePath();
 		const invocation = splitCommand(options.interpreterPath);
 		const spawnOptions: KernelSpawnOptions = {
 			command: invocation.command,

package/src/prompt/eval-prompt.ts

@@ -70,21 +70,21 @@ type EvalPromptExample = {
 const REUSE_CHAIN_EXAMPLES = [
 	{
 		caption: "First call — set up once",
-		language: "py",
+		language: "js",
 		summary: "Count all TypeScript source files under src/ excluding tests",
-		code: "from pathlib import Path\nfrom collections import Counter\nfiles = [p for p in Path('src').rglob('*.ts') if 'test' not in p.parts]\nprint(len(files))",
+		code: "import { readdir } from 'node:fs/promises'\nimport { extname } from 'node:path'\nconst files = (await readdir('src', { recursive: true })).filter(f => extname(f) === '.ts' && !f.includes('test'))\nprint(files.length)",
 	},
 	{
-		caption: "Second call — reuse `files`, batch-read in one cell",
-		language: "py",
-		summary: "Find which files reference legacyClient so we know what to migrate",
-		code: "hits = Counter()\nfor p in files:\n    hits[p.name] = read(p).count('legacyClient')\ndisplay({k: v for k, v in hits.items() if v})",
+		caption: "Second call — reuse `files`, fan out session tools in parallel",
+		language: "js",
+		summary: "Grep legacyClient per directory in one cell",
+		code: "const dirs = [...new Set(files.map(f => f.split('/')[0]))]\nconst hits = await Promise.all(dirs.map(d => tool.grep({ pattern: 'legacyClient', path: d })))\ndisplay(hits.map(h => h.matches?.length ?? 0))",
 	},
 	{
-		caption: "Third call — reuse results, fan out session tools in parallel",
+		caption: "JS kernel is busy with a detached cell — continue in py",
 		language: "py",
-		summary: "Confirm exact callsite lines in each directory to plan the refactor",
-		code: "dirs = ['src/core', 'src/tools']\ndisplay(parallel([lambda d=d: tool.grep({'pattern': 'legacyClient', 'path': d}) for d in dirs]))",
+		summary: "Aggregate legacyClient hits while JS is busy",
+		code: "from pathlib import Path\nprint(sum('legacyClient' in read(p) for p in Path('src').rglob('*.ts')))",
 	},
 ] as const satisfies readonly EvalPromptExample[];
 
@@ -129,7 +129,7 @@ Fields:
 - \`reset\` (optional) — wipe this language's kernel first.{{#ifAll py js}} Per-language: a \`py\` reset never touches the JS VM.{{/ifAll}}
 - \`action\` (optional) — defaults to \`"run"\`. A detached cell returns its id: use \`eval({ action: "peek", cell_id })\` for buffered output/state or \`eval({ action: "stop", cell_id })\` to cancel it.
 
-A detached cell keeps its language kernel busy while it finishes. Do not re-run a detached cell: the same-language busy error names its cell id and output tail; another language can continue. Completion arrives as one notification with the final value/error and buffered output. Stopping a cell interrupts its kernel; the stop result states whether kernel state survived or the kernel was restarted and its variables lost.
+A detached cell keeps its language kernel busy while it finishes; another language can continue. Do not re-run a detached cell: the same-language busy error names its cell id and output tail. Completion arrives as one notification with the final value/error and buffered output. Stopping a cell interrupts its kernel; the stop result states whether kernel state survived or the kernel was restarted and its variables lost.
 
 {{#if py}}Live event loop: use top-level \`await\` directly; \`asyncio.run(…)\` raises "cannot be called from a running event loop".{{/if}}
 {{#if js}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}

package/src/tool/detached-eval-result.ts

@@ -5,7 +5,7 @@ import type {
 	EvalDetachedCellState,
 } from "./detached-cell-manager.ts";
 import { interruptionStateNote } from "./interrupt-note.ts";
-import type { EvalCellResult, EvalControlInput, EvalToolDetails, EvalToolInput } from "./types.ts";
+import type { EvalCellResult, EvalControlInput, EvalLanguage, EvalToolDetails, EvalToolInput } from "./types.ts";
 
 export async function executeEvalControl(
 	cellManager: EvalDetachedCellManager,
@@ -101,10 +101,16 @@ export function resultForDetachedState(
 	};
 }
 
-export function detachedKernelBusyError(snapshot: EvalDetachedCellSnapshot): Error {
+export function detachedKernelBusyError(
+	snapshot: EvalDetachedCellSnapshot,
+	idleLanguages: readonly EvalLanguage[] = [],
+): Error {
 	const tail = snapshot.outputTail.length === 0 ? "(no output yet)" : snapshot.outputTail;
+	const peek = `eval({ action: "peek", cell_id: "${snapshot.cellId}" })`;
+	const idleHint =
+		idleLanguages.length === 0 ? "" : ` or continue this step in an idle kernel: ${idleLanguages.join(", ")}`;
 	return new Error(
-		`The ${snapshot.language} eval kernel is busy running detached cell ${snapshot.cellId}. Do not re-run it; use eval({ action: "peek", cell_id: "${snapshot.cellId}" }). Current output tail:\n${tail}`,
+		`The ${snapshot.language} eval kernel is busy running detached cell ${snapshot.cellId} - peek with ${peek}${idleHint}. Do not re-run the busy cell. Current output tail:\n${tail}`,
 	);
 }
 

package/src/tool/eval-tool.ts

@@ -67,7 +67,12 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 					`Unsupported eval language "${request.language}". Enabled languages: ${languages.join(", ")}`,
 				);
 			const busy = cellManager.busyFor(request.language);
-			if (busy !== undefined) throw detachedKernelBusyError(busy);
+			if (busy !== undefined) {
+				const idleLanguages = languages.filter(
+					(language) => language !== request.language && cellManager.busyFor(language) === undefined,
+				);
+				throw detachedKernelBusyError(busy, idleLanguages);
+			}
 			options.executionTracker?.assertEvalExecutionAllowed();
 			const lifecycleController = new AbortController();
 			const combinedSignal = signal