@code-yeongyu/senpi-codemode 2026.9.7 → 2026.9.9-2

package/CHANGELOG.md

@@ -12,6 +12,61 @@
 
 ### Removed
 
+## [2026.9.9-2] - 2026-09-09
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.9] - 2026-09-09
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.8] - 2026-09-08
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- The eval tool description teaches cell mechanics only (batch independent calls, real code, failures kept verbatim, truncated output re-read) and drops the "default execution surface / never a chain / distilled facts only" wording; routing lives in the model's prompt preset.
+
+### Fixed
+
+### Removed
+
+## [2026.9.7-2] - 2026-09-07
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- The JS kernel's shell capture now pins the worker's environment view for `Bun.spawnSync` as well as `Bun.spawn`, so a cell calling it without an explicit `env` sees the session's `PI_*` values instead of the inherited OS environ.
+- Eval kernels and every child they spawn now see the active session's `PI_*` environment (`PI_SESSION_ID`, `PI_SESSION_FILE`, `PI_PROVIDER`, `PI_MODEL`, `PI_REASONING_LEVEL`) exactly as bash-tool children do: inherited `PI_*` values are dropped before the session values are applied, so subprocesses such as `omo-agent-toolkit ulw-loop` resolve the same session as the `bash` tool instead of a cwd-global one.
+- JavaScript eval cells no longer lose their completion value when a nested function, callback, or try/catch helper contains `return`: the cell wrapper now skips last-expression capture only for a genuine top-level `return`, and a property named `return` no longer primes the statement scanner as the keyword (#1439).
+- Eval output truncation notices now name the real cause: a width-clamped line reports `N line(s) clamped to M columns (… dropped)`, a byte-capped tail reports the actual cap, and a notice never presents the output's own size as a limit.
+
+### Removed
+
 ## [2026.9.7] - 2026-09-07
 
 ### Breaking Changes

package/README.md

@@ -54,6 +54,19 @@ task-tool names are known.
 A missing optional interpreter removes that language from the session's `eval`
 schema; it is not an installation failure.
 
+### Session environment
+
+Every kernel starts with the active session's `PI_*` environment — `PI_SESSION_ID`,
+`PI_SESSION_FILE` (when the session is persistent), `PI_PROVIDER`, `PI_MODEL`, and
+`PI_REASONING_LEVEL` (when set) — resolved at session start, mirroring the bash tool's
+session environment contract. The values are visible to `env()`/`process.env`/`os.environ`
+inside cells and are inherited by every child process a cell spawns
+(`Bun.$`, `Bun.spawn`, `child_process`, `subprocess`, ...). Inherited `PI_*` values from
+the launching environment are dropped first, so a child spawned from a cell sees exactly
+what a child spawned from the bash tool sees. The values snapshot at kernel start, so a
+mid-session model switch updates the bash tool's next command but not already-running
+kernels; a new session starts fresh kernels with fresh values.
+
 ## Settings
 
 Configuration is loaded in this order:
@@ -116,7 +129,7 @@ options object and asynchronous helpers are `await`-able.
 | `print(value, ...)` | Emits text output. |
 | `read(path, offset?, limit?)` | Reads text with 1-indexed line slicing. `local://` paths resolve under the session artifact root. |
 | `write(path, content)` | Creates parent directories and writes text. `local://` paths persist in the session artifact root. |
-| `env(key?, value?)` | Reads all kernel environment values, one value, or sets one value. |
+| `env(key?, value?)` | Reads all kernel environment values, one value, or sets one value. Includes the session's `PI_*` values (see [Session environment](#session-environment)). |
 | `tool.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline and returns `{ text, images?, details?, hasError? }` in every kernel; image blocks arrive as `images[i] = { mimeType, dataBase64 }`. |
 | `tool_schema(name?)` | Returns a tool's parameter schema without calling it; omit `name` to list tool names. |
 | `completion(prompt, model?, system?, schema?)` | Requests a one-shot host completion; `schema` asks the host to parse structured output. |

package/package.json

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

package/src/bridge/protocol.ts

@@ -26,6 +26,7 @@ const hostToKernelMessageSchema = Type.Union([
 		type: Type.Literal("init"),
 		sessionId: Type.String({ minLength: 1 }),
 		connection: connectionConfigSchema,
+		sessionEnv: Type.Optional(Type.Record(Type.String(), Type.String())),
 	}),
 	Type.Object({
 		type: Type.Literal("run"),

package/src/extension/runtime-factory.ts

@@ -13,6 +13,7 @@ import {
 	getInterpreterAvailability,
 	type InterpreterAvailability,
 } from "../interpreters/detect.ts";
+import { sessionEnvironmentFrom } from "../kernels/session-env.ts";
 import { resolveSessionArtifactsDir } from "../output/streaming-output.ts";
 import type { EnabledEvalLanguages, EvalLanguage, EvalRuntimes } from "../tool/types.ts";
 import { jsRuntimeInfo, runtimesFromAvailability } from "./runtime-info.ts";
@@ -66,11 +67,13 @@ export async function createRuntime(
 	const executeTool = createExecuteTool(pi, activeTools);
 	const create = options.createSessionManager ?? createCodemodeSessionManager;
 	const sessionId = sessionIdFrom(event);
+	const sessionEnv = sessionEnvironmentFrom(ctx);
 	const configuredPoolWidth = settings.parallelPoolWidth;
 	const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
 	const manager = await create({
 		sessionId,
 		cwd: ctx.cwd,
+		sessionEnv,
 		settings,
 		availability,
 		artifactsDir: artifacts.dir,

package/src/extension/session-manager.ts

@@ -11,6 +11,7 @@ import { JuliaKernel } from "../kernels/jl/kernel.ts";
 import { JavaScriptKernel } from "../kernels/js/context-manager.ts";
 import { PythonKernel } from "../kernels/py/kernel.ts";
 import { RubyKernel } from "../kernels/rb/kernel.ts";
+import type { SessionEnvironment } from "../kernels/session-env.ts";
 import { marshalToolResult } from "../tool/image.ts";
 import type { EvalKernel, EvalKernelManager, EvalLanguage, ExecuteTool } from "../tool/types.ts";
 
@@ -40,6 +41,8 @@ export interface CreateCodemodeSessionManagerOptions {
 	readonly localRoots?: Readonly<Record<string, string>>;
 	/** Session-adjacent directory used for persisted eval artifacts. */
 	readonly artifactsDir?: string;
+	/** Per-session PI_* values exposed to every kernel and the children it spawns. */
+	readonly sessionEnv?: SessionEnvironment;
 	readonly executeTool: ExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
@@ -212,6 +215,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				cwd: this.#options.cwd,
 				parallelPoolWidth,
 				onMessage,
+				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 				...(localRoots ? { localRoots: { ...localRoots } } : {}),
 				...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
 			});
@@ -230,6 +234,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				interpreterPath: detected.path,
 				sessionId: this.#options.sessionId,
 				cwd: this.#options.cwd,
+				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 				connection,
 				onMessage,
 			});
@@ -239,6 +244,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				command: detected.path,
 				sessionId: this.#options.sessionId,
 				cwd: this.#options.cwd,
+				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 				connection,
 				onMessage,
 			});
@@ -247,6 +253,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 			command: detected.path,
 			sessionId: this.#options.sessionId,
 			cwd: this.#options.cwd,
+			...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 			connection,
 			onMessage,
 		});

package/src/kernels/AGENTS.md

@@ -15,6 +15,7 @@ runner/prelude assets).
 | Ruby kernel | `rb/kernel.ts` + `rb/prelude.rb`, `rb/runner.rb` |
 | Julia kernel | `jl/kernel.ts` + `jl/prelude.jl`, `jl/runner.jl` |
 | Shared subprocess layer | `shared/subprocess-kernel.ts`, `subprocess-{contract,process,queue,run}.ts`, `runtime-asset.ts` |
+| Session environment | `session-env.ts` (PI_* contract shared by all kernels; mirrors the core bash tool) |
 
 ## CONVENTIONS
 
@@ -29,6 +30,12 @@ runner/prelude assets).
   framed subprocesses through `shared/`.
 - Subprocess retirement/restart, worker recovery, timeout, and interrupt
   semantics live here, never in the tool layer.
+- Every kernel exposes the active session's `PI_*` environment (`session-env.ts`):
+  inherited values are deleted before the session's values are applied, so any
+  child spawned from a cell sees the same session environment a bash-tool child
+  sees. The JS worker applies it at init (`worker-core.js`; shell capture pins
+  the env view under Bun because `delete process.env.X` does not unsetenv),
+  and py/rb/jl spawn with it merged into the interpreter environment.
 
 ## ANTI-PATTERNS
 

package/src/kernels/jl/kernel.ts

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { SessionEnvironment } from "../session-env.ts";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { SubprocessKernel, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
 
@@ -7,6 +8,8 @@ export interface JuliaKernelStartOptions {
 	readonly cwd: string;
 	readonly sessionId: string;
 	readonly connection: BridgeConnectionConfig;
+	/** Per-session PI_* values merged into the interpreter environment at spawn. */
+	readonly sessionEnv?: SessionEnvironment;
 	readonly command?: string;
 	readonly spawn?: SubprocessSpawn;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
@@ -42,6 +45,7 @@ export class JuliaKernel extends SubprocessKernel {
 			],
 			cwd: options.cwd,
 			sessionId: options.sessionId,
+			sessionEnv: options.sessionEnv,
 			connection: options.connection,
 			spawn: options.spawn,
 			onMessage: options.onMessage,

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

@@ -1,4 +1,5 @@
 import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { SessionEnvironment } from "../session-env.ts";
 
 export type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
 export type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
@@ -11,6 +12,8 @@ export interface JavaScriptKernelOptions {
 	readonly parallelPoolWidth: number;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly workerEntryUrl?: URL;
+	/** Per-session PI_* values applied to the worker environment before the first cell runs. */
+	readonly sessionEnv?: SessionEnvironment;
 }
 
 export interface JavaScriptRunInput {

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

@@ -3,6 +3,17 @@ import { JsWorkerRuntime } from "./worker-runtime.js";
 // Mirrors INTERRUPT_ACK_OP in src/bridge/reserved.ts (this worker file cannot import TypeScript).
 const INTERRUPT_ACK_OP = "interrupt-ack";
 
+// Mirrors SESSION_ENVIRONMENT_KEYS in src/kernels/session-env.ts (this worker file
+// cannot import TypeScript). Keys the active session does not set must be dropped so a
+// value inherited from the host environment never leaks into a cell or its children.
+const SESSION_ENVIRONMENT_KEYS = [
+	"PI_SESSION_ID",
+	"PI_SESSION_FILE",
+	"PI_PROVIDER",
+	"PI_MODEL",
+	"PI_REASONING_LEVEL",
+];
+
 export function createWorkerCore(transport, options) {
 	let runtime = null;
 	let activeCell = null;
@@ -54,6 +65,7 @@ export function createWorkerCore(transport, options) {
 
 	function onMessage(message) {
 		if (message.type === "init") {
+			applySessionEnvironment(message.sessionEnv);
 			runtime = new JsWorkerRuntime({
 				cwd: options.cwd,
 				parallelPoolWidth: options.parallelPoolWidth,
@@ -98,6 +110,23 @@ function durationMs(startedAtMs) {
 	return Math.max(0, Math.round(performance.now() - startedAtMs));
 }
 
+function applySessionEnvironment(sessionEnv) {
+	const provided = new Set(Object.keys(sessionEnv ?? {}));
+	const deleted = [];
+	for (const key of SESSION_ENVIRONMENT_KEYS) {
+		if (key in process.env && !provided.has(key)) deleted.push(key);
+		delete process.env[key];
+	}
+	const applied = Object.entries(sessionEnv ?? {});
+	for (const [key, value] of applied) process.env[key] = value;
+	// A worker's process.env is its own view: Bun.$ and node:child_process read it, but Bun.spawn
+	// without an explicit env inherits the OS environ, which also still holds deleted keys because
+	// `delete process.env.X` does not unsetenv under Bun. installShellCapture reads these flags and
+	// pins the worker's environment view for such children (see worker-shell-capture.js).
+	globalThis.__senpi_session_env_deletions__ = deleted;
+	globalThis.__senpi_session_env_applied__ = applied.length > 0 || deleted.length > 0;
+}
+
 function valueRepr(value) {
 	if (value === undefined) return undefined;
 	return JSON.stringify(value);

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

@@ -11,7 +11,7 @@ export async function awaitMaybePromise(value) {
 
 export function wrapUserCode(code) {
 	const persistentCode = persistTopLevelDeclarations(code);
-	if (/\breturn\b/u.test(persistentCode)) return `(async () => {\n${persistentCode}\n})()`;
+	if (scanTopLevelStatements(persistentCode).hasTopLevelReturn) return `(async () => {\n${persistentCode}\n})()`;
 	return `(async () => {\n${captureLastExpression(persistentCode)}\n})()`;
 }
 
@@ -705,7 +705,7 @@ function skipBlockComment(code, start) {
 }
 
 function captureLastExpression(code) {
-	const start = findLastTopLevelStatementStart(code);
+	const start = scanTopLevelStatements(code).lastStatementStart;
 	const head = code.slice(0, start);
 	const tail = code.slice(start).trim();
 	if (!tail || isStatementOnly(tail)) return code;
@@ -726,7 +726,7 @@ function isStatementOnly(source) {
 
 const CONTROL_PAREN_KEYWORDS = new Set(["catch", "for", "if", "switch", "while", "with"]);
 
-function findLastTopLevelStatementStart(code) {
+function scanTopLevelStatements(code) {
 	let start = 0;
 	let round = 0;
 	let square = 0;
@@ -734,6 +734,7 @@ function findLastTopLevelStatementStart(code) {
 	let canStartRegex = true;
 	let lastSignificant = "";
 	let pendingControlParen = false;
+	let hasTopLevelReturn = false;
 	const controlParens = [];
 	for (let index = 0; index < code.length; index += 1) {
 		const char = code[index];
@@ -763,8 +764,11 @@ function findLastTopLevelStatementStart(code) {
 		if (isIdentifierStart(char)) {
 			const end = readIdentifier(code, index);
 			const token = code.slice(index, end);
-			canStartRegex = REGEX_PREFIX_KEYWORDS.has(token);
-			pendingControlParen = CONTROL_PAREN_KEYWORDS.has(token);
+			const isPropertyName = lastSignificant === ".";
+			const atTopLevel = round === 0 && square === 0 && curly === 0;
+			if (token === "return" && atTopLevel && !isPropertyName) hasTopLevelReturn = true;
+			canStartRegex = !isPropertyName && REGEX_PREFIX_KEYWORDS.has(token);
+			pendingControlParen = !isPropertyName && CONTROL_PAREN_KEYWORDS.has(token);
 			lastSignificant = code[end - 1];
 			index = end - 1;
 			continue;
@@ -828,7 +832,7 @@ function findLastTopLevelStatementStart(code) {
 			pendingControlParen = false;
 		}
 	}
-	return start;
+	return { lastStatementStart: start, hasTopLevelReturn };
 }
 
 const STATEMENT_CONTINUATION_KEYWORDS = new Set(["catch", "else", "finally"]);

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

@@ -17,3 +17,19 @@ export interface ShellCaptureOptions {
 }
 
 export function installShellCapture(options: ShellCaptureOptions): ShellCaptureRestore;
+
+declare global {
+	/**
+	 * Set by the JS worker core when applying the session environment deleted inherited
+	 * `PI_*` keys (see worker-core.js). Under Bun a `delete process.env.X` does not
+	 * unsetenv, so shell capture pins the worker's environment view for spawned children
+	 * while this list is non-empty.
+	 */
+	var __senpi_session_env_deletions__: string[] | undefined;
+	/**
+	 * Set by the JS worker core once a session environment was applied (values set or inherited
+	 * keys deleted). Bun.spawn without an explicit env inherits the OS environ rather than the
+	 * worker's process.env, so shell capture pins the worker's view whenever this is true.
+	 */
+	var __senpi_session_env_applied__: boolean | undefined;
+}

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

@@ -13,11 +13,23 @@ export function installShellCapture(options) {
 	if (!isBunRuntime(bun)) return () => {};
 	const originalShell = bun.$;
 	const originalSpawn = bun.spawn;
+	const originalSpawnSync = typeof bun.spawnSync === "function" ? bun.spawnSync : null;
+	const deletedKeys = globalThis.__senpi_session_env_deletions__;
+	const pinEnv =
+		globalThis.__senpi_session_env_applied__ === true || (Array.isArray(deletedKeys) && deletedKeys.length > 0);
+	if (pinEnv && typeof originalShell.env === "function") {
+		// Bun.spawn without an explicit env inherits the OS environ, not the worker's process.env,
+		// and deleting from process.env does not unsetenv under Bun. Pinning the worker's
+		// environment view mirrors the bash tool, which always spawns with an explicit env.
+		originalShell.env({ ...process.env });
+	}
 	bun.$ = capturedShell(originalShell, options);
-	bun.spawn = capturedSpawn(originalSpawn, options);
+	bun.spawn = capturedSpawn(originalSpawn, options, pinEnv);
+	if (originalSpawnSync !== null) bun.spawnSync = capturedSpawnSync(originalSpawnSync, pinEnv);
 	return () => {
 		bun.$ = originalShell;
 		bun.spawn = originalSpawn;
+		if (originalSpawnSync !== null) bun.spawnSync = originalSpawnSync;
 	};
 }
 
@@ -103,20 +115,44 @@ function outputText(value) {
 	return typeof value === "string" ? value : "";
 }
 
-function capturedSpawn(originalSpawn, options) {
+// Bun.spawnSync inherits the OS environ the same way Bun.spawn does, so a cell calling it
+// without an explicit env must get the worker's view pinned too (measured on Bun 1.4.0).
+function capturedSpawnSync(originalSpawnSync, pinEnv) {
+	return (...args) => {
+		if (!pinEnv) return originalSpawnSync(...args);
+		const [first, second] = args;
+		if (Array.isArray(first)) {
+			const spawnOptions = second === undefined ? {} : second;
+			if (spawnOptions === null || typeof spawnOptions !== "object" || spawnOptions.env !== undefined)
+				return originalSpawnSync(...args);
+			return originalSpawnSync(first, { ...spawnOptions, env: { ...process.env } });
+		}
+		if (first !== null && typeof first === "object" && first.env === undefined)
+			return originalSpawnSync({ ...first, env: { ...process.env } });
+		return originalSpawnSync(...args);
+	};
+}
+
+function capturedSpawn(originalSpawn, options, pinEnv) {
 	return (...args) => {
 		if (!options.isActive()) return originalSpawn(...args);
 		const [first, second] = args;
 		let child;
 		if (Array.isArray(first)) {
 			const spawnOptions = second === undefined ? {} : second;
-			child = needsStderrCapture(spawnOptions)
-				? drainStderr(originalSpawn(first, { ...spawnOptions, stderr: "pipe" }), options.emitText)
-				: originalSpawn(...args);
+			const effective = pinEnv && spawnOptions.env === undefined ? { ...spawnOptions, env: { ...process.env } } : spawnOptions;
+			child = needsStderrCapture(effective)
+				? drainStderr(originalSpawn(first, { ...effective, stderr: "pipe" }), options.emitText)
+				: effective === spawnOptions
+					? originalSpawn(...args)
+					: originalSpawn(first, effective);
 		} else {
-			child = needsStderrCapture(first)
-				? drainStderr(originalSpawn({ ...first, stderr: "pipe" }), options.emitText)
-				: originalSpawn(...args);
+			const effective = pinEnv && first !== null && typeof first === "object" && first.env === undefined ? { ...first, env: { ...process.env } } : first;
+			child = needsStderrCapture(effective)
+				? drainStderr(originalSpawn({ ...effective, stderr: "pipe" }), options.emitText)
+				: effective === first
+					? originalSpawn(...args)
+					: originalSpawn(effective);
 		}
 		options.onChild?.(child);
 		return child;

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

@@ -64,6 +64,7 @@ async function initializeWorker(
 		type: "init",
 		sessionId: options.sessionId,
 		connection: localBridgeConnection(options),
+		...(options.sessionEnv === undefined ? {} : { sessionEnv: options.sessionEnv }),
 	});
 	await ready;
 }

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

@@ -1,4 +1,5 @@
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { SessionEnvironment } from "../session-env.ts";
 import type { KernelSpawnProcess } from "./process.ts";
 import type { PythonTransportResult } from "./transport.ts";
 
@@ -8,6 +9,8 @@ export interface PythonKernelStartOptions {
 	readonly cwd: string;
 	readonly connection: BridgeConnectionConfig;
 	readonly env?: NodeJS.ProcessEnv;
+	/** Per-session PI_* values merged into the interpreter environment at spawn. */
+	readonly sessionEnv?: SessionEnvironment;
 	readonly startupTimeoutMs?: number;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly spawnProcess?: KernelSpawnProcess;

package/src/kernels/py/transport.ts

@@ -8,6 +8,7 @@ import {
 	isKernelToHostMessage,
 	type KernelToHostMessage,
 } from "../../bridge/protocol.ts";
+import { applySessionEnvironment, type SessionEnvironment } from "../session-env.ts";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import {
 	defaultSpawn,
@@ -36,6 +37,8 @@ export interface PythonTransportOptions {
 	readonly cwd: string;
 	readonly connection: BridgeConnectionConfig;
 	readonly env?: NodeJS.ProcessEnv;
+	/** Per-session PI_* values merged into the interpreter environment at spawn. */
+	readonly sessionEnv?: SessionEnvironment;
 	readonly startupTimeoutMs: number;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	readonly spawnProcess?: KernelSpawnProcess;
@@ -83,7 +86,12 @@ export class PythonKernelTransport {
 			command: invocation.command,
 			args: [...invocation.args, "-u", scriptPath],
 			cwd: options.cwd,
-			env: { ...process.env, ...options.env, PYTHONUNBUFFERED: "1", PYTHONIOENCODING: "utf-8" },
+			env: {
+				...applySessionEnvironment(process.env, options.sessionEnv),
+				...options.env,
+				PYTHONUNBUFFERED: "1",
+				PYTHONIOENCODING: "utf-8",
+			},
 		};
 		const child = (options.spawnProcess ?? defaultSpawn)(spawnOptions);
 		const transport = new PythonKernelTransport(options, child);

package/src/kernels/rb/kernel.ts

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { SessionEnvironment } from "../session-env.ts";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { SubprocessKernel, type SubprocessSpawn } from "../shared/subprocess-kernel.ts";
 
@@ -7,6 +8,8 @@ export interface RubyKernelStartOptions {
 	readonly cwd: string;
 	readonly sessionId: string;
 	readonly connection: BridgeConnectionConfig;
+	/** Per-session PI_* values merged into the interpreter environment at spawn. */
+	readonly sessionEnv?: SessionEnvironment;
 	readonly command?: string;
 	readonly spawn?: SubprocessSpawn;
 	readonly onMessage?: (message: KernelToHostMessage) => void;
@@ -31,6 +34,7 @@ export class RubyKernel extends SubprocessKernel {
 			args: [resolveRubyRunnerPath()],
 			cwd: options.cwd,
 			sessionId: options.sessionId,
+			sessionEnv: options.sessionEnv,
 			connection: options.connection,
 			spawn: options.spawn,
 			onMessage: options.onMessage,

package/src/kernels/session-env.ts

@@ -0,0 +1,56 @@
+/**
+ * Session environment exposed to eval kernels and every child they spawn.
+ *
+ * Mirrors the shell-tool session environment contract in the senpi core
+ * (`resolveSpawnContext` in `packages/coding-agent/src/core/tools/bash.ts` and
+ * `docs/environment-variables.md`): the per-session `PI_*` variables are
+ * deleted from the inherited environment first, then set from the active
+ * session, so a stale inherited value never leaks into a kernel child. A child
+ * spawned from an eval cell must see the same session environment a child
+ * spawned from the bash tool sees.
+ */
+export const SESSION_ENVIRONMENT_KEYS = [
+	"PI_SESSION_ID",
+	"PI_SESSION_FILE",
+	"PI_PROVIDER",
+	"PI_MODEL",
+	"PI_REASONING_LEVEL",
+] as const;
+
+/** Resolved per-session values for {@link SESSION_ENVIRONMENT_KEYS}; absent keys stay unset. */
+export type SessionEnvironment = Readonly<Record<string, string>>;
+
+/** Structural slice of `ExtensionContext` the session environment is resolved from. */
+export interface SessionEnvironmentSource {
+	readonly sessionManager: {
+		getSessionId(): string;
+		getSessionFile(): string | undefined;
+	};
+	readonly model?: { readonly provider: string; readonly id: string } | undefined;
+	readonly thinkingLevel?: string | undefined;
+}
+
+export function sessionEnvironmentFrom(source: SessionEnvironmentSource): SessionEnvironment {
+	const env: Record<string, string> = {};
+	env.PI_SESSION_ID = source.sessionManager.getSessionId();
+	const sessionFile = source.sessionManager.getSessionFile();
+	if (sessionFile) env.PI_SESSION_FILE = sessionFile;
+	const model = source.model;
+	if (model) {
+		env.PI_PROVIDER = model.provider;
+		env.PI_MODEL = model.id;
+	}
+	if (source.thinkingLevel) env.PI_REASONING_LEVEL = source.thinkingLevel;
+	return env;
+}
+
+/**
+ * Merges a session environment over a base environment the way the bash tool
+ * does: every {@link SESSION_ENVIRONMENT_KEYS} entry is dropped from `base`
+ * first, then the provided session values are applied.
+ */
+export function applySessionEnvironment(base: NodeJS.ProcessEnv, sessionEnv?: SessionEnvironment): NodeJS.ProcessEnv {
+	const merged: NodeJS.ProcessEnv = { ...base };
+	for (const key of SESSION_ENVIRONMENT_KEYS) delete merged[key];
+	return { ...merged, ...sessionEnv };
+}

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

@@ -1,4 +1,5 @@
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { SessionEnvironment } from "../session-env.ts";
 import type { SubprocessSpawn } from "./subprocess-process.ts";
 
 export interface KernelRunInput {
@@ -15,6 +16,8 @@ export interface SubprocessKernelOptions {
 	readonly args: readonly string[];
 	readonly cwd?: string;
 	readonly env?: NodeJS.ProcessEnv;
+	/** Per-session PI_* values merged into the interpreter environment at spawn. */
+	readonly sessionEnv?: SessionEnvironment;
 	readonly sessionId: string;
 	readonly connection: BridgeConnectionConfig;
 	readonly spawn?: SubprocessSpawn;

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

@@ -1,6 +1,7 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
+import { applySessionEnvironment } from "../session-env.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
 import { SubprocessRunQueue } from "./subprocess-queue.ts";
@@ -133,7 +134,14 @@ export class SubprocessKernel {
 	}
 
 	private spawnProcess(): void {
-		const child = spawnSubprocess(this.options.spawn, this.options);
+		const child = spawnSubprocess(this.options.spawn, {
+			...this.options,
+			env:
+				this.options.env ??
+				(this.options.sessionEnv
+					? applySessionEnvironment(globalThis.process.env, this.options.sessionEnv)
+					: undefined),
+		});
 		const process = new SubprocessProcess(child, {
 			onLine: (source, line) => this.handleLine(source, line),
 			onStderr: (source, data) => this.handleMessage(source, { type: "text", stream: "stderr", data }),

package/src/output/output-meta.ts

@@ -28,12 +28,14 @@ export function resolveSessionArtifactsDir(sessionFile: string | undefined): Ses
 
 export interface TruncationMeta {
 	readonly direction: "head" | "tail" | "middle";
-	readonly truncatedBy: "lines" | "bytes" | "middle";
+	readonly truncatedBy: "lines" | "bytes" | "columns" | "middle";
 	readonly totalLines: number;
 	readonly totalBytes: number;
 	readonly outputLines: number;
 	readonly outputBytes: number;
 	readonly maxBytes?: number;
+	readonly maxColumns?: number;
+	readonly columnTruncatedLines?: number;
 	readonly shownRange?: { readonly start: number; readonly end: number };
 	readonly headRange?: { readonly start: number; readonly end: number };
 	readonly tailRange?: { readonly start: number; readonly end: number };
@@ -72,7 +74,7 @@ export function formatTruncationWarning(meta: TruncationMeta | undefined): strin
 				meta.shownRange !== undefined && meta.shownRange.end >= meta.shownRange.start
 					? `Showing lines ${meta.shownRange.start}-${meta.shownRange.end} of ${meta.totalLines}`
 					: `Showing ${meta.outputLines} of ${meta.totalLines} lines`;
-			if (meta.truncatedBy === "bytes") message += ` (${formatBytes(meta.maxBytes ?? meta.outputBytes)} limit)`;
+			message += formatByteLoss(meta);
 			break;
 		default:
 			return assertNever(meta.direction);
@@ -81,6 +83,28 @@ export function formatTruncationWarning(meta: TruncationMeta | undefined): strin
 	return `[${message}]`;
 }
 
+function formatByteLoss(meta: TruncationMeta): string {
+	const dropped = formatBytes(Math.max(0, meta.totalBytes - meta.outputBytes));
+	switch (meta.truncatedBy) {
+		case "columns": {
+			const clamped = meta.columnTruncatedLines ?? 0;
+			const width = meta.maxColumns === undefined ? "the column cap" : `${meta.maxColumns} columns`;
+			return `; ${clamped} line${clamped === 1 ? "" : "s"} clamped to ${width} (${dropped} dropped)`;
+		}
+		case "bytes":
+			return meta.maxBytes === undefined ? ` (${dropped} dropped)` : ` (${formatBytes(meta.maxBytes)} limit)`;
+		case "lines":
+		case "middle":
+			return "";
+		default:
+			return assertNeverCause(meta.truncatedBy);
+	}
+}
+
+function assertNeverCause(value: never): never {
+	throw new TypeError(`Unhandled truncation cause: ${String(value)}`);
+}
+
 export function stripOutputNotice(text: string, meta: TruncationMeta | undefined): string {
 	const notice = formatTruncationWarning(meta);
 	if (notice === null) return text;

package/src/prompt/eval-prompt.ts

@@ -70,29 +70,22 @@ const EVAL_PROMPT_TEMPLATE = `Run one step of code in a persistent kernel.
 **One eval call = one cell = one logical step.** Top-level names persist per language across eval calls{{#if spawns}}, tool calls and \`task\` subagents{{else}} and tool calls{{/if}}: define helpers and clients once and reuse them instead of re-importing or re-reading. Rebuild state only after \`reset\`, a kernel restart, or a \`NameError\`/\`ReferenceError\`, and check a sentinel variable first so a re-run cannot duplicate side effects.
 
 {{#if styleClaude}}<eval_first_batching>
-\`eval\` is your default execution surface: if a step needs more than one tool call, write ONE cell that performs the whole step — never issue the calls one at a time.
-- Enumerate every lookup the step needs, then run all independent ones simultaneously with \`parallel(thunks)\` inside the cell; keep calls sequential only when one result feeds the next.
-- Write real code around the calls: loop or comprehend over file sets with \`read()\`/stdlib, branch per case, and wrap risky calls in try/except so one failure degrades only its item — recover or retry inside the cell, keep the batch alive.
-- Post-process \`tool.<name>()\` results programmatically — filter, join, aggregate — and return distilled facts, not raw dumps.
+Batch a step's independent calls in one cell with \`parallel(thunks)\`; write real code around them - loops, branches, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
 {{#if monitor}}- Start long-running work (build, test run, deploy, or watch) through \`tool.monitor({ command, filter })\`, putting the decisive-line filter inside the same cell, then keep working until its event wakes the turn.{{/if}}
 </eval_first_batching>{{/if}}{{#if styleGpt}}<gpt_eval_dialect>
-GPT eval: compose multi-tool work inside one cell with \`tool.<name>(args)\` and \`parallel(thunks)\`; do not split a planned step into serial tool calls.
+GPT eval: batch a step's independent tool calls in one cell with \`tool.<name>(args)\` and \`parallel(thunks)\` and inspect every result.
 {{#if monitor}}- A wait or a long run (build, test run, deploy, watch) starts through \`tool.monitor({ command, filter })\` in that same cell with the decisive-line filter; its event wakes the turn, so no cell sits on the wait and no child is spawned for it.
 {{/if}}- Long cells detach on timeout and notify on completion; do not poll or re-run them.
-- Filter, join, and aggregate tool results in the cell; return only decision-relevant facts.
-</gpt_eval_dialect>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
-- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically — filter, join, aggregate.
-- Wrap failable calls in try/except inside the cell; a failed item degrades only itself. After two distinct failed strategies for the same fact, fall back to direct tool calls.
-- Reduce large results in-kernel to the facts the task needs before returning.
-{{#if monitor}}- Long-running build/test/deploy/watch work: start \`tool.monitor({ command, filter })\` with the decisive-line filter inside the same cell, then continue working until its event wakes the turn.{{/if}}{{/if}}{{#if styleKimi}}**EVAL IS YOUR SUPERPOWER — MAKE IT YOUR DEFAULT WAY TO ACT.** Before any step, think: "how do I execute this WHOLE step in ONE parallelized cell?" — then write that ONE cell.
-- **BATCH EVERYTHING AT ONCE:** enumerate EVERY independent lookup the step needs and dispatch them ALL simultaneously with \`parallel(thunks)\` in that cell; keep calls sequential only when one result feeds the next.
-- **WRITE REAL CODE, NOT CALL CHAINS:** loop or comprehend over file sets with \`read()\`/stdlib, post-process \`tool.<name>()\` results programmatically, and put try/except around each risky call so the rest of the batch completes.
-- **DISTILL IN-KERNEL:** filter, join, and aggregate \`tool.<name>()\` results in code, then return ONLY the distilled facts.
-{{#if monitor}}- **DO start long-running build, test run, deploy, or watch work with \`tool.monitor({ command, filter })\`, put the decisive-line filter INSIDE THE SAME CELL, and KEEP WORKING until its event wakes the turn.**{{/if}}{{/if}}{{#if styleDefault}}**EVAL IS YOUR PRIMARY EXECUTION SURFACE.** Any step that needs MORE THAN ONE tool call MUST be written as ONE cell — NEVER as a chain of single tool calls.
-- **PLAN THE WHOLE STEP, THEN BATCH IT.** Enumerate every read/search/lookup the step needs and dispatch ALL independent ones through \`parallel(thunks)\` in one cell.
-- **WRITE REAL CODE, NOT CALL LISTS.** Loop or comprehend over file sets with \`read()\`/stdlib, branch \`if\`/\`else\` per case, post-process \`tool.<name>()\` results programmatically, and wrap EVERY risky call in try/except so ONE failure NEVER kills the batch.
-- **DISTILL IN-KERNEL.** Filter, join, diff, and aggregate in code before returning; return facts, NOT dumps.
-{{#if monitor}}- **LONG-RUNNING build, test run, deploy, or watch work MUST start with \`tool.monitor({ command, filter })\`, with the decisive-line filter INSIDE THE SAME CELL; KEEP WORKING until its event wakes the turn.**{{/if}}{{/if}}
+- Keep every failed or missing item in the result verbatim and re-read truncated output before deciding.
+</gpt_eval_dialect>{{/if}}{{#if styleCodex}}Route a step's independent lookups through one eval cell via \`parallel(thunks)\` and inspect every result.
+- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
+- Wrap failable calls in try/except inside the cell and keep every failed item in the result verbatim; after two distinct failed strategies for the same fact, fall back to direct tool calls.
+- Re-read truncated output before deciding on it.
+{{#if monitor}}- Long-running build/test/deploy/watch work: start \`tool.monitor({ command, filter })\` with the decisive-line filter inside the same cell, then continue working until its event wakes the turn.{{/if}}{{/if}}{{#if styleKimi}}Put a step's independent calls into one cell with \`parallel(thunks)\`.
+- Write real code around the calls - loops, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
+{{#if monitor}}- Start long-running build, test run, deploy, or watch work with \`tool.monitor({ command, filter })\`, put the decisive-line filter inside the same cell, and keep working until its event wakes the turn.{{/if}}{{/if}}{{#if styleDefault}}Batch a step's independent calls in one cell with \`parallel(thunks)\`.
+- Write real code around the calls - loops, branches, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
+{{#if monitor}}- Long-running build, test run, deploy, or watch work starts with \`tool.monitor({ command, filter })\`, with the decisive-line filter inside the same cell; keep working until its event wakes the turn.{{/if}}{{/if}}
 {{#if hostLine}}
 Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to its cores; \`tool.<name>()\` shell commands must fit this platform, even when the code you are writing targets another machine.
 {{/if}}
@@ -200,12 +193,12 @@ const GPT_MONITOR_BATCHING_GUIDELINE =
 
 const BATCHING_GUIDELINES: Record<EvalEmphasisStyle, string> = {
 	default:
-		"**EVAL FIRST.** Any step needing MORE THAN ONE tool call MUST be ONE eval cell: run independent calls in parallel, wrap risky calls in try/except, and return distilled facts — NEVER a chain of single tool calls.",
+		"Prefer eval when a step's calls are independent: one cell runs them together and keeps every failure in its result; edits and result-dependent calls go one at a time, each observed before the next.",
 	claude:
-		"Prefer eval for any step needing more than one tool call: one cell that runs independent calls in parallel, handles per-call failures in code, and returns distilled facts.",
-	codex: "Route multi-call steps through eval: one cell per step, independent calls dispatched in parallel; fall back to direct tool calls when one call is sufficient or each result changes the next decision.",
-	gpt: "Use eval to compose tool work in one cell; long cells detach on timeout and notify on completion, so do not poll.",
-	kimi: "**EVAL IS YOUR SUPERPOWER — DEFAULT TO IT.** Execute EVERY multi-call step as ONE eval cell: run ALL independent calls simultaneously via parallel(thunks), handle failures per item in code, and return ONLY distilled facts.",
+		"Prefer eval for a step's independent calls: one cell runs them together and keeps every failure in its result.",
+	codex: "Route a step's independent calls through one eval cell and inspect every result; a direct tool call is right when one call is sufficient.",
+	gpt: "Use eval to batch a step's independent tool calls in one cell and inspect every result; long cells detach on timeout and notify on completion, so do not poll.",
+	kimi: "Put a step's independent calls into one eval cell with parallel(thunks) and keep every failed item in the result.",
 };
 
 function renderTemplate(template: string, context: Context): string {

package/src/tool/image.ts

@@ -119,7 +119,7 @@ export class EvalOutputCollector {
 	async finish(): Promise<EvalOutputResult> {
 		await this.#processImages();
 		const summary = await this.#finalSummary();
-		const meta = truncationMetaFromSummary(summary);
+		const meta = truncationMetaFromSummary(summary, this.#options.maxColumns);
 		const notice = summary.artifactId === undefined ? undefined : artifactNotice(summary.artifactId);
 		return {
 			output: summary.output.trimEnd(),
@@ -215,7 +215,7 @@ function formatDisplayJson(value: unknown): string {
 	return `${text.slice(0, MAX_DISPLAY_TEXT_BYTES)}\n[…${text.length - MAX_DISPLAY_TEXT_BYTES}ch elided…]`;
 }
 
-function truncationMetaFromSummary(summary: OutputSummary): TruncationMeta | undefined {
+function truncationMetaFromSummary(summary: OutputSummary, maxColumns: number): TruncationMeta | undefined {
 	if (!summary.truncated) return undefined;
 	const artifact = summary.artifactId === undefined ? {} : { artifactId: summary.artifactId };
 	if (summary.elidedBytes !== undefined && summary.elidedBytes > 0) {
@@ -239,9 +239,18 @@ function truncationMetaFromSummary(summary: OutputSummary): TruncationMeta | und
 			...artifact,
 		};
 	}
+	const droppedBytes = Math.max(0, summary.totalBytes - summary.outputBytes);
+	const clampedLines = summary.columnTruncatedLines ?? 0;
+	const columnOnly = clampedLines > 0 && (summary.columnDroppedBytes ?? 0) >= droppedBytes;
+	const byteCapped = summary.totalBytes - (summary.columnDroppedBytes ?? 0) > DEFAULT_MAX_BYTES;
 	return {
 		direction: "tail",
-		truncatedBy: summary.outputBytes < summary.totalBytes ? "bytes" : "lines",
+		truncatedBy: columnOnly ? "columns" : byteCapped ? "bytes" : "lines",
+		...(columnOnly
+			? { maxColumns, columnTruncatedLines: clampedLines }
+			: byteCapped
+				? { maxBytes: DEFAULT_MAX_BYTES }
+				: {}),
 		totalLines: summary.totalLines,
 		totalBytes: summary.totalBytes,
 		outputLines: summary.outputLines,