@code-yeongyu/senpi-codemode 2026.10.31-2 → 2026.11.2-1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [2026.11.02-1] - 2026-11-02
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- An eval call that leaves out `language` now runs when the kernel is unambiguous (only one language enabled, or clear js/py code markers) and its result says the language was inferred ([#5157](https://github.com/code-yeongyu/senpi/pull/5157))
+
+### Fixed
+
+- Python Windows startup supports native builtin path helpers without losing captured permission identity isolation, and the isolated compiled-host check includes all Python runtime assets ([#5052](https://github.com/code-yeongyu/senpi/pull/5052)).
+- A Ruby or Julia kernel whose interpreter cannot be spawned (for example `julia` missing from `PATH`) now fails its cells with the spawn error (`Kernel startup failed: spawn julia ENOENT`) and closes at once, instead of waiting two seconds for an exit that never comes and reporting `Kernel process did not exit after SIGKILL` (#3500) ([#5181](https://github.com/code-yeongyu/senpi/pull/5181))
+- A stopped JavaScript cell no longer runs code from an `fs` callback operation that was already in flight when it was stopped: the callback is dropped (a late `fs.open` descriptor is closed), the same way the stopped cell's timers never fire, so a stopped polling loop cannot tick once more after the stop ([#5179](https://github.com/code-yeongyu/senpi/issues/5179))
+
+### Removed
+
 ## [2026.10.31-2] - 2026-10-31
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.10.31-2",
+	"version": "2026.11.02-1",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -33,15 +33,15 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.31-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.11.02-1",
 		"quickjs-wasi": "3.6.2",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.10.31-2"
+		"@code-yeongyu/senpi": "2026.11.02-1"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.10.31-2"
+		"@code-yeongyu/senpi": "2026.11.02-1"
 	},
 	"keywords": [
 		"senpi",

package/src/kernels/js/cell-ownership.js

@@ -152,14 +152,23 @@ function refuseWhenReleased(owner, names, patched) {
 	}
 }
 
-// The callback form: a released cell's operation is never started, so its callback never runs, the same way a timer a
-// released cell sets never fires.
+// The callback form: a released cell's operation is never started, and one already in flight when the cell is released
+// never calls back, the same way a timer a released cell sets never fires. A file it opened late is closed instead.
 function neverStartWhenReleased(owner, names, patched) {
 	for (const name of names) {
 		const original = owner?.[name];
 		if (typeof original !== "function") continue;
 		const guarded = function (...args) {
-			if (currentCell()?.released) return undefined;
+			const cell = currentCell();
+			if (cell?.released) return undefined;
+			const callback = args.at(-1);
+			if (cell !== undefined && typeof callback === "function") {
+				args[args.length - 1] = function (error, ...results) {
+					if (!cell.released) return callback.call(this, error, ...results);
+					if (name === "open" && error == null && Number.isInteger(results[0])) owner.close(results[0], () => {});
+					return undefined;
+				};
+			}
 			return original.apply(this, args);
 		};
 		Object.assign(guarded, original);

package/src/kernels/py/path_identity_windows.py

@@ -27,7 +27,9 @@ def windows_primitives(failure):
         if isinstance(function, types.FunctionType) and function.__globals__ is vars(ntpath):
             namespace[name] = types.FunctionType(function.__code__, namespace, name, function.__defaults__)
     dirname, basename, normpath, splitdrive = (
-        types.FunctionType(getattr(ntpath, name).__code__, namespace, name)
+        # C builtins do not read ntpath's mutable module globals.
+        types.FunctionType(function.__code__, namespace, name, function.__defaults__)
+        if isinstance(function := getattr(ntpath, name), types.FunctionType) else function
         for name in ("dirname", "basename", "normpath", "splitdrive")
     )
     getcwd = os.getcwd

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

@@ -231,7 +231,10 @@ export class SubprocessKernel {
 			onStderr: (source, data) => this.handleMessage(source, { type: "text", stream: "stderr", data }),
 			onExit: (source, code, signal) => this.handleExit(source, code, signal),
 			onError: (source, error) => {
-				if (this.accepts(source)) this.failClosed(new KernelProcessError(error.message));
+				if (!this.accepts(source)) return;
+				this.failClosed(
+					source.neverStarted ? new KernelStartupError(error.message) : new KernelProcessError(error.message),
+				);
 			},
 		});
 		this.process = process;

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

@@ -52,6 +52,7 @@ export class SubprocessProcess {
 	private readonly errorListener: (error: Error) => void;
 	private readonly stdinErrorListener: (error: Error) => void;
 	private exited = false;
+	private spawnFailed = false;
 	private retiring = false;
 	private outputDetached = false;
 	private errorReported = false;
@@ -68,6 +69,13 @@ export class SubprocessProcess {
 		this.errorListener = (error) => {
 			if (this.errorReported) return;
 			this.errorReported = true;
+			// senpi#3500: a child whose spawn failed has no pid and never emits "exit"; there is no process to retire.
+			if (child.pid === undefined && String(Reflect.get(error, "syscall")).startsWith("spawn")) {
+				this.spawnFailed = true;
+				this.exited = true;
+				this.detachOutput();
+				this.exit.resolve();
+			}
 			this.handlers.onError(this, error);
 		};
 		this.stdoutReader.on("line", (line) => {
@@ -96,6 +104,10 @@ export class SubprocessProcess {
 		return this.retiring;
 	}
 
+	get neverStarted(): boolean {
+		return this.spawnFailed;
+	}
+
 	send(frame: string): boolean {
 		if (this.retiring || this.exited) return false;
 		this.child.stdin.write(frame);

package/src/tool/eval-argument-validator.ts

@@ -1,5 +1,6 @@
 import { type JsonObject, registerToolArgumentValidator, validateToolArguments } from "@earendil-works/pi-ai";
 import type { TSchema } from "typebox";
+import { EVAL_LANGUAGE_INFERRED_KEY, inferEvalLanguage, markEvalLanguageFilled } from "./eval-language-inference.ts";
 import { type EvalRunField, evalRunFieldRequiredMessage, normalizeEvalSummary } from "./eval-request.ts";
 import type { EvalLanguage } from "./types.ts";
 
@@ -17,21 +18,36 @@ const RUN_FIELDS: readonly EvalRunField[] = ["language", "code", "summary"];
 export function registerEvalArgumentValidator(schema: TSchema, languages: readonly EvalLanguage[]): void {
 	// The same schema under another identity, so the generic path validates it instead of calling back here.
 	const generic: TSchema = Object.create(Object.getPrototypeOf(schema), Object.getOwnPropertyDescriptors(schema));
+	const genericValidate = (args: unknown): unknown =>
+		validateToolArguments(
+			{ name: "eval", description: "", parameters: generic },
+			{ type: "toolCall", id: "", name: "eval", arguments: args as JsonObject },
+		);
 	const validate: EvalArgumentValidator = (value) => {
+		const callerArguments = structuredClone(value);
+		const inferred = fillInferredLanguage(value, languages);
 		const missing = missingRunFieldErrors(value, languages);
 		if (missing.length > 0) {
 			validate.errors = missing;
 			return false;
 		}
-		// Throws the generic validation error unchanged when the call is invalid for any other reason.
-		const coerced: unknown = validateToolArguments(
-			{ name: "eval", description: "", parameters: generic },
-			{ type: "toolCall", id: "", name: "eval", arguments: value as JsonObject },
-		);
+		let coerced: unknown;
+		try {
+			// Throws the generic validation error unchanged when the call is invalid for any other reason.
+			coerced = genericValidate(value);
+		} catch (error) {
+			// A filled language stands only for a call that validates; otherwise report what the caller sent.
+			if (inferred !== undefined) genericValidate(callerArguments);
+			throw error;
+		}
 		// A registered validator's input is what the caller returns, so the generic coercion lands in place.
 		if (isRecord(value) && isRecord(coerced)) {
 			for (const key of Object.keys(value)) delete value[key];
 			Object.assign(value, coerced);
+			if (inferred !== undefined) {
+				value[EVAL_LANGUAGE_INFERRED_KEY] = inferred;
+				markEvalLanguageFilled(value);
+			}
 		}
 		validate.errors = null;
 		return true;
@@ -39,6 +55,20 @@ export function registerEvalArgumentValidator(schema: TSchema, languages: readon
 	registerToolArgumentValidator(schema, validate);
 }
 
+/**
+ * Fills an omitted run language when it is unambiguous (senpi#5154), before the missing-field check, and drops any
+ * inference marker the caller sent so only this fill can set it. An explicit language is never changed.
+ */
+function fillInferredLanguage(value: unknown, languages: readonly EvalLanguage[]): string | undefined {
+	if (!isRecord(value) || (value.action !== undefined && value.action !== "run")) return undefined;
+	delete value[EVAL_LANGUAGE_INFERRED_KEY];
+	if (!isMissing("language", value.language)) return undefined;
+	const inference = inferEvalLanguage(value.code, languages);
+	if (inference === undefined) return undefined;
+	value.language = inference.language;
+	return inference.basis;
+}
+
 function missingRunFieldErrors(value: unknown, languages: readonly EvalLanguage[]): EvalArgumentError[] {
 	if (!isRecord(value) || (value.action !== undefined && value.action !== "run")) return [];
 	return RUN_FIELDS.filter((field) => isMissing(field, value[field])).map((field) => ({

package/src/tool/eval-language-inference.ts

@@ -0,0 +1,116 @@
+import type { EvalLanguage } from "./types.ts";
+
+/** Why an omitted run language was filled: the only enabled kernel, or unambiguous code markers (senpi#5154). */
+export type EvalLanguageInferenceBasis = "only-enabled-language" | "code-markers";
+
+export interface EvalLanguageInference {
+	readonly language: EvalLanguage;
+	readonly basis: EvalLanguageInferenceBasis;
+}
+
+/** The argument key validation sets when it filled the language, so execution can tell the model. */
+export const EVAL_LANGUAGE_INFERRED_KEY = "language_inferred";
+
+// Argument objects whose language this module's validator filled; only these may carry a trusted inference marker.
+const filledArguments = new WeakSet<object>();
+
+export function markEvalLanguageFilled(args: object): void {
+	filledArguments.add(args);
+}
+
+/** True only when argument validation filled this object's language; a caller-sent marker is never trusted. */
+export function wasEvalLanguageFilled(args: object): boolean {
+	return filledArguments.has(args);
+}
+
+interface LanguageSignals {
+	/** Any one of these fills the language when the other language shows no signal at all. */
+	readonly strong: readonly RegExp[];
+	/** These never fill; they only veto a fill for the other language. */
+	readonly weak: readonly RegExp[];
+}
+
+const PYTHON_IDENTIFIER = "[A-Za-z_]\\w*";
+const PYTHON_MODULE = `${PYTHON_IDENTIFIER}(?:\\.${PYTHON_IDENTIFIER})*`;
+const PYTHON_IMPORT_ITEM = `${PYTHON_MODULE}(?:[ \\t]+as[ \\t]+${PYTHON_IDENTIFIER})?`;
+
+const SIGNALS: Readonly<Record<"js" | "py", LanguageSignals>> = {
+	py: {
+		strong: [
+			/^[ \t]*def[ \t]+[A-Za-z_]\w*[ \t]*\(/mu,
+			new RegExp(
+				`^[ \\t]*import[ \\t]+${PYTHON_IMPORT_ITEM}(?:[ \\t]*,[ \\t]*${PYTHON_IMPORT_ITEM})*[ \\t]*$`,
+				"mu",
+			),
+			new RegExp(`^[ \\t]*from[ \\t]+\\.*${PYTHON_MODULE}[ \\t]+import[ \\t]+[\\w(*]`, "mu"),
+		],
+		weak: [
+			/\b(?:None|True|False|elif|lambda|self)\b/u,
+			/^[ \t]*(?:if|elif|else|for|while|with|try|except|finally|class|async[ \t]+def)\b.*:[ \t]*(?:#.*)?$/mu,
+			/^[ \t]*#/mu,
+		],
+	},
+	js: {
+		strong: [
+			// `print(` is a prelude helper in both runtimes, so it is no signal at all; these forms are JS-only.
+			/\bawait[ \t]+[A-Za-z_$][\w$.]*[ \t]*\(/u,
+			/`/u,
+			/(?<![\w.$])(?:JSON|Object|Array)\.[A-Za-z_$]/u,
+			/^[ \t]*(?:const|let)[ \t]+[A-Za-z_$[{]/mu,
+			/=>/u,
+			/\bconsole\.log\(/u,
+			/^[ \t]*import[ \t].*\bfrom[ \t]*["']/mu,
+			/^[ \t]*import[ \t]*["']/mu,
+		],
+		weak: [
+			/\b(?:null|undefined|function|var|typeof|new)\b/u,
+			/===|!==|&&|\|\||\+\+/u,
+			/;[ \t]*$/mu,
+			/^[ \t]*\/\//mu,
+			/[{}][ \t]*$/mu,
+		],
+	},
+};
+
+function signals(code: string, language: "js" | "py"): { readonly strong: boolean; readonly any: boolean } {
+	const { strong, weak } = SIGNALS[language];
+	const hasStrong = strong.some((pattern) => pattern.test(code));
+	return { strong: hasStrong, any: hasStrong || weak.some((pattern) => pattern.test(code)) };
+}
+
+/**
+ * Classifies a cell body as js or py only on a strong marker of one language with no signal of the other;
+ * anything else, including any conflicting signal, is unclassified.
+ */
+export function classifyEvalCode(code: string): "js" | "py" | undefined {
+	const py = signals(code, "py");
+	const js = signals(code, "js");
+	if (py.strong && !js.any) return "py";
+	if (js.strong && !py.any) return "js";
+	return undefined;
+}
+
+/**
+ * The language an omitted run language may be filled with: the only enabled kernel, or, when exactly js and py are
+ * enabled, the classified code. Any other case returns undefined and the caller keeps its teaching error.
+ */
+export function inferEvalLanguage(
+	code: unknown,
+	languages: readonly EvalLanguage[],
+): EvalLanguageInference | undefined {
+	const [only] = languages;
+	if (languages.length === 1 && only !== undefined) return { language: only, basis: "only-enabled-language" };
+	if (languages.length !== 2 || !languages.includes("js") || !languages.includes("py")) return undefined;
+	if (typeof code !== "string") return undefined;
+	const language = classifyEvalCode(code);
+	return language === undefined ? undefined : { language, basis: "code-markers" };
+}
+
+export function isEvalLanguageInferenceBasis(value: unknown): value is EvalLanguageInferenceBasis {
+	return value === "only-enabled-language" || value === "code-markers";
+}
+
+/** The line an inferred-language result leads with, so the model sees the fill and passes language next time. */
+export function evalLanguageInferredNote(language: EvalLanguage, basis: EvalLanguageInferenceBasis): string {
+	return `${EVAL_LANGUAGE_INFERRED_KEY}: ${language} (${basis}). This eval run omitted language; pass language explicitly.`;
+}

package/src/tool/eval-request.ts

@@ -6,6 +6,13 @@ import {
 	type EvalToolRequest,
 	evalLanguageOrder,
 } from "./types.ts";
+import {
+	EVAL_LANGUAGE_INFERRED_KEY,
+	type EvalLanguageInferenceBasis,
+	inferEvalLanguage,
+	isEvalLanguageInferenceBasis,
+	wasEvalLanguageFilled,
+} from "./eval-language-inference.ts";
 
 const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
 
@@ -40,9 +47,17 @@ export function parseEvalRequest(
 	}
 	if (params.action !== undefined && params.action !== "run")
 		throw new TypeError(`Unknown eval action "${String(params.action)}"`);
-	if (params.language === undefined) throw new TypeError(evalRunFieldRequiredMessage("language", enabledLanguages));
-	if (!isEvalLanguage(params.language))
+	// An omitted language is filled only when unambiguous (senpi#5154); argument validation may already have filled it.
+	const inference = params.language === undefined ? inferEvalLanguage(params.code, enabledLanguages) : undefined;
+	const language: unknown = inference?.language ?? params.language;
+	if (language === undefined) throw new TypeError(evalRunFieldRequiredMessage("language", enabledLanguages));
+	if (!isEvalLanguage(language))
 		throw new TypeError(`eval run language must be one of: ${enabledLanguages.join(", ")}`);
+	const inferredBy: EvalLanguageInferenceBasis | undefined =
+		inference?.basis ??
+		(wasEvalLanguageFilled(params) && isEvalLanguageInferenceBasis(params[EVAL_LANGUAGE_INFERRED_KEY])
+			? params[EVAL_LANGUAGE_INFERRED_KEY]
+			: undefined);
 	if (typeof params.code !== "string") throw new TypeError(evalRunFieldRequiredMessage("code", enabledLanguages));
 	const summary = normalizeEvalSummary(params.summary);
 	if (summary === undefined) throw new TypeError(evalRunFieldRequiredMessage("summary", enabledLanguages));
@@ -53,12 +68,11 @@ export function parseEvalRequest(
 		if (options.sandbox !== true) {
 			throw new EvalIsolateInvalidError("sandbox cells are turned off (set sandbox.enabled in codemode settings)");
 		}
-		if (params.language !== "js")
-			throw new EvalIsolateInvalidError('sandbox cells run JavaScript only (language: "js")');
+		if (language !== "js") throw new EvalIsolateInvalidError('sandbox cells run JavaScript only (language: "js")');
 		if (params.reset === true) throw new EvalIsolateInvalidError("a sandbox cell starts fresh; reset does not apply");
 	}
 	return {
-		language: params.language,
+		language,
 		code: params.code,
 		summary,
 		...(params.action === "run" ? { action: "run" as const } : {}),
@@ -66,6 +80,7 @@ export function parseEvalRequest(
 		...(params.on_timeout === "detach" || params.on_timeout === "error" ? { on_timeout: params.on_timeout } : {}),
 		...(typeof params.reset === "boolean" ? { reset: params.reset } : {}),
 		...(params.isolate === true ? { isolate: true } : {}),
+		...(inferredBy === undefined ? {} : { language_inferred: inferredBy }),
 	};
 }
 

package/src/tool/eval-tool.ts

@@ -9,6 +9,7 @@ import {
 import { buildEvalPrompt } from "../prompt/eval-prompt.ts";
 import { EvalDetachedCellManager } from "./detached-cell-manager.ts";
 import { registerEvalArgumentValidator } from "./eval-argument-validator.ts";
+import { evalLanguageInferredNote } from "./eval-language-inference.ts";
 import { executeEvalControl } from "./detached-eval-result.ts";
 import {
 	EvalIsolateInvalidError,
@@ -38,6 +39,7 @@ export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./type
 type EvalExecuteArgs<Request extends EvalToolRequest> = Parameters<
 	ToolDefinition<TUnsafe<Request | Partial<EvalToolInput>>, EvalToolDetails>["execute"]
 >;
+type RunArgs = EvalExecuteArgs<EvalToolInput>;
 
 export function createEvalTool(options: CreateEvalToolOptions) {
 	const foregroundWindowSeconds = options.foregroundWindowSeconds ?? DEFAULT_FOREGROUND_WINDOW_SECONDS;
@@ -87,6 +89,19 @@ export function createEvalTool(options: CreateEvalToolOptions) {
 	): Promise<AgentToolResult<EvalResultDetails>> {
 		const request = parseEvalRequest(params, languages, { sandbox });
 		if (isEvalControlRequest(request)) return await executeEvalControl(cellManager, request);
+		const output = await executeRun(request, toolCallId, signal, onUpdate, ctx);
+		if (request.language_inferred === undefined) return output;
+		// The model sees that its omitted language was filled, and how, so it passes language next time (senpi#5154).
+		const note = evalLanguageInferredNote(request.language, request.language_inferred);
+		return { ...output, content: [{ type: "text", text: note }, ...output.content] };
+	}
+	async function executeRun(
+		request: EvalToolInput,
+		toolCallId: RunArgs[0],
+		signal: RunArgs[2],
+		onUpdate: RunArgs[3],
+		ctx: RunArgs[4],
+	): Promise<AgentToolResult<EvalResultDetails>> {
 		if (options.proxyExecutor) {
 			// A proxy runs cells elsewhere and knows nothing of sandbox cells: an isolated cell must never run unisolated.
 			if ("isolate" in request && request.isolate === true)

package/src/tool/types.ts

@@ -59,6 +59,8 @@ export interface EvalToolInput {
 	readonly reset?: boolean;
 	/** Run in a fresh sandbox VM instead of the persistent kernel; accepted only while `sandbox.enabled` is on. */
 	readonly isolate?: boolean;
+	/** Set when the call omitted language and it was filled (senpi#5154); the result then says so. */
+	readonly language_inferred?: "only-enabled-language" | "code-markers";
 }
 
 export interface EvalListInput {