@oh-my-pi/pi-coding-agent 14.9.2 → 14.9.5

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

@@ -32,9 +32,6 @@ interface VmHelperOptions {
 	reverse?: boolean;
 	unique?: boolean;
 	count?: boolean;
-	cwd?: string;
-	timeoutMs?: number;
-	timeout?: number;
 }
 
 interface VmContextState {
@@ -303,41 +300,6 @@ async function createHelpers(state: VmContextState) {
 			emitStatus(state, { op: "tree", path: root, entries: entryCount, preview: result.slice(0, 1000) });
 			return result;
 		},
-		run: async (
-			command: string,
-			options: VmHelperOptions = {},
-		): Promise<{ stdout: string; stderr: string; exit_code: number }> => {
-			const cwd = options.cwd ? resolvePath(state, options.cwd) : state.cwd;
-			const timeoutMs =
-				typeof options.timeoutMs === "number"
-					? options.timeoutMs
-					: typeof options.timeout === "number"
-						? options.timeout * 1000
-						: undefined;
-			const timeoutSignal =
-				typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0
-					? AbortSignal.timeout(timeoutMs)
-					: undefined;
-			const signal =
-				state.currentRun?.signal && timeoutSignal
-					? AbortSignal.any([state.currentRun.signal, timeoutSignal])
-					: (state.currentRun?.signal ?? timeoutSignal);
-			const child = Bun.spawn(["bash", "-lc", command], {
-				cwd,
-				env: getMergedEnv(state),
-				stdout: "pipe",
-				stderr: "pipe",
-				signal,
-			});
-			const [stdout, stderr, exit_code] = await Promise.all([
-				new Response(child.stdout as ReadableStream<Uint8Array>).text(),
-				new Response(child.stderr as ReadableStream<Uint8Array>).text(),
-				child.exited,
-			]);
-			const output = `${stdout}${stderr}`.slice(0, 500);
-			emitStatus(state, { op: "run", cmd: command.slice(0, 120), code: exit_code, output });
-			return { stdout, stderr, exit_code };
-		},
 		env: (key?: string, value?: string): string | Record<string, string> | undefined => {
 			if (!key) {
 				const env = Object.fromEntries(Object.entries(getMergedEnv(state)).sort(([a], [b]) => a.localeCompare(b)));
@@ -419,6 +381,7 @@ async function createVmState(
 		atob,
 		btoa,
 		Buffer,
+		Bun,
 		process: createProcessSubset(cwd),
 		require: buildRequire(cwd),
 		createRequire,

package/src/eval/js/prelude.txt

@@ -12,7 +12,6 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	const counter = (items, opts = {}) => callHelper("counter", items, toOptions(opts));
 	const diff = (a, b) => callHelper("diff", a, b);
 	const tree = (path = ".", opts = {}) => callHelper("tree", path, toOptions(opts));
-	const run = (cmd, opts = {}) => callHelper("run", cmd, toOptions(opts));
 	const env = (key, value) => callHelper("env", key, value);
 
 	const tool = new Proxy(
@@ -67,6 +66,5 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	globalThis.counter = counter;
 	globalThis.diff = diff;
 	globalThis.tree = tree;
-	globalThis.run = run;
 	globalThis.env = env;
 }

package/src/eval/parse.ts

@@ -1,3 +1,4 @@
+import { sniffEvalLanguage } from "./sniff";
 import type { EvalLanguage } from "./types";
 
 export type EvalLanguageOrigin = "default" | "header";
@@ -14,324 +15,224 @@ export interface ParsedEvalCell {
 
 export interface ParsedEvalInput {
 	cells: ParsedEvalCell[];
+	/**
+	 * True when the parser encountered `*** Abort` (recovery sentinel emitted
+	 * by the agent loop's harmony-leak mitigation; see
+	 * `docs/ERRATA-GPT5-HARMONY.md`). The cell containing the marker, if any,
+	 * is dropped — its body is incomplete and unsafe to execute.
+	 */
+	aborted?: boolean;
 }
 
 const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_LANGUAGE: EvalLanguage = "python";
 
 /**
- * Canonical language tokens we map onto our two backends. Matched
- * case-insensitively. Unknown tokens are treated as title fragments rather
- * than languages; this is intentional fallback behaviour and MUST NOT be
- * advertised in the tool's prompt — the lark grammar describes the
- * canonical surface we encourage callers to emit.
+ * Canonical language tokens plus common long-form aliases. The grammar
+ * advertises only `PY` / `JS` / `TS`, but unconstrained models reach for
+ * `Python` / `JavaScript` / `TypeScript` often enough that we accept them.
  */
-const LANGUAGE_ALIASES: Record<string, EvalLanguage> = {
-	py: "python",
-	python: "python",
-	ipy: "python",
-	ipython: "python",
-	js: "js",
-	javascript: "js",
-	ts: "js",
-	typescript: "js",
+const LANGUAGE_MAP: Record<string, EvalLanguage> = {
+	PY: "python",
+	PYTHON: "python",
+	IPY: "python",
+	IPYTHON: "python",
+	JS: "js",
+	JAVASCRIPT: "js",
+	TS: "js",
+	TYPESCRIPT: "js",
 };
 
-function resolveLanguageAlias(token: string): EvalLanguage | undefined {
-	return LANGUAGE_ALIASES[token.toLowerCase()];
-}
+// Markers are case-insensitive, accept ≥2 leading stars (so `**Begin` and
+// `*** Begin` both work), and tolerate any whitespace (including tabs)
+// between tokens. Models that can't constrain-sample frequently emit minor
+// variations like `**End`, `*** end py`, or `***\tTitle: foo`.
+const STARS = String.raw`\*{2,}`;
+const BEGIN_RE = new RegExp(`^${STARS}\\s*Begin\\b\\s*(\\S+)?\\s*$`, "i");
+const END_RE = new RegExp(`^${STARS}\\s*End\\b.*$`, "i");
+const TITLE_RE = new RegExp(`^${STARS}\\s*Title\\s*:\\s*(.+?)\\s*$`, "i");
+const TIMEOUT_RE = new RegExp(`^${STARS}\\s*Timeout\\s*:\\s*(\\S+)\\s*$`, "i");
+const RESET_RE = new RegExp(`^${STARS}\\s*Reset\\s*$`, "i");
+const ABORT_RE = new RegExp(`^${STARS}\\s*Abort\\s*$`, "i");
 
 /**
- * Map an attribute key (from `key:value` or bare `key` in a header) to one
- * of the three canonical roles. Canonical keys: `id`, `t`, `rst`. Fallback
- * aliases — accepted but not advertised in the prompt — cover common
- * synonyms the LLM is likely to reach for instead of the short canonical.
+ * Warning text appended to the eval tool result when parsing terminated on
+ * `*** Abort`. Tells the model that earlier cells (if any) ran normally and
+ * that any aborted cell needs to be re-issued.
  */
-const ID_KEYS = new Set(["id", "title", "name", "cell", "file", "label"]);
-const T_KEYS = new Set(["t", "timeout", "duration", "time"]);
-const RST_KEYS = new Set(["rst", "reset"]);
+export const ABORT_WARNING =
+	"Tool stream truncated mid-call due to detected output corruption. Earlier cells (if any) executed normally; their state persists. Re-issue the aborted cell.";
+const DURATION_RE = /^(\d+)(ms|s|m)?$/i;
 
-function classifyAttrKey(key: string): "id" | "t" | "rst" | null {
-	if (ID_KEYS.has(key)) return "id";
-	if (T_KEYS.has(key)) return "t";
-	if (RST_KEYS.has(key)) return "rst";
-	return null;
+function resolveLang(token: string | undefined): EvalLanguage | undefined {
+	return token ? LANGUAGE_MAP[token.toUpperCase()] : undefined;
 }
 
-interface HeaderInfo {
-	language?: EvalLanguage;
-	title?: string;
-	timeoutMs?: number;
-	reset?: boolean;
-}
-
-/**
- * Match a header line: `={5,} <info>? ={5,}`. Both bars MUST be on the
- * same line and each MUST be at least five equal signs (lengths need not
- * match — a 5/6 split is fine).
- */
-const HEADER_RE = /^={5,}([^=].*?)?={5,}\s*$/;
-const EMPTY_HEADER_RE = /^={5,}\s*$/;
-
-const ATTR_TOKEN_RE = /^([a-zA-Z][\w-]*)(?::(?:"([^"]*)"|'([^']*)'|(.*)))?$/;
-const DURATION_TOKEN_RE = /^\d+(?:ms|s|m)?$/;
-
 function parseDurationMs(raw: string, lineNumber: number): number {
-	const match = /^(\d+)(ms|s|m)?$/.exec(raw.trim());
+	const match = DURATION_RE.exec(raw.trim());
 	if (!match) {
 		throw new Error(
 			`Eval line ${lineNumber}: invalid duration \`${raw}\`; use a number with optional ms, s, or m units.`,
 		);
 	}
 	const value = Number.parseInt(match[1], 10);
-	const unit = match[2] ?? "s";
+	const unit = (match[2] ?? "s").toLowerCase();
 	if (unit === "ms") return value;
 	if (unit === "s") return value * 1000;
 	return value * 60_000;
 }
 
-function parseBoolean(value: string): boolean | undefined {
-	const normalized = value.trim().toLowerCase();
-	if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") return true;
-	if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") return false;
-	return undefined;
-}
-
-function trimOuterBlankLines(lines: string[]): string[] {
-	let start = 0;
-	let end = lines.length;
-	while (start < end && lines[start].trim() === "") start++;
-	while (end > start && lines[end - 1].trim() === "") end--;
-	return lines.slice(start, end);
-}
+// Markdown fence wrapping a single bare cell, e.g. "```py\n...\n```" or
+// "```\n...\n```". Used by models that wrap eval input in code fences.
+const FENCE_OPEN_RE = /^```\s*([A-Za-z]\w*)?\s*$/;
+const FENCE_CLOSE_RE = /^```\s*$/;
 
 /**
- * Detect whether a line is a cell header. Returns the info string between
- * the two bar runs (trimmed) when it is, or `null` otherwise. An empty
- * header (`===== =====` or just `=====`) yields an empty info string.
- *
- * A line that contains text but only one bar (e.g. `===== title`) is NOT
- * a header — it's normal code that happens to start with equal signs.
+ * Last-resort fallback when the input has no recognizable `*** Begin` header.
+ * Models that can't constrain-sample sometimes pass bare code or wrap it in
+ * a markdown fence (```py / ```python / bare ```). Treat the whole input as
+ * a single implicit cell, sniffing the language from the body.
  */
-function parseHeaderLine(line: string): string | null {
-	if (EMPTY_HEADER_RE.test(line)) return "";
-	const match = HEADER_RE.exec(line);
-	if (!match) return null;
-	return (match[1] ?? "").trim();
-}
-
-/**
- * Tokenize a header info string while preserving content inside matching
- * single or double quotes as a single token. The opening and closing
- * quote characters are kept verbatim so attribute parsing can strip them
- * later.
- */
-function tokenizeInfoString(info: string): string[] {
-	const tokens: string[] = [];
-	let i = 0;
-	while (i < info.length) {
-		while (i < info.length && /\s/.test(info[i])) i++;
-		if (i >= info.length) break;
-		let token = "";
-		while (i < info.length && !/\s/.test(info[i])) {
-			const ch = info[i];
-			if (ch === '"' || ch === "'") {
-				token += ch;
-				i++;
-				while (i < info.length && info[i] !== ch) {
-					token += info[i];
-					i++;
-				}
-				if (i < info.length) {
-					token += info[i];
-					i++;
-				}
-			} else {
-				token += ch;
-				i++;
-			}
+function parseImplicitCell(lines: string[]): ParsedEvalCell {
+	let body = lines.slice();
+	while (body.length > 0 && body[0].trim() === "") body.shift();
+	while (body.length > 0 && body[body.length - 1].trim() === "") body.pop();
+
+	let fenceLang: string | undefined;
+	if (body.length >= 2) {
+		const open = FENCE_OPEN_RE.exec(body[0]);
+		const closeIdx = body.length - 1;
+		if (open && FENCE_CLOSE_RE.test(body[closeIdx])) {
+			fenceLang = open[1];
+			body = body.slice(1, closeIdx);
 		}
-		tokens.push(token);
 	}
-	return tokens;
-}
-
-/**
- * Decode a header info string into language, title, timeout, and reset flag.
- *
- * Token forms (all optional, any order):
- *   - `py` / `js` / `ts`              bare language
- *   - `py:"..."` / `js:"..."` / `ts:"..."`  language + title shorthand
- *   - `id:"..."`                      cell title
- *   - `t:<duration>`                  per-cell timeout
- *   - `<duration>`                    bare positional duration (lenient)
- *   - `rst`                           reset flag
- *   - `rst:true|false`                reset flag with explicit value
- *
- * Fallback aliases (accepted but not advertised in the prompt):
- *   - id:  title, name, cell, file, label
- *   - t:   timeout, duration, time
- *   - rst: reset
- *
- * Truly unknown keys are silently dropped. First occurrence wins when a
- * key is repeated (canonical or alias). Anything that doesn't classify
- * accumulates as a positional title fragment joined by spaces.
- */
-function parseHeaderInfo(info: string, lineNumber: number): HeaderInfo {
-	const tokens = tokenizeInfoString(info);
-	if (tokens.length === 0) return {};
-
-	let language: EvalLanguage | undefined;
-	let titleAttr: string | undefined;
-	let positionalDurationMs: number | undefined;
-	let tAttr: string | undefined;
-	let rstAttr: string | undefined;
-	let bareReset = false;
-	const titleParts: string[] = [];
-
-	for (const token of tokens) {
-		// Bare reset flag.
-		if (RST_KEYS.has(token.toLowerCase())) {
-			bareReset = true;
-			continue;
-		}
-
-		const attrMatch = ATTR_TOKEN_RE.exec(token);
-		if (attrMatch && token.includes(":")) {
-			const key = attrMatch[1].toLowerCase();
-			const value = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
 
-			// Language-with-title shorthand: `py:"foo"` etc.
-			const langCandidate = resolveLanguageAlias(key);
-			if (langCandidate) {
-				if (language === undefined) language = langCandidate;
-				if (titleAttr === undefined && value !== "") titleAttr = value;
-				continue;
-			}
-
-			const role = classifyAttrKey(key);
-			if (role === "id" && titleAttr === undefined) titleAttr = value;
-			else if (role === "t" && tAttr === undefined) tAttr = value;
-			else if (role === "rst" && rstAttr === undefined) rstAttr = value;
-			// unknown / repeated keys silently dropped
-			continue;
-		}
-
-		// Bare language token (no colon).
-		const lang = resolveLanguageAlias(token);
-		if (lang && language === undefined) {
-			language = lang;
-			continue;
-		}
-
-		// Bare positional duration (lenient — `t:` is canonical).
-		if (positionalDurationMs === undefined && DURATION_TOKEN_RE.test(token)) {
-			positionalDurationMs = parseDurationMs(token, lineNumber);
-			continue;
-		}
-
-		titleParts.push(token);
-	}
-
-	const explicitTitle = (titleAttr ?? "").trim();
-	const positionalTitle = titleParts.join(" ").trim();
-	const title = explicitTitle.length > 0 ? explicitTitle : positionalTitle.length > 0 ? positionalTitle : undefined;
-
-	let timeoutMs: number | undefined;
-	if (tAttr !== undefined) {
-		timeoutMs = parseDurationMs(tAttr, lineNumber);
-	} else if (positionalDurationMs !== undefined) {
-		timeoutMs = positionalDurationMs;
-	}
-
-	let reset: boolean | undefined;
-	if (rstAttr !== undefined) {
-		const parsed = parseBoolean(rstAttr);
-		if (parsed === undefined) {
-			throw new Error(`Eval line ${lineNumber}: invalid rst value \`${rstAttr}\`; use true or false.`);
-		}
-		reset = parsed;
-	} else if (bareReset) {
-		reset = true;
-	}
-
-	return { language, title, timeoutMs, reset };
-}
-
-interface ExpansionState {
-	language: EvalLanguage;
-	languageOrigin: EvalLanguageOrigin;
+	const code = body.join("\n");
+	const explicitLanguage = resolveLang(fenceLang);
+	const language = explicitLanguage ?? sniffEvalLanguage(code) ?? DEFAULT_LANGUAGE;
+	return {
+		index: 0,
+		title: undefined,
+		code,
+		language,
+		languageOrigin: explicitLanguage ? "header" : "default",
+		timeoutMs: DEFAULT_TIMEOUT_MS,
+		reset: false,
+	};
 }
 
 export function parseEvalInput(input: string): ParsedEvalInput {
 	const normalized = input.replace(/\r\n?/g, "\n");
 	const lines = normalized.split("\n");
-	// `split("\n")` produces a trailing empty element when the input ends with
-	// a newline. Drop it so we don't emit phantom blank trailing code lines.
 	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
 
-	const state: ExpansionState = { language: "python", languageOrigin: "default" };
 	const cells: ParsedEvalCell[] = [];
+	let aborted = false;
 	let i = 0;
 
-	// Lenient: leading content before any header forms an implicit
-	// default-language cell. Drop it if it's only blank lines.
-	if (i < lines.length && parseHeaderLine(lines[i]) === null) {
-		const buffer: string[] = [];
-		while (i < lines.length && parseHeaderLine(lines[i]) === null) {
-			buffer.push(lines[i]);
-			i++;
-		}
-		const trimmed = trimOuterBlankLines(buffer);
-		if (trimmed.length > 0) {
-			cells.push({
-				index: cells.length,
-				title: undefined,
-				code: trimmed.join("\n"),
-				language: state.language,
-				languageOrigin: state.languageOrigin,
-				timeoutMs: DEFAULT_TIMEOUT_MS,
-				reset: false,
-			});
+	// Skip leading blank lines.
+	while (i < lines.length && lines[i].trim() === "") i++;
+
+	// Lenient fallback: if the input has no recognizable begin marker, treat
+	// the entire input as one implicit cell — unless that content contains
+	// `*** Abort`, in which case the body is incomplete/unsafe and we drop it.
+	if (i < lines.length && !BEGIN_RE.test(lines[i])) {
+		const tail = lines.slice(i);
+		if (tail.some(line => ABORT_RE.test(line))) {
+			return { cells, aborted: true };
 		}
+		const cell = parseImplicitCell(tail);
+		if (cell.code.length > 0) cells.push(cell);
+		return { cells };
 	}
 
 	while (i < lines.length) {
-		const headerInfo = parseHeaderLine(lines[i]);
-		if (headerInfo === null) {
-			// Loop invariant guarantees this is a header line; guard anyway.
-			i++;
-			continue;
+		const beginMatch = BEGIN_RE.exec(lines[i])!;
+		const langToken = beginMatch[1];
+		const explicitLanguage = resolveLang(langToken);
+		i++;
+
+		let title: string | undefined;
+		let timeoutMs: number | undefined;
+		let reset = false;
+
+		while (i < lines.length) {
+			const line = lines[i];
+			const lineNumber = i + 1;
+			const titleMatch = TITLE_RE.exec(line);
+			if (titleMatch) {
+				if (title === undefined) title = titleMatch[1];
+				i++;
+				continue;
+			}
+			const timeoutMatch = TIMEOUT_RE.exec(line);
+			if (timeoutMatch) {
+				if (timeoutMs === undefined) timeoutMs = parseDurationMs(timeoutMatch[1], lineNumber);
+				i++;
+				continue;
+			}
+			if (RESET_RE.test(line)) {
+				reset = true;
+				i++;
+				continue;
+			}
+			break;
 		}
-		const headerLineNumber = i + 1;
-		const info = parseHeaderInfo(headerInfo, headerLineNumber);
-		i++; // consume header line
 
+		// Collect cell body. Close on `*** End` OR on the next `*** Begin`
+		// (implicit end — leniency for models that drop end markers between
+		// back-to-back cells). `*** Abort` (recovery sentinel) drops the
+		// in-progress cell entirely: its body is partial and unsafe to run.
 		const codeLines: string[] = [];
-		while (i < lines.length && parseHeaderLine(lines[i]) === null) {
-			codeLines.push(lines[i]);
+		let cellAborted = false;
+		while (i < lines.length) {
+			const line = lines[i];
+			if (ABORT_RE.test(line)) {
+				cellAborted = true;
+				aborted = true;
+				i++;
+				break;
+			}
+			if (END_RE.test(line)) {
+				i++;
+				break;
+			}
+			if (BEGIN_RE.test(line)) break;
+			codeLines.push(line);
 			i++;
 		}
+
+		if (cellAborted) break;
+
 		// Strip trailing blank lines so visual spacing between cells doesn't
 		// leak into the preceding cell's code.
 		while (codeLines.length > 0 && codeLines[codeLines.length - 1].trim() === "") {
 			codeLines.pop();
 		}
+		const code = codeLines.join("\n");
 
-		const language = info.language ?? state.language;
-		const languageOrigin: EvalLanguageOrigin = info.language ? "header" : state.languageOrigin;
+		const language = explicitLanguage ?? sniffEvalLanguage(code) ?? DEFAULT_LANGUAGE;
+		const languageOrigin: EvalLanguageOrigin = explicitLanguage ? "header" : "default";
 
 		cells.push({
 			index: cells.length,
-			title: info.title,
-			code: codeLines.join("\n"),
+			title,
+			code,
 			language,
 			languageOrigin,
-			timeoutMs: info.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-			reset: info.reset ?? false,
+			timeoutMs: timeoutMs ?? DEFAULT_TIMEOUT_MS,
+			reset,
 		});
-		state.language = language;
-		state.languageOrigin = languageOrigin;
+
+		// Skip blank separator lines between cells; an `*** Abort` here
+		// terminates parsing while keeping previously-collected cells.
+		while (i < lines.length && lines[i].trim() === "") i++;
+		if (i < lines.length && ABORT_RE.test(lines[i])) {
+			aborted = true;
+			break;
+		}
 	}
 
-	return { cells };
+	return aborted ? { cells, aborted: true } : { cells };
 }

package/src/eval/py/executor.ts

@@ -39,6 +39,13 @@ export interface PythonExecutorOptions {
 	useSharedGateway?: boolean;
 	/** Session file path for accessing task outputs */
 	sessionFile?: string;
+	/**
+	 * Effective artifacts directory for the current session. Subagents share
+	 * the parent's directory, so this can differ from `sessionFile`'s sibling
+	 * dir. When present, exported to the kernel as `PI_ARTIFACTS_DIR` and
+	 * preferred over `PI_SESSION_FILE`-derived paths.
+	 */
+	artifactsDir?: string;
 	/** Artifact path/id for full output storage */
 	artifactPath?: string;
 	artifactId?: string;
@@ -102,6 +109,7 @@ let cleanupTimer: NodeJS.Timeout | null = null;
 interface KernelSessionExecutionOptions {
 	useSharedGateway?: boolean;
 	sessionFile?: string;
+	artifactsDir?: string;
 	signal?: AbortSignal;
 	deadlineMs?: number;
 	kernelOwnerId?: string;
@@ -123,6 +131,19 @@ function getExecutionDeadlineMs(options?: Pick<PythonExecutorOptions, "deadlineM
 	return Date.now() + options.timeoutMs;
 }
 
+/**
+ * Build the env block exposed to the Python kernel. Includes the session file
+ * (for things that need the raw session path) and the effective artifacts
+ * directory (preferred by the prelude when resolving output IDs, so subagents
+ * see the parent's flat dir instead of a non-existent sibling).
+ */
+function buildKernelEnv(options: { sessionFile?: string; artifactsDir?: string }): Record<string, string> | undefined {
+	const env: Record<string, string> = {};
+	if (options.sessionFile) env.PI_SESSION_FILE = options.sessionFile;
+	if (options.artifactsDir) env.PI_ARTIFACTS_DIR = options.artifactsDir;
+	return Object.keys(env).length > 0 ? env : undefined;
+}
+
 function getRemainingTimeoutMs(deadlineMs?: number): number | undefined {
 	if (deadlineMs === undefined) return undefined;
 	return deadlineMs - Date.now();
@@ -523,9 +544,7 @@ async function createKernelSession(
 	isRetry?: boolean,
 ): Promise<KernelSession> {
 	requireRemainingTimeoutMs(options.deadlineMs);
-	const env: Record<string, string> | undefined = options.sessionFile
-		? { PI_SESSION_FILE: options.sessionFile }
-		: undefined;
+	const env = buildKernelEnv(options);
 	const startOptions = buildKernelStartOptions(cwd, env, options);
 
 	let kernel: PythonKernel;
@@ -586,9 +605,7 @@ async function restartKernelSession(
 				});
 			}
 		}
-		const env: Record<string, string> | undefined = options.sessionFile
-			? { PI_SESSION_FILE: options.sessionFile }
-			: undefined;
+		const env = buildKernelEnv(options);
 		const startOptions = buildKernelStartOptions(cwd, env, options);
 		const kernel = await PythonKernel.start(startOptions);
 		session.kernel = kernel;
@@ -936,10 +953,9 @@ export async function executePython(code: string, options?: PythonExecutorOption
 		await ensureKernelAvailable(cwd);
 
 		const kernelMode = executionOptions.kernelMode ?? "session";
-		const sessionFile = executionOptions.sessionFile;
 
 		if (kernelMode === "per-call") {
-			const env: Record<string, string> | undefined = sessionFile ? { PI_SESSION_FILE: sessionFile } : undefined;
+			const env = buildKernelEnv(executionOptions);
 			requireRemainingTimeoutMs(deadlineMs);
 			const startOptions = buildKernelStartOptions(cwd, env, executionOptions);
 			const kernel = await PythonKernel.start(startOptions);

package/src/eval/py/index.ts

@@ -35,6 +35,7 @@ export default {
 			kernelMode,
 			useSharedGateway,
 			sessionFile: opts.sessionFile,
+			artifactsDir: opts.session.getArtifactsDir?.() ?? undefined,
 			kernelOwnerId: opts.kernelOwnerId,
 			reset: opts.reset,
 			artifactPath: opts.artifactPath,