@code-yeongyu/senpi-codemode 2026.10.11 → 2026.10.12

package/CHANGELOG.md

@@ -12,6 +12,24 @@
 
 ### Removed
 
+## [2026.10.12] - 2026-10-12
+
+### Breaking Changes
+
+### Added
+
+- Session-owned eval cell RPC handlers share the eval tool's manager, bound output tails, return typed unknown-cell failures and confirmed stop snapshots, and preserve ordinary detached completion notifications ([#3072](https://github.com/code-yeongyu/senpi/issues/3072)).
+
+### Changed
+
+- The eval tool's stop action also cancels listed running foreground cells, returning their terminal outcome. Concurrent stops await the same interrupt and confirm whether kernel state survived ([#3072](https://github.com/code-yeongyu/senpi/issues/3072)).
+
+### Fixed
+
+- Pip installs preserve successful results, typed install errors and cancellation when scratch cleanup fails. Cleanup retries before reporting exhausted retries as a warning ([#3103](https://github.com/code-yeongyu/senpi/pull/3103)).
+
+### Removed
+
 ## [2026.10.11] - 2026-10-11
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.10.11",
+	"version": "2026.10.12",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -19,7 +19,7 @@
 	"scripts": {
 		"gate": "bun scripts/gate-eval.ts",
 		"bench": "bun scripts/bench-eval.ts",
-		"test": "vitest run test/",
+		"test": "node ../../scripts/run-tests.mjs vitest run test/",
 		"clean": "node -e \"\"",
 		"build": "node -e \"\""
 	},
@@ -33,15 +33,15 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.11",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.12",
 		"quickjs-wasi": "3.6.2",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.10.11"
+		"@code-yeongyu/senpi": "2026.10.12"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.10.11"
+		"@code-yeongyu/senpi": "2026.10.12"
 	},
 	"keywords": [
 		"senpi",

package/src/environments/py-installer.ts

@@ -1,5 +1,7 @@
 import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
 import { devNull } from "node:os";
+import { join } from "node:path";
 import { terminateProcessTrees } from "../kernels/js/process-tree-host.ts";
 
 export type EnvironmentErrorCode =
@@ -180,7 +182,7 @@ export function isolatedPipEnv(): NodeJS.ProcessEnv {
 	return { ...env, PIP_CONFIG_FILE: process.platform === "win32" ? "nul" : devNull, PYTHONNOUSERSITE: "1" };
 }
 
-export function runPipInstall(input: {
+export async function runPipInstall(input: {
 	readonly interpreter: string;
 	readonly root: string;
 	readonly args: readonly string[];
@@ -200,52 +202,82 @@ export function runPipInstall(input: {
 		input.root,
 		...input.args,
 	];
-	return new Promise((resolve, reject) => {
-		if (input.signal.aborted) {
-			reject(new EnvironmentError("environment_install_cancelled", "the install was cancelled before it started"));
-			return;
-		}
-		const child = spawn(input.interpreter, argv, {
-			cwd: input.cwd,
-			stdio: ["ignore", "pipe", "pipe"],
-			env: isolatedPipEnv(),
-		});
-		let stderrTail = "";
-		child.stdout.setEncoding("utf8").on("data", (data: string) => input.onOutput?.("stdout", data));
-		child.stderr.setEncoding("utf8").on("data", (data: string) => {
-			stderrTail = (stderrTail + data).slice(-STDERR_TAIL_BYTES);
-			input.onOutput?.("stderr", data);
-		});
-		// pip's build backends run in their own subprocesses; stopping only pip would leave them writing.
-		const onAbort = () => {
-			const pid = child.pid;
-			if (pid === undefined) child.kill("SIGKILL");
-			else void terminateProcessTrees([pid], { graceMs: PIP_TREE_GRACE_MS }).catch(() => child.kill("SIGKILL"));
-		};
-		input.signal.addEventListener("abort", onAbort, { once: true });
-		child.once("error", (error) => {
-			input.signal.removeEventListener("abort", onAbort);
-			reject(
-				new EnvironmentError("environment_installer_unavailable", `${input.interpreter} -m pip: ${error.message}`),
-			);
-		});
-		child.once("close", (code, signal) => {
-			input.signal.removeEventListener("abort", onAbort);
+	if (input.signal.aborted) {
+		throw new EnvironmentError("environment_install_cancelled", "the install was cancelled before it started");
+	}
+	const scratch = await mkdtemp(join(input.root, ".pip-"));
+	try {
+		await new Promise<void>((resolve, reject) => {
 			if (input.signal.aborted) {
-				reject(new EnvironmentError("environment_install_cancelled", "the install was cancelled; pip was stopped"));
-			} else if (code === 0) resolve();
-			else if (/No module named pip/.test(stderrTail)) {
-				reject(new EnvironmentError("environment_installer_unavailable", `${input.interpreter} has no pip module`));
-			} else if (/ResolutionImpossible|conflicting dependencies/.test(stderrTail)) {
-				reject(new EnvironmentError("environment_resolution_conflict", stderrTail.trim()));
-			} else {
+				reject(
+					new EnvironmentError("environment_install_cancelled", "the install was cancelled before it started"),
+				);
+				return;
+			}
+			const child = spawn(input.interpreter, argv, {
+				cwd: input.cwd,
+				stdio: ["ignore", "pipe", "pipe"],
+				env: { ...isolatedPipEnv(), TMPDIR: scratch, TEMP: scratch, TMP: scratch },
+			});
+			let termination: Promise<void> | undefined;
+			let stderrTail = "";
+			child.stdout.setEncoding("utf8").on("data", (data: string) => input.onOutput?.("stdout", data));
+			child.stderr.setEncoding("utf8").on("data", (data: string) => {
+				stderrTail = (stderrTail + data).slice(-STDERR_TAIL_BYTES);
+				input.onOutput?.("stderr", data);
+			});
+			// pip's build backends run in their own subprocesses; stopping only pip would leave them writing.
+			const onAbort = () => {
+				const pid = child.pid;
+				if (pid === undefined) child.kill("SIGKILL");
+				else
+					termination = terminateProcessTrees([pid], { graceMs: PIP_TREE_GRACE_MS }).catch(() => {
+						child.kill("SIGKILL");
+					});
+			};
+			input.signal.addEventListener("abort", onAbort, { once: true });
+			child.once("error", (error) => {
+				input.signal.removeEventListener("abort", onAbort);
 				reject(
 					new EnvironmentError(
-						"environment_install_failed",
-						stderrTail.trim() || `pip exited with ${code ?? signal}`,
+						"environment_installer_unavailable",
+						`${input.interpreter} -m pip: ${error.message}`,
 					),
 				);
-			}
+			});
+			child.once("close", async (code, signal) => {
+				input.signal.removeEventListener("abort", onAbort);
+				await termination;
+				if (input.signal.aborted) {
+					reject(
+						new EnvironmentError("environment_install_cancelled", "the install was cancelled; pip was stopped"),
+					);
+				} else if (code === 0) resolve();
+				else if (/No module named pip/.test(stderrTail)) {
+					reject(
+						new EnvironmentError("environment_installer_unavailable", `${input.interpreter} has no pip module`),
+					);
+				} else if (/ResolutionImpossible|conflicting dependencies/.test(stderrTail)) {
+					reject(new EnvironmentError("environment_resolution_conflict", stderrTail.trim()));
+				} else {
+					reject(
+						new EnvironmentError(
+							"environment_install_failed",
+							stderrTail.trim() || `pip exited with ${code ?? signal}`,
+						),
+					);
+				}
+			});
 		});
-	});
+	} finally {
+		// A killed pip/build backend cannot clean Python's tempfile directories itself.
+		try {
+			await rm(scratch, { recursive: true, force: true, maxRetries: 3 });
+		} catch (cause) {
+			// Keep the install's success or typed failure; cleanup is a separate diagnostic.
+			process.emitWarning(`pip scratch cleanup failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+				code: "SENPI_PIP_SCRATCH_CLEANUP",
+			});
+		}
+	}
 }

package/src/extension/eval-cells-rpc.ts

@@ -0,0 +1,62 @@
+import { EvalCellNotFoundError, type EvalDetachedCellManager } from "../tool/detached-cell-manager.ts";
+import { listEvalCells } from "../tool/detached-eval-result.ts";
+
+const DEFAULT_TAIL_BYTES = 8 * 1024;
+const MAX_TAIL_BYTES = 64 * 1024;
+
+class InvalidEvalCellRequestError extends Error {
+	readonly code = "invalid_eval_cell_request";
+
+	constructor(message: string) {
+		super(message);
+		this.name = "InvalidEvalCellRequestError";
+	}
+}
+
+/** Extension RPC handlers never invoke a model tool or write a session entry. */
+export function registerEvalCellsRpc(
+	rpc: { handle?(name: string, handler: (data: unknown) => unknown | Promise<unknown>): void } | undefined,
+	getCells: () => EvalDetachedCellManager | undefined,
+): void {
+	rpc?.handle?.("eval_cells.list", () => {
+		const cells = getCells();
+		return cells === undefined ? [] : listEvalCells(cells);
+	});
+	for (const action of ["peek", "stop"] as const) {
+		rpc?.handle?.(`eval_cells.${action}`, async (data) => {
+			if (
+				typeof data !== "object" ||
+				data === null ||
+				!("cellId" in data) ||
+				typeof data.cellId !== "string" ||
+				data.cellId.trim().length === 0
+			) {
+				throw new InvalidEvalCellRequestError("cellId must be a non-empty string");
+			}
+			const tailBytes = action === "peek" && "tailBytes" in data ? data.tailBytes : DEFAULT_TAIL_BYTES;
+			if (typeof tailBytes !== "number" || !Number.isSafeInteger(tailBytes) || tailBytes < 0) {
+				throw new InvalidEvalCellRequestError("tailBytes must be a non-negative safe integer");
+			}
+			const cells = getCells();
+			if (cells === undefined) throw new EvalCellNotFoundError(data.cellId);
+			const snapshot = action === "stop" ? await cells.stop(data.cellId) : cells.peek(data.cellId);
+			const bytes = Buffer.from(snapshot.outputTail, "utf8");
+			let start = Math.max(0, bytes.length - Math.min(tailBytes, MAX_TAIL_BYTES));
+			// Drop a partial leading UTF-8 character instead of expanding it into a replacement character.
+			while (start < bytes.length && (bytes[start] & 0xc0) === 0x80) start++;
+			return {
+				cellId: snapshot.cellId,
+				language: snapshot.language,
+				state: snapshot.state,
+				startedAtMs: snapshot.startedAtMs,
+				...(snapshot.result.details.summary ? { summary: snapshot.result.details.summary } : {}),
+				...(snapshot.queuedBehind === undefined ? {} : { queuedBehind: snapshot.queuedBehind }),
+				outputTail: bytes.subarray(start).toString("utf8"),
+				...(snapshot.stateRetained === undefined ? {} : { stateRetained: snapshot.stateRetained }),
+				...(snapshot.interruptNote === undefined ? {} : { interruptNote: snapshot.interruptNote }),
+				...(snapshot.hardLimitSeconds === undefined ? {} : { hardLimitSeconds: snapshot.hardLimitSeconds }),
+				...(snapshot.runBudgetSeconds === undefined ? {} : { runBudgetSeconds: snapshot.runBudgetSeconds }),
+			};
+		});
+	}
+}

package/src/index.ts

@@ -10,6 +10,7 @@ import {
 	resolveMaxDetachedCells,
 	resolveRunBudgetSeconds,
 } from "./config/settings.ts";
+import { registerEvalCellsRpc } from "./extension/eval-cells-rpc.ts";
 import { type EvalNotificationContent, EvalNotifier } from "./extension/eval-notifier.ts";
 import { EVAL_CELLS_STATUS_KEY } from "./extension/eval-status.ts";
 import { EvalStatusTicker } from "./extension/eval-status-ticker.ts";
@@ -63,7 +64,10 @@ export interface CodemodeExtensionAPI {
 	/** Optional host event bus; a host without one turns extension event emission into a harmless no-op. */
 	events?: { emit(name: string, data: unknown): void };
 	/** Optional host RPC surface for forwarding extension-owned events to connected clients. */
-	rpc?: { emit(name: string, data: unknown): void };
+	rpc?: {
+		emit(name: string, data: unknown): void;
+		handle?(name: string, handler: (data: unknown) => unknown | Promise<unknown>): void;
+	};
 }
 
 export interface SenpiCodemodeOptions {
@@ -94,6 +98,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 	let activeContext: ExtensionContext | undefined;
 	let activeCells: EvalDetachedCellManager | undefined;
 	let activeHandles: HandleRegistry | undefined;
+	registerEvalCellsRpc(pi.rpc, () => activeCells);
 	let promptPreludeDocs = "";
 	const notifier = new EvalNotifier({
 		sendMessage: (message, notifyOptions) => pi.sendMessage(message, notifyOptions),

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

@@ -35,10 +35,20 @@ export type {
 	EvalDetachedCellStatusEntry,
 } from "./detached-cell-contract.ts";
 
+export class EvalCellNotFoundError extends Error {
+	readonly code = "eval_cell_not_found";
+
+	constructor(cellId: string) {
+		super(`Unknown detached eval cell "${cellId}"`);
+		this.name = "EvalCellNotFoundError";
+	}
+}
+
 export class EvalDetachedCellManager {
 	readonly #onStatusChange: ((entries: readonly EvalDetachedCellStatusEntry[]) => void) | undefined;
 	readonly #onWakeSourceState: ((state: WakeSourceState) => void) | undefined;
 	readonly #cells = new Map<string, ManagedCell>();
+	readonly #interrupting = new Map<string, ManagedCell>();
 	readonly #detached = new Map<string, ManagedCell>();
 	readonly #terminalSnapshots: TerminalSnapshotStore;
 	readonly #notificationQueue: DetachedNotificationQueue;
@@ -156,10 +166,11 @@ export class EvalDetachedCellManager {
 	}
 
 	async stop(cellId: string, reason = "Stopped detached eval cell"): Promise<EvalDetachedCellSnapshot> {
-		const live = this.#cells.get(cellId);
+		const live = this.#cells.get(cellId) ?? this.#interrupting.get(cellId);
 		if (live === undefined) return this.#terminal(cellId);
 		if (live.state === "queued") this.#cancelQueued(live, reason);
-		else if (live.detached) await this.#cancel(live, reason);
+		else if (detachedCellIsActive(live.state)) await this.#cancel(live, reason);
+		await live.interruptOutcome?.promise;
 		return this.#snapshot(live);
 	}
 
@@ -273,6 +284,7 @@ export class EvalDetachedCellManager {
 	async #cancel(cell: ManagedCell, reason: string): Promise<void> {
 		const outcome = Promise.withResolvers<void>();
 		cell.interruptOutcome = outcome;
+		this.#interrupting.set(cell.cellId, cell);
 		try {
 			if (!this.#settle(cell, "cancelled", cancelledDetachedResult(cell)) || cell.kernel === undefined) return;
 			const handle = await cell.kernel.interrupt(reason, cell.cellId);
@@ -280,6 +292,7 @@ export class EvalDetachedCellManager {
 			cell.stateRetained = await handle.stateRetained;
 		} finally {
 			outcome.resolve();
+			if (this.#interrupting.get(cell.cellId) === cell) this.#interrupting.delete(cell.cellId);
 			this.#refreshTerminalSnapshot(cell);
 		}
 	}
@@ -304,7 +317,7 @@ export class EvalDetachedCellManager {
 
 	#terminal(cellId: string): EvalDetachedCellSnapshot {
 		const snapshot = this.#terminalSnapshots.get(cellId);
-		if (snapshot === undefined) throw new Error(`Unknown detached eval cell "${cellId}"`);
+		if (snapshot === undefined) throw new EvalCellNotFoundError(cellId);
 		return snapshot;
 	}
 }

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

@@ -36,10 +36,9 @@ export async function executeEvalControl(
 	return createDetachedControlResult(snapshot);
 }
 
-function createEvalListResult(cellManager: EvalDetachedCellManager): AgentToolResult<EvalListDetails> {
+export function listEvalCells(cellManager: EvalDetachedCellManager): EvalListedCell[] {
 	const { live, recent } = cellManager.list();
-	const snapshots = [...live, ...recent];
-	const cells: EvalListedCell[] = snapshots.map((snapshot) => {
+	return [...live, ...recent].map((snapshot) => {
 		const summary = snapshot.result.details.summary;
 		return {
 			cellId: snapshot.cellId,
@@ -50,6 +49,12 @@ function createEvalListResult(cellManager: EvalDetachedCellManager): AgentToolRe
 			...(summary ? { summary } : {}),
 		};
 	});
+}
+
+function createEvalListResult(cellManager: EvalDetachedCellManager): AgentToolResult<EvalListDetails> {
+	const { live, recent } = cellManager.list();
+	const snapshots = [...live, ...recent];
+	const cells = listEvalCells(cellManager);
 	const text = snapshots
 		.map((snapshot, index) => {
 			const cell = cells[index];