@code-yeongyu/senpi 2026.9.21-2 → 2026.9.22-2

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-tool.ts

@@ -1,8 +1,13 @@
-import type { ToolDefinition } from "@code-yeongyu/senpi";
-import { DEFAULT_FOREGROUND_WINDOW_SECONDS } from "../config/settings.ts";
+import type { AgentToolResult, ToolDefinition } from "@code-yeongyu/senpi";
+import type { TUnsafe } from "typebox";
+import {
+	DEFAULT_FOREGROUND_WINDOW_SECONDS,
+	defaultCodemodeSettings,
+	resolveMaxDetachedCells,
+} from "../config/settings.ts";
 import { buildEvalPrompt } from "../prompt/eval-prompt.ts";
 import { EvalDetachedCellManager } from "./detached-cell-manager.ts";
-import { detachedKernelBusyError, executeEvalControl } from "./detached-eval-result.ts";
+import { executeEvalControl } from "./detached-eval-result.ts";
 import { clampEvalSummary, isEvalControlRequest, parseEvalRequest } from "./eval-request.ts";
 import type { CreateEvalToolOptions } from "./eval-tool-options.ts";
 import { runEvalCell } from "./run-eval-cell.ts";
@@ -10,6 +15,9 @@ import {
 	createEvalInputSchema,
 	defaultEvalDeadlineSeconds,
 	type EvalInputSchema,
+	type EvalListDetails,
+	type EvalListInput,
+	type EvalResultDetails,
 	type EvalToolDetails,
 	type EvalToolRequest,
 	enabledLanguageList,
@@ -19,8 +27,16 @@ export type { EvalTimeoutFactory } from "./cell-execution.ts";
 export type { CreateEvalToolOptions } from "./eval-tool-options.ts";
 export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./types.ts";
 
-export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<EvalInputSchema, EvalToolDetails> {
+type EvalExecuteArgs<Request extends EvalToolRequest> = Parameters<
+	ToolDefinition<TUnsafe<Request>, EvalToolDetails>["execute"]
+>;
+
+export function createEvalTool(options: CreateEvalToolOptions) {
 	const foregroundWindowSeconds = options.foregroundWindowSeconds ?? DEFAULT_FOREGROUND_WINDOW_SECONDS;
+	const maxDetachedCells =
+		options.cellManager?.maxDetachedCells ??
+		options.maxDetachedCells ??
+		resolveMaxDetachedCells(options.settings ?? defaultCodemodeSettings);
 	const deadlines = {
 		runBudgetSeconds: options.runBudgetSeconds ?? defaultEvalDeadlineSeconds.runBudgetSeconds,
 		detachAfterSeconds: Math.min(options.cellTimeoutSeconds, foregroundWindowSeconds),
@@ -31,6 +47,7 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 	const prompt = buildEvalPrompt(options.enabledLanguages, {
 		spawns: options.spawns ?? false,
 		monitor: options.monitor,
+		maxDetachedCells,
 		runBudgetSeconds: deadlines.runBudgetSeconds,
 		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
 		...(options.modelId === undefined ? {} : { modelId: options.modelId }),
@@ -42,10 +59,43 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 	const cellManager =
 		options.cellManager ??
 		new EvalDetachedCellManager({
+			maxDetachedCells,
 			...(options.artifactsDir === undefined ? {} : { artifactsDir: options.artifactsDir }),
 			...(options.hardLimitSeconds === undefined ? {} : { hardLimitSeconds: options.hardLimitSeconds }),
 			...(options.runBudgetSeconds === undefined ? {} : { runBudgetSeconds: options.runBudgetSeconds }),
 		});
+	// Keep run/peek/stop results typed as execution details; list has no single language or output cell.
+	function execute(
+		...args: EvalExecuteArgs<Exclude<EvalToolRequest, EvalListInput>>
+	): Promise<AgentToolResult<EvalToolDetails>>;
+	function execute(...args: EvalExecuteArgs<EvalListInput>): Promise<AgentToolResult<EvalListDetails>>;
+	function execute(...args: EvalExecuteArgs<EvalToolRequest>): Promise<AgentToolResult<EvalResultDetails>>;
+	async function execute(
+		...[toolCallId, params, signal, onUpdate, ctx]: EvalExecuteArgs<EvalToolRequest>
+	): Promise<AgentToolResult<EvalResultDetails>> {
+		const request = parseEvalRequest(params);
+		if (isEvalControlRequest(request)) return await executeEvalControl(cellManager, request);
+		if (options.proxyExecutor) return await options.proxyExecutor(request, signal);
+		if (!languages.includes(request.language))
+			throw new RangeError(
+				`Unsupported eval language "${request.language}". Enabled languages: ${languages.join(", ")}`,
+			);
+		options.executionTracker?.assertEvalExecutionAllowed();
+		const lifecycleController = new AbortController();
+		const combinedSignal = signal
+			? AbortSignal.any([signal, lifecycleController.signal])
+			: lifecycleController.signal;
+		const execution = runEvalCell(options, cellManager, {
+			cellId: toolCallId,
+			input: request,
+			signal: combinedSignal,
+			onUpdate,
+			ctx,
+		});
+		return options.executionTracker
+			? await options.executionTracker.trackEvalExecution(execution, lifecycleController)
+			: await execution;
+	}
 	return {
 		name: "eval",
 		label: "Eval",
@@ -57,7 +107,8 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 		prepareArguments: (args) => {
 			if (typeof args !== "object" || args === null) return args as EvalToolRequest;
 			const record = args as Record<string, unknown>;
-			if (record.action === "peek" || record.action === "stop") return args as EvalToolRequest;
+			if (record.action === "peek" || record.action === "stop" || record.action === "list")
+				return args as EvalToolRequest;
 			const summary = clampEvalSummary(record.summary);
 			if (summary === undefined) delete record.summary;
 			else record.summary = summary;
@@ -65,36 +116,6 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 		},
 		...(options.renderers?.renderCall === undefined ? {} : { renderCall: options.renderers.renderCall }),
 		...(options.renderers?.renderResult === undefined ? {} : { renderResult: options.renderers.renderResult }),
-		async execute(toolCallId, params, signal, onUpdate, ctx) {
-			const request = parseEvalRequest(params);
-			if (isEvalControlRequest(request)) return await executeEvalControl(cellManager, request);
-			if (options.proxyExecutor) return await options.proxyExecutor(request, signal);
-			if (!languages.includes(request.language))
-				throw new RangeError(
-					`Unsupported eval language "${request.language}". Enabled languages: ${languages.join(", ")}`,
-				);
-			const busy = cellManager.busyFor(request.language);
-			if (busy !== undefined) {
-				const idleLanguages = languages.filter(
-					(language) => language !== request.language && cellManager.busyFor(language) === undefined,
-				);
-				throw detachedKernelBusyError(busy, idleLanguages);
-			}
-			options.executionTracker?.assertEvalExecutionAllowed();
-			const lifecycleController = new AbortController();
-			const combinedSignal = signal
-				? AbortSignal.any([signal, lifecycleController.signal])
-				: lifecycleController.signal;
-			const execution = runEvalCell(options, cellManager, {
-				cellId: toolCallId,
-				input: request,
-				signal: combinedSignal,
-				onUpdate,
-				ctx,
-			});
-			return options.executionTracker
-				? await options.executionTracker.trackEvalExecution(execution, lifecycleController)
-				: await execution;
-		},
-	};
+		execute,
+	} satisfies ToolDefinition<EvalInputSchema, EvalResultDetails>;
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/managed-cell.ts

@@ -12,7 +12,9 @@ export type ManagedCell = {
 	readonly spillPath: string | undefined;
 	readonly startedAtMs: number;
 	readonly terminal: PromiseWithResolvers<EvalDetachedCellSnapshot>;
-	state: EvalDetachedCellState;
+	state: Exclude<EvalDetachedCellState, "detached">;
+	runStartedAtMs: number | undefined;
+	detached: boolean;
 	canDetach: boolean;
 	wasDetached: boolean;
 	kernel: EvalKernel | undefined;
@@ -47,12 +49,22 @@ export function createManagedCell(init: ManagedCellInit): ManagedCell {
 	// An explicit longer per-call timeout raises the deadline, mirroring bash keeping explicit timeouts.
 	const hardLimitSeconds = Math.max(init.defaultHardLimitSeconds, init.input.timeout ?? 0);
 	const runBudgetSeconds = init.input.timeout ?? init.defaultRunBudgetSeconds;
+	const deadlines = new CellDeadlines({
+		cellId: init.cellId,
+		hardLimitSeconds,
+		runBudgetSeconds,
+		onExpire: (expiry) => init.onExpire(init.cellId, expiry),
+	});
+	// Queue time never consumes execution budget; the submission-time hard limit remains armed.
+	deadlines.pause();
 	return {
 		cellId: init.cellId,
 		input: init.input,
 		spillPath: detachedNotificationSpillPath(init.artifactsDir, init.cellId),
 		startedAtMs: init.now(),
-		state: "running",
+		state: "queued",
+		runStartedAtMs: undefined,
+		detached: false,
 		canDetach: false,
 		wasDetached: false,
 		kernel: undefined,
@@ -62,12 +74,7 @@ export function createManagedCell(init: ManagedCellInit): ManagedCell {
 		liveResult: undefined,
 		terminalResult: undefined,
 		notificationQueued: false,
-		deadlines: new CellDeadlines({
-			cellId: init.cellId,
-			hardLimitSeconds,
-			runBudgetSeconds,
-			onExpire: (expiry) => init.onExpire(init.cellId, expiry),
-		}),
+		deadlines,
 		hardLimitSeconds,
 		runBudgetSeconds,
 		hardLimited: false,

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/render.ts

@@ -10,6 +10,7 @@ import {
 	truncateToVisualLines,
 } from "@code-yeongyu/senpi";
 import { formatTruncationWarning, stripOutputNotice, type TruncationMeta } from "../output/output-meta.ts";
+import { clampEvalSummary } from "./eval-request.ts";
 import {
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
@@ -25,13 +26,14 @@ import type {
 	EvalCellResult,
 	EvalInputSchema,
 	EvalLanguage,
+	EvalResultDetails,
 	EvalStatusEvent,
 	EvalToolDetails,
 	EvalToolInput,
 	EvalToolRequest,
 } from "./types.ts";
 
-type EvalToolDefinition = ToolDefinition<EvalInputSchema, EvalToolDetails>;
+type EvalToolDefinition = ToolDefinition<EvalInputSchema, EvalResultDetails>;
 type RenderContext = Parameters<NonNullable<EvalToolDefinition["renderCall"]>>[2];
 type ResultRenderContext = Parameters<NonNullable<EvalToolDefinition["renderResult"]>>[3];
 type CollapsibleKind = "code" | "output";
@@ -301,6 +303,8 @@ function cellPresentation(status: CellStatus, spinnerFrame: number | undefined):
 	switch (status) {
 		case "pending":
 			return { label: "pending", icon: "○", color: "muted" };
+		case "queued":
+			return { label: "queued", icon: "○", color: "muted" };
 		case "running":
 			return { label: "running", icon: spinner(spinnerFrame), color: "warning" };
 		case "detached":
@@ -337,6 +341,8 @@ function cellHeader(cell: EvalCellResult, environment: RenderEnvironment, badges
 	const presentation = cellPresentation(cell.status, environment.spinnerFrame);
 	const runtimeBadge = cell.runtime === undefined ? "" : ` (${formatRuntimeBadge(cell.language, cell.runtime)})`;
 	let header = `eval ${cell.language}${runtimeBadge} ${presentation.label} ${presentation.icon}`;
+	if (cell.queuedBehind !== undefined && cell.queuedBehind.length > 0)
+		header += ` · queued behind ${cell.queuedBehind.map(sanitizeTerminalLabel).join(", ")}`;
 	const throughputBadge = badges.throughput === undefined ? undefined : formatThroughputBadge(badges.throughput);
 	if (throughputBadge !== undefined) header += ` · ${throughputBadge}`;
 	const elapsedMs = badges.throughput?.wallDurationMs ?? cellElapsedMs(cell, environment);
@@ -706,7 +712,7 @@ function renderJsonOutputs(values: readonly unknown[], environment: RenderEnviro
 
 function renderDetailedLines(
 	details: EvalToolDetails,
-	result: AgentToolResult<EvalToolDetails>,
+	result: AgentToolResult<EvalResultDetails>,
 	context: DetailedRenderContext,
 ): string[] {
 	const lines: string[] = [];
@@ -765,7 +771,7 @@ function renderDetailedLines(
 	return lines;
 }
 
-function textOutput(result: AgentToolResult<EvalToolDetails>, showImageFallback: boolean): string {
+function textOutput(result: AgentToolResult<EvalResultDetails>, showImageFallback: boolean): string {
 	const lines: string[] = [];
 	for (const part of result.content) {
 		if (part.type === "text") lines.push(part.text);
@@ -777,7 +783,7 @@ function textOutput(result: AgentToolResult<EvalToolDetails>, showImageFallback:
 }
 
 function isEvalRunInput(args: EvalToolRequest): args is EvalToolInput {
-	return args.action !== "peek" && args.action !== "stop";
+	return args.action === undefined || args.action === "run";
 }
 
 function toolCallRows(details: EvalToolDetails | undefined): ToolCallRow[] {
@@ -878,6 +884,13 @@ function resultMetadata(
 	return [{ kind: "text", text: style(theme, "muted", metadata.join(" | ")) }];
 }
 
+// The call renderer reads the assistant message's raw arguments, which now keep the provider's
+// original summary (senpi#1472 detached preparation from the message). The advertised display
+// limit is enforced here instead, idempotently: an already-clamped value is returned unchanged.
+function displaySummary(summary: string | undefined): string | undefined {
+	return clampEvalSummary(summary);
+}
+
 export function renderEvalCall(
 	args: EvalToolRequest,
 	theme: Theme | undefined,
@@ -891,7 +904,8 @@ export function renderEvalCall(
 		return component;
 	}
 	if (!isEvalRunInput(args)) {
-		component.setBlocks([{ kind: "text", text: style(theme, "toolTitle", `eval ${args.action} ${args.cell_id}`) }]);
+		const title = args.action === "list" ? "eval list" : `eval ${args.action} ${args.cell_id}`;
+		component.setBlocks([{ kind: "text", text: style(theme, "toolTitle", title) }]);
 		return component;
 	}
 	if (theme === undefined && context.spinnerFrame === undefined) {
@@ -899,7 +913,9 @@ export function renderEvalCall(
 		const timeout = args.timeout === undefined ? "" : ` timeout ${args.timeout}s`;
 		component.setBlocks([
 			{ kind: "text", text: style(theme, "toolTitle", `eval ${args.language}${reset}${timeout}`) },
-			...(args.summary === undefined ? [] : [{ kind: "text" as const, text: style(theme, "muted", args.summary) }]),
+			...(displaySummary(args.summary) === undefined
+				? []
+				: [{ kind: "text" as const, text: style(theme, "muted", displaySummary(args.summary) ?? "") }]),
 			{
 				kind: "text",
 				text: style(theme, "mdCodeBlock", args.code.trim().length > 0 ? args.code : "..."),
@@ -924,7 +940,7 @@ export function renderEvalCall(
 				};
 				const cell: EvalCellResult = {
 					index: 0,
-					...(args.summary === undefined ? {} : { summary: args.summary }),
+					...(displaySummary(args.summary) === undefined ? {} : { summary: displaySummary(args.summary) ?? "" }),
 					code: args.code,
 					language: args.language,
 					output: "",
@@ -942,13 +958,21 @@ export function renderEvalCall(
 }
 
 export function renderEvalResult(
-	result: AgentToolResult<EvalToolDetails>,
+	result: AgentToolResult<EvalResultDetails>,
 	options: ToolRenderResultOptions,
 	theme: Theme | undefined,
 	context: ResultRenderContext,
 ): EvalRenderComponent {
 	const component = componentFor(context);
 	const details = result.details;
+	if (details && "action" in details) {
+		component.syncLiveTicker(false, context.invalidate);
+		component.setBlocks([
+			{ kind: "text", text: style(theme, "toolTitle", "eval list") },
+			{ kind: "text", text: style(theme, "toolOutput", textOutput(result, false)) },
+		]);
+		return component;
+	}
 	const expanded = options.expanded || context.expanded;
 	const imageProtocol = context.imageProtocol ?? null;
 	component.syncLiveTicker(hasLiveCell(details), context.invalidate);

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/run-eval-cell.ts

@@ -6,6 +6,7 @@ import {
 	type ExtensionKernelTools,
 	kernelToolsStorage,
 } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } from "../config/settings.ts";
 import {
 	KERNEL_TOOLS_CAPABILITIES,
@@ -16,8 +17,9 @@ import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.
 import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-execution.ts";
 import { CellHandler, type CellState } from "./cell-handler.ts";
 import type { EvalDetachedCellManager } from "./detached-cell-manager.ts";
-import { resultAfterDetach } from "./detached-eval-result.ts";
+import { EvalBackgroundCapacityError, resultAfterDetach, resultForDetachedState } from "./detached-eval-result.ts";
 import { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from "./eval-execution-event.ts";
+import { EvalKernelResetRefusedError } from "./eval-kernel-reset-refused-error.ts";
 import { evalTimeoutBehavior } from "./eval-request.ts";
 import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
 import { describeTimeoutState } from "./interrupt-note.ts";
@@ -54,7 +56,7 @@ export async function runEvalCell(
 		phase: undefined,
 		error: undefined,
 		durationMs: 0,
-		status: "pending",
+		status: "queued",
 	};
 	let detached = false;
 	let execution: CellExecution;
@@ -65,6 +67,24 @@ export async function runEvalCell(
 		execution.detach();
 		return true;
 	};
+	const cancelAtCapacity = (idleError: Error): void => {
+		const liveCells = cellManager.liveCells(undefined, { except: invocation.cellId });
+		if (
+			!cell.canDetach &&
+			liveCells.filter((live) => live.state === "detached").length < cellManager.maxDetachedCells
+		) {
+			execution.cancel(idleError);
+			return;
+		}
+		execution.cancel(
+			new EvalBackgroundCapacityError(
+				cellManager.maxDetachedCells,
+				invocation.cellId,
+				Date.now() - state.startedAt,
+				liveCells.map((live) => live.cellId),
+			),
+		);
+	};
 	execution = new CellExecution({
 		callerSignal: invocation.signal,
 		cellId: invocation.cellId,
@@ -74,7 +94,13 @@ export async function runEvalCell(
 						timeoutMs: detachAfterMs,
 						maxPauseGraceMs: foregroundWindowMs,
 						onTimeout: (error: Error) => {
-							if (!detach()) execution.cancel(error);
+							if (detach()) return;
+							const remainingMs = foregroundWindowMs - (Date.now() - state.startedAt);
+							if (remainingMs <= 0) cancelAtCapacity(error);
+							else
+								execution.rearmIdle(remainingMs, () => {
+									if (!detach()) cancelAtCapacity(error);
+								});
 						},
 					},
 				}
@@ -116,6 +142,7 @@ export async function runEvalCell(
 				state,
 				outcome,
 				completedAt: Date.now(),
+				queuedMs: Math.max(0, (cell.runStartedAtMs ?? Date.now()) - cell.startedAtMs),
 				detached,
 			}),
 		);
@@ -137,7 +164,12 @@ export async function runEvalCell(
 			finalized.then((result) => ({ kind: "result" as const, result })),
 			execution.detached.then(() => ({ kind: "detached" as const })),
 		]);
-		if (outcome.kind === "detached") return resultAfterDetach(cellManager.peek(invocation.cellId), invocation.input);
+		if (outcome.kind === "detached")
+			return resultAfterDetach(
+				cellManager.peek(invocation.cellId),
+				invocation.input,
+				cellManager.liveCells(undefined, { except: invocation.cellId }).length,
+			);
 		return outcome.result;
 	} finally {
 		steeringSignal?.removeEventListener("abort", onSteering);
@@ -157,30 +189,30 @@ async function executeCell(
 ): Promise<AgentToolResult<EvalToolDetails>> {
 	let handler: CellHandler | undefined;
 	try {
-		const kernel = await execution.wait(
-			options.kernelManager.getKernel(invocation.input.language, (message) => {
-				if (!state.active || handler === undefined) return;
-				if (message.type === "status") {
-					if (message.event.op === TIMEOUT_PAUSE_OP) {
-						execution.pause();
-						cellManager.pause(cell);
-						return;
-					}
-					if (message.event.op === TIMEOUT_RESUME_OP) {
-						execution.resume();
-						cellManager.resume(cell);
-						return;
-					}
+		const onMessage = (message: KernelToHostMessage): void => {
+			if (!state.active || handler === undefined) return;
+			if (message.type === "status") {
+				if (message.event.op === TIMEOUT_PAUSE_OP) {
+					execution.pause();
+					cellManager.pause(cell);
+					return;
 				}
-				const pending = handler.handle(message);
-				void pending.catch((error: unknown) => execution.cancel(error));
-			}),
-		);
+				if (message.event.op === TIMEOUT_RESUME_OP) {
+					execution.resume();
+					cellManager.resume(cell);
+					return;
+				}
+			}
+			const pending = handler.handle(message);
+			void pending.catch((error: unknown) => execution.cancel(error));
+		};
+		const kernel = await execution.wait(options.kernelManager.getKernel(invocation.input.language, onMessage));
 		// Computed before the handler so the cell's capability can be entered per host tool call from the
 		// worker's message loop, which runs outside the `kernelToolsStorage.run` context below (#1754).
 		const kernelTools = jsKernelTools(kernel, invocation.input.language);
 		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
-			execution.setKernel(kernel);
+			const queue = kernel.queueSnapshot();
+			state.queuedBehind = [...(queue.activeCellId === null ? [] : [queue.activeCellId]), ...queue.queuedCellIds];
 			const activeHandler = new CellHandler(kernel, state, {
 				executeTool: options.executeTool,
 				...(options.listTools === undefined ? {} : { listTools: options.listTools }),
@@ -194,25 +226,57 @@ async function executeCell(
 				...(kernelTools === undefined ? {} : { kernelTools }),
 			});
 			handler = activeHandler;
-			cellManager.markRunning(
+			cellManager.bindKernel(
 				cell,
 				kernel,
 				() => activeHandler.liveResult(),
 				(error) => execution.cancel(error),
 			);
+			if (invocation.input.reset) {
+				const liveCells = cellManager.liveCells(invocation.input.language, { except: invocation.cellId });
+				if (liveCells.length > 0)
+					throw new EvalKernelResetRefusedError(
+						invocation.input.language,
+						liveCells.map((live) => live.cellId),
+					);
+			}
 			// Includes a steer already queued at execute start or received while acquiring the kernel.
 			onReady();
 			if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
 				options.kernelManager.setContext(bridgeContext);
 			}
 			if (invocation.input.reset) await execution.wait(kernel.reset());
-			const result = await execution.wait(kernel.run({ cellId: invocation.cellId, code: invocation.input.code }));
+			execution.setKernel(kernel);
+			const result = await execution.wait(
+				kernel.run({
+					cellId: invocation.cellId,
+					code: invocation.input.code,
+					onMessage,
+					onStarted: () => {
+						cellManager.markRunning(cell);
+						state.runStartedAt = cell.runStartedAtMs;
+						state.status = "running";
+						state.queuedBehind = undefined;
+						state.onUpdate?.(activeHandler.liveResult());
+					},
+				}),
+			);
 			if (result.ok && state.pendingBridgeCalls.length > 0)
 				await execution.wait(Promise.all(state.pendingBridgeCalls));
 			return await handler.finalize(result);
 		};
 		return kernelTools ? await kernelToolsStorage.run(kernelTools, runBound) : await runBound();
 	} catch (error) {
+		if (error instanceof EvalBackgroundCapacityError) {
+			const final = handler
+				? await handler.finalizeCancellation(error)
+				: {
+						content: [{ type: "text" as const, text: error.message }],
+						details: cellManager.peek(invocation.cellId).result.details,
+					};
+			const result = resultForDetachedState(final, "cancelled", state.durationMs);
+			return { ...result, details: { ...result.details, isError: true, code: error.code } };
+		}
 		if (handler && error instanceof Error && error.name === "CodemodeSessionDisposedError")
 			return await handler.finalizeCancellation(error);
 		if (error instanceof Error && error.name === "TimeoutError") throw await describeTimeoutState(error, execution);

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/terminal-snapshot-store.ts

@@ -29,6 +29,10 @@ export class TerminalSnapshotStore {
 		this.#snapshots.delete(cellId);
 	}
 
+	list(): readonly EvalDetachedCellSnapshot[] {
+		return [...this.#snapshots.values()];
+	}
+
 	clear(): void {
 		this.#snapshots.clear();
 	}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/types.ts

@@ -54,18 +54,25 @@ export interface EvalToolInput {
 	readonly reset?: boolean;
 }
 
-export interface EvalControlInput {
-	readonly action: "peek" | "stop";
-	readonly cell_id: string;
+export interface EvalListInput {
+	readonly action: "list";
 }
 
+export type EvalControlInput =
+	| EvalListInput
+	| {
+			readonly action: "peek" | "stop";
+			readonly cell_id: string;
+	  };
+
 export type EvalToolRequest = EvalToolInput | EvalControlInput;
 
 function evalInputProperties<Language extends TSchema>(languageSchema: Language, deadlines: EvalDeadlineSeconds) {
 	return {
 		action: Type.Optional(
-			Type.Union([Type.Literal("run"), Type.Literal("peek"), Type.Literal("stop")], {
-				description: "Defaults to run. peek and stop require cell_id.",
+			Type.Union([Type.Literal("run"), Type.Literal("peek"), Type.Literal("stop"), Type.Literal("list")], {
+				description:
+					"Defaults to run. peek and stop require cell_id. list: live and recently settled cells across languages.",
 			}),
 		),
 		language: Type.Optional(languageSchema),
@@ -83,8 +90,12 @@ function evalInputProperties<Language extends TSchema>(languageSchema: Language,
 				description: onTimeoutFieldDescription(deadlines),
 			}),
 		),
-		reset: Type.Optional(Type.Boolean({ description: "Reset this language kernel before running." })),
-		cell_id: Type.Optional(Type.String({ description: "Detached eval cell id for peek or stop." })),
+		reset: Type.Optional(
+			Type.Boolean({
+				description: "Reset this language kernel before running; refused while that language has live cells.",
+			}),
+		),
+		cell_id: Type.Optional(Type.String({ minLength: 1, description: "Eval cell id for peek or stop." })),
 	};
 }
 
@@ -108,7 +119,14 @@ export function createEvalInputSchema(
 		languages.length === 1
 			? Type.Union([Type.Literal(languages[0])])
 			: Type.Union(languages.map((item) => Type.Literal(item)));
-	return Type.Unsafe<EvalToolRequest>(Type.Object(evalInputProperties(languageSchema, deadlines))) as EvalInputSchema;
+	return Type.Unsafe<EvalToolRequest>(
+		Type.Object(evalInputProperties(languageSchema, deadlines), {
+			anyOf: [
+				{ properties: { action: { enum: ["run", "list"] } } },
+				{ properties: { action: { enum: ["peek", "stop"] } }, required: ["action", "cell_id"] },
+			],
+		}),
+	) as EvalInputSchema;
 }
 export type EvalKernelResult = Extract<KernelToHostMessage, { type: "result" }>;
 export type EvalToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
@@ -117,6 +135,8 @@ export interface EvalKernelRunInput {
 	readonly cellId: string;
 	readonly code: string;
 	readonly timeoutMs?: number;
+	readonly onStarted?: () => void;
+	readonly onMessage?: (message: KernelToHostMessage) => void;
 }
 
 export interface KernelInterruptHandle {
@@ -128,7 +148,9 @@ export interface KernelInterruptHandle {
 
 export interface EvalKernel {
 	run(input: EvalKernelRunInput): Promise<EvalKernelResult>;
-	interrupt(reason?: string): Promise<KernelInterruptHandle>;
+	cancelQueued(cellId: string, reason: string): boolean;
+	interrupt(reason?: string, cellId?: string): Promise<KernelInterruptHandle>;
+	queueSnapshot(): { activeCellId: string | null; queuedCellIds: readonly string[] };
 	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void;
 	reset(): Promise<void>;
 	close(): Promise<void>;
@@ -182,7 +204,8 @@ export type EvalCellResult = {
 	readonly language: EvalLanguage;
 	readonly output: string;
 	readonly runtime?: EvalRuntimeInfo;
-	readonly status: "pending" | "running" | "detached" | "complete" | "error" | "cancelled";
+	readonly status: "pending" | "queued" | "running" | "detached" | "complete" | "error" | "cancelled";
+	readonly queuedBehind?: readonly string[];
 	readonly exitCode?: number;
 	readonly durationMs?: number;
 	/** Epoch ms when the cell started; lets renderers tick elapsed time between update events. */
@@ -191,6 +214,22 @@ export type EvalCellResult = {
 	readonly hasMarkdown?: boolean;
 };
 
+export interface EvalListedCell {
+	readonly cellId: string;
+	readonly language: EvalLanguage;
+	readonly state: "queued" | "running" | "detached" | "completed" | "failed" | "cancelled";
+	readonly startedAtMs: number;
+	readonly queuedBehind?: readonly string[];
+	readonly summary?: string;
+}
+
+export interface EvalListDetails {
+	readonly action: "list";
+	readonly cells: readonly EvalListedCell[];
+}
+
+export type EvalResultDetails = EvalToolDetails | EvalListDetails;
+
 export interface EvalToolDetails {
 	readonly language: EvalLanguage;
 	readonly languages?: readonly EvalLanguage[];
@@ -204,6 +243,8 @@ export interface EvalToolDetails {
 	readonly toolCalls: readonly EvalToolCallSummary[];
 	readonly truncated: boolean;
 	readonly isError?: boolean;
+	/** Machine-readable reason for a tool-boundary cancellation. */
+	readonly code?: string;
 	readonly phase?: string;
 	readonly cells?: readonly EvalCellResult[];
 	readonly statusEvents?: readonly EvalStatusEvent[];

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.d.ts

@@ -3,6 +3,7 @@
  * Transforms to Message[] only at the LLM call boundary.
  */
 import { type Context, EventStream } from "@earendil-works/pi-ai";
+import { prepareAgentToolCallArguments } from "./tool-arguments.ts";
 import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, AgentTool, AgentToolCall, StreamFn } from "./types.ts";
 export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
 /**
@@ -31,6 +32,6 @@ export interface PreparedAgentToolCall {
     tool: AgentTool;
     args: unknown;
 }
-export declare function prepareAgentToolCallArguments(tool: AgentTool, toolCall: AgentToolCall): AgentToolCall;
+export { prepareAgentToolCallArguments };
 export declare function prepareAgentToolCall(tool: AgentTool, toolCall: AgentToolCall): PreparedAgentToolCall;
 //# sourceMappingURL=agent-loop.d.ts.map