@code-yeongyu/senpi-codemode 2026.9.13 → 2026.9.15-2

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

@@ -3,10 +3,14 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { inspect } from "node:util";
 import { encodeDisplayImage, resolveDisplayOps } from "./display-image.js";
+import { terminateProcessTrees } from "./process-tree.js";
 import { awaitMaybePromise, indirectEval, wrapUserCode } from "./worker-indirect-eval.js";
 import { installShellCapture } from "./worker-shell-capture.js";
 
 const PREPARED_CELL_PREFIX = "/*senpi:prepared-cell*/";
+// How long a child gets to honour SIGTERM before SIGKILL. Short, because the
+// cell has already produced its value and the caller is waiting on settle.
+const CHILD_TERMINATION_GRACE_MS = 1_000;
 const INTERNAL_URL = /^([a-z][a-z0-9+.-]*):\/\/(.*)$/iu;
 
 export class JsWorkerRuntime {
@@ -17,10 +21,12 @@ export class JsWorkerRuntime {
 	#hooks = null;
 	#pendingDisplays = [];
 	#children = new Set();
+	#onChildEvent;
 
 	constructor(options) {
 		this.#cwd = options.cwd;
 		this.#parallelPoolWidth = options.parallelPoolWidth;
+		this.#onChildEvent = typeof options.onChildEvent === "function" ? options.onChildEvent : null;
 		this.#localRoots = { ...(options.localRoots ?? {}) };
 		if (options.artifactsDir && !this.#localRoots.local) this.#localRoots.local = join(options.artifactsDir, "local");
 		this.#installGlobals();
@@ -42,24 +48,46 @@ export class JsWorkerRuntime {
 			return value;
 		} finally {
 			this.#pendingDisplays = [];
-			this.#children.clear();
+			// A child still running here has lost its only owner: the cell that
+			// spawned it is over, nothing will await it again, and it would be
+			// reparented to init. Retire it the way timeout and abort cleanup
+			// already do, unless the cell asked for a detached process.
+			await this.#terminateChildren();
 			this.#hooks = null;
 		}
 	}
 
 	interrupt() {
-		for (const child of this.#children) {
-			if (child.exitCode === null && child.signalCode === null) child.kill();
-		}
+		// The tree snapshot, SIGTERM, and SIGKILL escalation run on their own so
+		// the caller's interrupt latency stays that of the acknowledgement.
+		void this.#terminateChildren();
 	}
 
-	#trackChild(child) {
+	#trackChild(child, spawnOptions) {
 		if (child === null || typeof child !== "object" || typeof child.kill !== "function") return;
+		// `detached: true` is the cell saying it wants the process to outlive it.
+		if (isPlainObject(spawnOptions) && spawnOptions.detached === true) return;
 		this.#children.add(child);
-		const forget = () => this.#children.delete(child);
+		const pid = Number.isInteger(child.pid) && child.pid > 0 ? child.pid : null;
+		// The host keeps its own copy of live pids: if this worker is terminated
+		// while blocked, only the host can still retire them.
+		if (pid !== null) this.#onChildEvent?.({ pid, state: "spawned" });
+		const forget = () => {
+			this.#children.delete(child);
+			if (pid !== null) this.#onChildEvent?.({ pid, state: "exited" });
+		};
 		if (child.exited instanceof Promise) child.exited.then(forget, forget);
 	}
 
+	#terminateChildren() {
+		const children = [...this.#children].filter(child => child.exitCode === null && child.signalCode === null);
+		this.#children.clear();
+		if (children.length === 0) return undefined;
+		const roots = children.map(child => child.pid).filter(pid => Number.isInteger(pid) && pid > 0);
+		const settled = Promise.allSettled(children.map(child => (child.exited instanceof Promise ? child.exited : Promise.resolve())));
+		return terminateProcessTrees(roots, { graceMs: CHILD_TERMINATION_GRACE_MS, settled });
+	}
+
 	async #drainPendingDisplays() {
 		while (this.#pendingDisplays.length > 0) {
 			const pending = this.#pendingDisplays;
@@ -114,7 +142,7 @@ export class JsWorkerRuntime {
 		const restoreShellCapture = installShellCapture({
 			isActive: () => this.#hooks !== null,
 			emitText: (stream, data) => this.#emitText(stream, data),
-			onChild: (child) => this.#trackChild(child),
+			onChild: (child, spawnOptions) => this.#trackChild(child, spawnOptions),
 		});
 		globalThis.__senpi_restore_console__ = () => {
 			console.log = originalLog;

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

@@ -3,6 +3,7 @@ export type ShellCaptureStream = "stdout" | "stderr";
 export type ShellCaptureRestore = () => void;
 
 export interface ShellCaptureChild {
+	readonly pid?: number;
 	readonly exitCode: number | null;
 	readonly signalCode: string | null;
 	readonly exited: Promise<number>;
@@ -13,7 +14,7 @@ export interface ShellCaptureOptions {
 	readonly isActive: () => boolean;
 	readonly emitText: (stream: ShellCaptureStream, data: string) => void;
 	/** Receives every `Bun.spawn` child created while a cell is active so the runtime can kill it on interrupt. */
-	readonly onChild?: (child: ShellCaptureChild) => void;
+	readonly onChild?: (child: ShellCaptureChild, spawnOptions?: unknown) => void;
 }
 
 export function installShellCapture(options: ShellCaptureOptions): ShellCaptureRestore;

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

@@ -154,7 +154,7 @@ function capturedSpawn(originalSpawn, options, pinEnv) {
 					? originalSpawn(...args)
 					: originalSpawn(effective);
 		}
-		options.onChild?.(child);
+		options.onChild?.(child, Array.isArray(first) ? second : first);
 		return child;
 	};
 }

package/src/kernels/py/prelude.py

@@ -23,7 +23,7 @@ import uuid
 from collections.abc import Iterable
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
-from threading import Lock
+from threading import Lock, Thread
 from typing import Any, Callable
 from urllib.parse import unquote
 
@@ -1022,14 +1022,48 @@ def handle(message: dict[str, Any]) -> bool:
     return True
 
 
+def _terminate_process_group() -> None:
+    # The kernel is spawned into its own session (setsid), so its pid is its process
+    # group id and a cell's subprocesses inherit that group. Killing the group takes
+    # those children down with the kernel instead of orphaning them to init.
+    if os.name != "posix":
+        return
+    with contextlib.suppress(OSError):
+        os.killpg(os.getpgrp(), signal.SIGKILL)
+
+
+def _watch_parent(initial_ppid: int) -> None:
+    # A cell blocked in the main thread (for example a multiprocessing pool) never
+    # returns to the stdin loop, so it cannot notice the host closing its pipe. This
+    # daemon thread notices the reparenting instead and takes the whole group down.
+    while True:
+        time.sleep(1.0)
+        if os.getppid() != initial_ppid:
+            _terminate_process_group()
+            return
+
+
+def _start_parent_watch() -> None:
+    if os.name != "posix":
+        return
+    Thread(target=_watch_parent, args=(os.getppid(),), name="senpi-parent-watch", daemon=True).start()
+
+
 def main() -> None:
     signal.signal(signal.SIGINT, signal.SIG_IGN)
+    _start_parent_watch()
+    host_closed = False
     for raw in sys.stdin:
         try:
             if not handle(json.loads(raw)):
+                host_closed = True
                 break
         except BaseException as exc:  # noqa: BROAD_EXCEPT_OK — process boundary serializes malformed input and interrupts.
             emit({"type": "init-failed", "error": bridge_error(exc)})
+    # Reaching here without a close frame means the host's pipe hit EOF: it is gone,
+    # so retire any subprocess the last cell left running before the interpreter exits.
+    if not host_closed:
+        _terminate_process_group()
 
 
 if __name__ == "__main__":

package/src/kernels/py/process.ts

@@ -45,6 +45,12 @@ export function splitCommand(commandLine: string): { readonly command: string; r
 	return { command, args };
 }
 
+function errorCode(error: unknown): string | undefined {
+	if (typeof error !== "object" || error === null) return undefined;
+	const code = Reflect.get(error, "code");
+	return typeof code === "string" ? code : undefined;
+}
+
 export function numberOrNull(value: unknown): number | null {
 	return typeof value === "number" ? value : null;
 }
@@ -80,6 +86,20 @@ export async function waitForExit(child: KernelChild, timeoutMs: number): Promis
 	});
 }
 
+// A cell's own subprocess is spawned into the detached kernel's process group. When the
+// leader exits gracefully on close, kill the group so a Popen the cell left running does
+// not outlive the kernel; the group is addressed by the leader pid (== pgid) while members live.
+export function sweepProcessGroup(child: KernelChild): void {
+	if (child.pid === undefined || process.platform === "win32") return;
+	try {
+		process.kill(-child.pid, "SIGKILL");
+	} catch (error) {
+		// ESRCH means the group is already gone (the success case). Any other error
+		// (for example EPERM on a member we cannot signal) must not fail a graceful close.
+		if (errorCode(error) !== "ESRCH") return;
+	}
+}
+
 export async function hardKill(child: KernelChild, timeoutMs: number): Promise<void> {
 	await new Promise<void>((resolve, reject) => {
 		let timer: NodeJS.Timeout | undefined;

package/src/kernels/py/transport.ts

@@ -19,6 +19,7 @@ import {
 	numberOrNull,
 	signalOrNull,
 	splitCommand,
+	sweepProcessGroup,
 	waitForExit,
 	withTimeout,
 } from "./process.ts";
@@ -145,7 +146,10 @@ export class PythonKernelTransport {
 		} catch (error) {
 			if (!(error instanceof Error)) throw error;
 		}
-		if (!(await exited)) await hardKill(this.#child, hardKillWaitMs);
+		// hardKill kills the whole group; a graceful leader exit does not, so sweep it
+		// to retire any subprocess the cell left running in the kernel's process group.
+		if (await exited) sweepProcessGroup(this.#child);
+		else await hardKill(this.#child, hardKillWaitMs);
 	}
 
 	retire(): Promise<void> {

package/src/kernels/session-env.ts

@@ -12,6 +12,8 @@
 export const SESSION_ENVIRONMENT_KEYS = [
 	"PI_SESSION_ID",
 	"PI_SESSION_FILE",
+	"PI_SESSION_CWD",
+	"PI_GOAL_STORE_FILE",
 	"PI_PROVIDER",
 	"PI_MODEL",
 	"PI_REASONING_LEVEL",
@@ -22,6 +24,8 @@ export type SessionEnvironment = Readonly<Record<string, string>>;
 
 /** Structural slice of `ExtensionContext` the session environment is resolved from. */
 export interface SessionEnvironmentSource {
+	readonly cwd: string;
+	readonly goalStoreFile?: string;
 	readonly sessionManager: {
 		getSessionId(): string;
 		getSessionFile(): string | undefined;
@@ -33,6 +37,8 @@ export interface SessionEnvironmentSource {
 export function sessionEnvironmentFrom(source: SessionEnvironmentSource): SessionEnvironment {
 	const env: Record<string, string> = {};
 	env.PI_SESSION_ID = source.sessionManager.getSessionId();
+	env.PI_SESSION_CWD = source.cwd;
+	if (source.goalStoreFile) env.PI_GOAL_STORE_FILE = source.goalStoreFile;
 	const sessionFile = source.sessionManager.getSessionFile();
 	if (sessionFile) env.PI_SESSION_FILE = sessionFile;
 	const model = source.model;

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

@@ -2,6 +2,9 @@ import type { KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelResult, KernelRunInput, ToolCallMessage } from "./subprocess-contract.ts";
 import { createPendingRun, failureResult, type PendingRun, settlePendingRun } from "./subprocess-run.ts";
 
+// Same bound as the JS kernel's pull-API fallback queue (context-manager.ts); clears happen at run teardown.
+const MAX_PENDING_TOOL_CALLS = 256;
+
 export class SubprocessRunQueue {
 	readonly #queue: PendingRun[] = [];
 	readonly #pendingCalls: ToolCallMessage[] = [];
@@ -59,7 +62,10 @@ export class SubprocessRunQueue {
 	pushToolCall(message: ToolCallMessage): void {
 		const waiter = this.#callWaiters.shift();
 		if (waiter) waiter(message);
-		else this.#pendingCalls.push(message);
+		else {
+			this.#pendingCalls.push(message);
+			if (this.#pendingCalls.length > MAX_PENDING_TOOL_CALLS) this.#pendingCalls.shift();
+		}
 	}
 
 	handleMessage(

package/src/tool/detached-cell-manager.ts

@@ -1,14 +1,12 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
 import { DEFAULT_HARD_LIMIT_SECONDS, DEFAULT_RUN_BUDGET_SECONDS } from "../config/settings.ts";
 import type { WakeSourceState } from "../extension/wake-source-state.ts";
-import { type CellDeadlineExpiry, CellDeadlines } from "./cell-deadlines.ts";
+import type { CellDeadlineExpiry } from "./cell-deadlines.ts";
 import type {
 	EvalDetachedCellManagerOptions,
 	EvalDetachedCellSnapshot,
-	EvalDetachedCellState,
 	EvalDetachedCellStatusEntry,
 } from "./detached-cell-contract.ts";
-import { detachedNotificationSpillPath } from "./detached-cell-notification.ts";
 import { currentDetachedResult, detachedErrorResult, snapshotDetachedCell } from "./detached-cell-snapshot.ts";
 import {
 	activeDetachedCellReuseError,
@@ -17,6 +15,8 @@ import {
 } from "./detached-cell-state.ts";
 import { detachedStatusEntries, detachedWakeSourceState } from "./detached-cell-status.ts";
 import { DetachedNotificationQueue } from "./detached-notification-queue.ts";
+import { createManagedCell, type LiveResultProvider, type ManagedCell } from "./managed-cell.ts";
+import { TerminalSnapshotStore } from "./terminal-snapshot-store.ts";
 import type { EvalKernel, EvalLanguage, EvalToolDetails, EvalToolInput } from "./types.ts";
 
 export type {
@@ -28,40 +28,13 @@ export type {
 	EvalDetachedCellStatusEntry,
 } from "./detached-cell-contract.ts";
 
-type LiveResultProvider = () => AgentToolResult<EvalToolDetails>;
-
-type ManagedCell = {
-	readonly cellId: string;
-	readonly input: EvalToolInput;
-	readonly spillPath: string | undefined;
-	readonly startedAtMs: number;
-	readonly terminal: PromiseWithResolvers<EvalDetachedCellSnapshot>;
-	state: EvalDetachedCellState;
-	canDetach: boolean;
-	wasDetached: boolean;
-	kernel: EvalKernel | undefined;
-	stateRetained: boolean | undefined;
-	interruptNote: string | undefined;
-	/** Holds the completion notification until the interrupt has reported whether kernel state survived. */
-	interruptOutcome: PromiseWithResolvers<void> | undefined;
-	liveResult: LiveResultProvider | undefined;
-	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
-	notificationQueued: boolean;
-	readonly deadlines: CellDeadlines;
-	readonly hardLimitSeconds: number;
-	readonly runBudgetSeconds: number;
-	hardLimited: boolean;
-	runBudgetExhausted: boolean;
-	/** Foreground killer: the still-awaited CellExecution owns interrupting and rejecting its own call; bound from creation so a deadline firing during kernel boot still ends it. */
-	onKill: ((error: Error) => void) | undefined;
-};
-
 export class EvalDetachedCellManager {
 	readonly #artifactsDir: string | undefined;
 	readonly #onStatusChange: ((entries: readonly EvalDetachedCellStatusEntry[]) => void) | undefined;
 	readonly #onWakeSourceState: ((state: WakeSourceState) => void) | undefined;
 	readonly #cells = new Map<string, ManagedCell>();
 	readonly #detachedByLanguage = new Map<EvalLanguage, ManagedCell>();
+	readonly #terminalSnapshots = new TerminalSnapshotStore();
 	readonly #notificationQueue: DetachedNotificationQueue;
 	readonly #now: () => number;
 	readonly #hardLimitSeconds: number;
@@ -83,40 +56,20 @@ export class EvalDetachedCellManager {
 			if (detachedCellIsActive(existing.state)) throw activeDetachedCellReuseError(existing);
 			this.#cells.delete(cellId);
 		}
-		// An explicit longer per-call timeout raises the deadline, mirroring bash keeping explicit timeouts.
-		const hardLimitSeconds = Math.max(this.#hardLimitSeconds, input.timeout ?? 0);
-		const runBudgetSeconds = input.timeout ?? this.#runBudgetSeconds;
-		const cell: ManagedCell = {
+		this.#terminalSnapshots.delete(cellId);
+		const cell = createManagedCell({
 			cellId,
 			input,
-			spillPath: detachedNotificationSpillPath(this.#artifactsDir, cellId),
-			startedAtMs: this.#now(),
-			state: "running",
-			canDetach: false,
-			wasDetached: false,
-			kernel: undefined,
-			stateRetained: undefined,
-			interruptNote: undefined,
-			interruptOutcome: undefined,
-			liveResult: undefined,
-			terminalResult: undefined,
-			notificationQueued: false,
-			deadlines: new CellDeadlines({
-				cellId,
-				hardLimitSeconds,
-				runBudgetSeconds,
-				onExpire: (expiry) => {
-					const managed = this.#cells.get(cellId);
-					if (managed !== undefined) void this.#expireDeadline(managed, expiry);
-				},
-			}),
-			hardLimitSeconds,
-			runBudgetSeconds,
-			hardLimited: false,
-			runBudgetExhausted: false,
+			artifactsDir: this.#artifactsDir,
+			now: this.#now,
+			defaultHardLimitSeconds: this.#hardLimitSeconds,
+			defaultRunBudgetSeconds: this.#runBudgetSeconds,
 			onKill,
-			terminal: Promise.withResolvers<EvalDetachedCellSnapshot>(),
-		};
+			onExpire: (expiredId, expiry) => {
+				const managed = this.#cells.get(expiredId);
+				if (managed !== undefined) void this.#expireDeadline(managed, expiry);
+			},
+		});
 		this.#cells.set(cellId, cell);
 		return cell;
 	}
@@ -144,7 +97,12 @@ export class EvalDetachedCellManager {
 	}
 
 	detach(cell: ManagedCell): boolean {
-		if (!cell.canDetach || !allowsDetachedCellTransition(cell.state, "detached")) return false;
+		if (
+			!cell.canDetach ||
+			!allowsDetachedCellTransition(cell.state, "detached") ||
+			this.#detachedByLanguage.has(cell.input.language)
+		)
+			return false;
 		cell.state = "detached";
 		cell.wasDetached = true;
 		this.#detachedByLanguage.set(cell.input.language, cell);
@@ -161,13 +119,15 @@ export class EvalDetachedCellManager {
 	}
 
 	async stop(cellId: string, reason = "Stopped detached eval cell"): Promise<EvalDetachedCellSnapshot> {
-		const cell = this.#get(cellId);
-		if (cell.state === "detached") await this.#cancel(cell, reason);
-		return this.#snapshot(cell);
+		const live = this.#cells.get(cellId);
+		if (live === undefined) return this.#terminal(cellId);
+		if (live.state === "detached") await this.#cancel(live, reason);
+		return this.#snapshot(live);
 	}
 
 	peek(cellId: string): EvalDetachedCellSnapshot {
-		return this.#snapshot(this.#get(cellId));
+		const live = this.#cells.get(cellId);
+		return live === undefined ? this.#terminal(cellId) : this.#snapshot(live);
 	}
 
 	busyFor(language: EvalLanguage): EvalDetachedCellSnapshot | undefined {
@@ -176,7 +136,8 @@ export class EvalDetachedCellManager {
 	}
 
 	async waitForTerminal(cellId: string): Promise<EvalDetachedCellSnapshot> {
-		return await this.#get(cellId).terminal.promise;
+		const live = this.#cells.get(cellId);
+		return live === undefined ? this.#terminal(cellId) : await live.terminal.promise;
 	}
 
 	async dispose(): Promise<void> {
@@ -186,6 +147,8 @@ export class EvalDetachedCellManager {
 		);
 		if (detached.length === 0) this.#emitWakeSourceState([]);
 		await this.#notificationQueue.flush();
+		this.#cells.clear();
+		this.#terminalSnapshots.clear();
 	}
 
 	async flushNotifications(): Promise<void> {
@@ -208,6 +171,8 @@ export class EvalDetachedCellManager {
 		cell.terminalResult = result;
 		cell.liveResult = undefined;
 		cell.terminal.resolve(this.#snapshot(cell));
+		this.#cells.delete(cell.cellId);
+		this.#refreshTerminalSnapshot(cell);
 		if (cell.wasDetached) {
 			if (this.#detachedByLanguage.get(cell.input.language) === cell)
 				this.#detachedByLanguage.delete(cell.input.language);
@@ -252,9 +217,14 @@ export class EvalDetachedCellManager {
 			cell.stateRetained = await handle.stateRetained;
 		} finally {
 			outcome.resolve();
+			this.#refreshTerminalSnapshot(cell);
 		}
 	}
 
+	#refreshTerminalSnapshot(cell: ManagedCell): void {
+		if (!this.#cells.has(cell.cellId)) this.#terminalSnapshots.remember(this.#snapshot(cell));
+	}
+
 	#emitStatus(): void {
 		const liveCells = [...this.#detachedByLanguage.values()];
 		this.#onStatusChange?.(detachedStatusEntries(liveCells));
@@ -269,9 +239,9 @@ export class EvalDetachedCellManager {
 		return snapshotDetachedCell(cell, this.#now());
 	}
 
-	#get(cellId: string): ManagedCell {
-		const cell = this.#cells.get(cellId);
-		if (cell === undefined) throw new Error(`Unknown detached eval cell "${cellId}"`);
-		return cell;
+	#terminal(cellId: string): EvalDetachedCellSnapshot {
+		const snapshot = this.#terminalSnapshots.get(cellId);
+		if (snapshot === undefined) throw new Error(`Unknown detached eval cell "${cellId}"`);
+		return snapshot;
 	}
 }

package/src/tool/image-resize.ts

@@ -0,0 +1,52 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import { convertToPng, formatDimensionNote, resizeImage } from "@code-yeongyu/senpi";
+
+export interface EvalImageContent {
+	readonly type: "image";
+	readonly data: string;
+	readonly mimeType: string;
+}
+
+export interface EvalImageResizeResult {
+	readonly image: EvalImageContent;
+	readonly dimensionNote?: string;
+}
+
+export type EvalImageResizer = (
+	image: EvalImageContent,
+	model: ExtensionContext["model"],
+) => Promise<EvalImageResizeResult>;
+
+type WebpModel = { readonly provider: string; readonly api: string } | undefined;
+
+export function webpExclusionForModel(model: WebpModel): true | undefined {
+	if (model === undefined) return undefined;
+	return model.provider === "ollama" ||
+		model.provider === "ollama-cloud" ||
+		model.provider === "llama.cpp" ||
+		model.provider === "lm-studio" ||
+		model.provider === "local-server" ||
+		model.api === "ollama-chat"
+		? true
+		: undefined;
+}
+
+export const resizeEvalImage: EvalImageResizer = async (image, model) => {
+	const excludeWebP = webpExclusionForModel(model);
+	const forceWebpConversion = excludeWebP === true && image.mimeType === "image/webp";
+	const resized = await resizeImage(
+		Buffer.from(image.data, "base64"),
+		image.mimeType,
+		forceWebpConversion ? { maxBytes: Buffer.byteLength(image.data, "utf8") } : undefined,
+	);
+	let output: EvalImageContent =
+		resized === null ? image : { type: "image", data: resized.data, mimeType: resized.mimeType };
+	if (excludeWebP === true && output.mimeType === "image/webp") {
+		const converted = await convertToPng(output.data, output.mimeType);
+		if (converted === null)
+			throw new TypeError(`Unable to convert ${output.mimeType} display output for the active model`);
+		output = { type: "image", data: converted.data, mimeType: converted.mimeType };
+	}
+	const dimensionNote = resized === null ? undefined : formatDimensionNote(resized);
+	return { image: output, ...(dimensionNote === undefined ? {} : { dimensionNote }) };
+};