@code-yeongyu/senpi 2026.9.21-2 → 2026.9.22

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

@@ -1,5 +1,9 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
-import { DEFAULT_HARD_LIMIT_SECONDS, DEFAULT_RUN_BUDGET_SECONDS } from "../config/settings.ts";
+import {
+	DEFAULT_HARD_LIMIT_SECONDS,
+	DEFAULT_MAX_DETACHED_CELLS,
+	DEFAULT_RUN_BUDGET_SECONDS,
+} from "../config/settings.ts";
 import type { WakeSourceState } from "../extension/wake-source-state.ts";
 import type { CellDeadlineExpiry } from "./cell-deadlines.ts";
 import type {
@@ -33,12 +37,13 @@ export class EvalDetachedCellManager {
 	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 #detached = new Map<string, ManagedCell>();
 	readonly #terminalSnapshots = new TerminalSnapshotStore();
 	readonly #notificationQueue: DetachedNotificationQueue;
 	readonly #now: () => number;
 	readonly #hardLimitSeconds: number;
 	readonly #runBudgetSeconds: number;
+	readonly #maxDetachedCells: number;
 
 	constructor(options: EvalDetachedCellManagerOptions = {}) {
 		this.#artifactsDir = options.artifactsDir;
@@ -48,6 +53,11 @@ export class EvalDetachedCellManager {
 		this.#now = options.now ?? Date.now;
 		this.#hardLimitSeconds = options.hardLimitSeconds ?? DEFAULT_HARD_LIMIT_SECONDS;
 		this.#runBudgetSeconds = options.runBudgetSeconds ?? DEFAULT_RUN_BUDGET_SECONDS;
+		this.#maxDetachedCells = options.maxDetachedCells ?? DEFAULT_MAX_DETACHED_CELLS;
+	}
+
+	get maxDetachedCells(): number {
+		return this.#maxDetachedCells;
 	}
 
 	create(cellId: string, input: EvalToolInput, onKill?: (error: Error) => void): ManagedCell {
@@ -74,19 +84,27 @@ export class EvalDetachedCellManager {
 		return cell;
 	}
 
-	markRunning(
+	bindKernel(
 		cell: ManagedCell,
 		kernel: EvalKernel,
 		liveResult: LiveResultProvider,
 		onKill?: (error: Error) => void,
 	): void {
-		if (cell.state !== "running") return;
+		if (!detachedCellIsActive(cell.state)) return;
 		cell.onKill = onKill ?? cell.onKill;
 		cell.kernel = kernel;
 		cell.liveResult = liveResult;
 		cell.canDetach = true;
 	}
 
+	markRunning(cell: ManagedCell): void {
+		if (!allowsDetachedCellTransition(cell.state, "running")) return;
+		cell.state = "running";
+		cell.runStartedAtMs = this.#now();
+		cell.deadlines.resume();
+		if (cell.detached) this.#emitStatus();
+	}
+
 	/** A host bridge call is in flight for this cell; its run budget stops charging until {@link resume}. */
 	pause(cell: ManagedCell): void {
 		cell.deadlines.pause();
@@ -99,19 +117,26 @@ export class EvalDetachedCellManager {
 	detach(cell: ManagedCell): boolean {
 		if (
 			!cell.canDetach ||
-			!allowsDetachedCellTransition(cell.state, "detached") ||
-			this.#detachedByLanguage.has(cell.input.language)
+			!detachedCellIsActive(cell.state) ||
+			cell.detached ||
+			!(this.#detached.size < this.#maxDetachedCells)
 		)
 			return false;
-		cell.state = "detached";
+		cell.detached = true;
 		cell.wasDetached = true;
-		this.#detachedByLanguage.set(cell.input.language, cell);
+		this.#detached.set(cell.cellId, cell);
 		this.#emitStatus();
 		return true;
 	}
 
 	complete(cell: ManagedCell, result: AgentToolResult<EvalToolDetails>): boolean {
-		return this.#settle(cell, result.details.isError === true ? "failed" : "completed", result);
+		const state =
+			result.details.cells?.[0]?.status === "cancelled"
+				? "cancelled"
+				: result.details.isError === true
+					? "failed"
+					: "completed";
+		return this.#settle(cell, state, result);
 	}
 
 	fail(cell: ManagedCell, error: Error): boolean {
@@ -121,7 +146,8 @@ export class EvalDetachedCellManager {
 	async stop(cellId: string, reason = "Stopped detached eval cell"): Promise<EvalDetachedCellSnapshot> {
 		const live = this.#cells.get(cellId);
 		if (live === undefined) return this.#terminal(cellId);
-		if (live.state === "detached") await this.#cancel(live, reason);
+		if (live.state === "queued") this.#cancelQueued(live, reason);
+		else if (live.detached) await this.#cancel(live, reason);
 		return this.#snapshot(live);
 	}
 
@@ -130,9 +156,20 @@ export class EvalDetachedCellManager {
 		return live === undefined ? this.#terminal(cellId) : this.#snapshot(live);
 	}
 
-	busyFor(language: EvalLanguage): EvalDetachedCellSnapshot | undefined {
-		const cell = this.#detachedByLanguage.get(language);
-		return cell === undefined ? undefined : this.#snapshot(cell);
+	liveCells(language?: EvalLanguage, opts?: { except?: string }): readonly EvalDetachedCellSnapshot[] {
+		return [...this.#cells.values()]
+			.filter(
+				(cell) =>
+					detachedCellIsActive(cell.state) &&
+					(language === undefined || cell.input.language === language) &&
+					cell.cellId !== opts?.except,
+			)
+			.sort((a, b) => a.startedAtMs - b.startedAtMs)
+			.map((cell) => this.#snapshot(cell));
+	}
+
+	list(): { live: readonly EvalDetachedCellSnapshot[]; recent: readonly EvalDetachedCellSnapshot[] } {
+		return { live: this.liveCells(), recent: this.#terminalSnapshots.list() };
 	}
 
 	async waitForTerminal(cellId: string): Promise<EvalDetachedCellSnapshot> {
@@ -141,7 +178,11 @@ export class EvalDetachedCellManager {
 	}
 
 	async dispose(): Promise<void> {
-		const detached = [...this.#detachedByLanguage.values()];
+		const detached = [...this.#detached.values()];
+		// Dequeue first: interrupting an active run can synchronously start its next waiter.
+		for (const cell of detached) {
+			if (cell.state === "queued") this.#cancelQueued(cell, "Session ended; detached eval cell cancelled");
+		}
 		await Promise.allSettled(
 			detached.map(async (cell) => await this.stop(cell.cellId, "Session ended; detached eval cell cancelled")),
 		);
@@ -157,7 +198,7 @@ export class EvalDetachedCellManager {
 
 	/** Re-publish the current snapshot; consumers reset their per-source counts at session_start. */
 	publishWakeSourceState(): void {
-		this.#emitWakeSourceState([...this.#detachedByLanguage.values()]);
+		this.#emitWakeSourceState([...this.#detached.values()]);
 	}
 
 	#settle(
@@ -174,8 +215,7 @@ export class EvalDetachedCellManager {
 		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);
+			this.#detached.delete(cell.cellId);
 			this.#emitStatus();
 			if (!cell.notificationQueued) {
 				cell.notificationQueued = true;
@@ -197,9 +237,13 @@ export class EvalDetachedCellManager {
 	 */
 	async #expireDeadline(cell: ManagedCell, expiry: CellDeadlineExpiry): Promise<void> {
 		if (!detachedCellIsActive(cell.state)) return;
-		const foreground = cell.state === "running" && cell.onKill !== undefined;
+		const foreground = !cell.detached && cell.onKill !== undefined;
 		cell.hardLimited = expiry.kind === "hard-limit";
 		cell.runBudgetExhausted = expiry.kind === "run-budget";
+		if (cell.state === "queued") {
+			this.#cancelQueued(cell, expiry.error.message, expiry.error);
+			return;
+		}
 		if (foreground) {
 			if (this.#settle(cell, "cancelled", currentDetachedResult(cell))) cell.onKill?.(expiry.error);
 			return;
@@ -207,12 +251,20 @@ export class EvalDetachedCellManager {
 		await this.#cancel(cell, expiry.error.message);
 	}
 
+	#cancelQueued(cell: ManagedCell, reason: string, error = new Error(reason)): void {
+		const dequeued = cell.kernel?.cancelQueued(cell.cellId, reason) ?? false;
+		cell.stateRetained = true;
+		this.#settle(cell, "cancelled", currentDetachedResult(cell));
+		// Acquisition/reset has no queue promise yet; its execution has no interrupt target either.
+		if (!dequeued) cell.onKill?.(error);
+	}
+
 	async #cancel(cell: ManagedCell, reason: string): Promise<void> {
 		const outcome = Promise.withResolvers<void>();
 		cell.interruptOutcome = outcome;
 		try {
 			if (!this.#settle(cell, "cancelled", currentDetachedResult(cell)) || cell.kernel === undefined) return;
-			const handle = await cell.kernel.interrupt(reason);
+			const handle = await cell.kernel.interrupt(reason, cell.cellId);
 			cell.interruptNote = handle.note;
 			cell.stateRetained = await handle.stateRetained;
 		} finally {
@@ -226,7 +278,7 @@ export class EvalDetachedCellManager {
 	}
 
 	#emitStatus(): void {
-		const liveCells = [...this.#detachedByLanguage.values()];
+		const liveCells = [...this.#detached.values()];
 		this.#onStatusChange?.(detachedStatusEntries(liveCells));
 		this.#emitWakeSourceState(liveCells);
 	}

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

@@ -1,12 +1,15 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
 import type { EvalDetachedCellSnapshot, EvalDetachedCellState } from "./detached-cell-manager.ts";
 import { resultForDetachedState } from "./detached-eval-result.ts";
+import { EvalKernelResetRefusedError } from "./eval-kernel-reset-refused-error.ts";
 import type { EvalKernel, EvalToolDetails, EvalToolInput } from "./types.ts";
 
 export interface DetachedCellResultSource {
 	readonly cellId: string;
 	readonly input: EvalToolInput;
 	readonly startedAtMs: number;
+	readonly runStartedAtMs?: number | undefined;
+	readonly detached?: boolean;
 	state: EvalDetachedCellState;
 	kernel: EvalKernel | undefined;
 	stateRetained: boolean | undefined;
@@ -20,12 +23,16 @@ export interface DetachedCellResultSource {
 }
 
 export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: number): EvalDetachedCellSnapshot {
-	const durationMs = Math.max(0, nowMs - cell.startedAtMs);
-	const result = resultForDetachedState(currentDetachedResult(cell), cell.state, durationMs);
+	const durationMs = cell.runStartedAtMs === undefined ? 0 : Math.max(0, nowMs - cell.runStartedAtMs);
+	const state = cell.detached && (cell.state === "queued" || cell.state === "running") ? "detached" : cell.state;
+	const queuedBehind = queuedBehindCell(cell);
+	const result = resultForDetachedState(currentDetachedResult(cell), state, durationMs, queuedBehind);
 	return {
 		cellId: cell.cellId,
 		language: cell.input.language,
-		state: cell.state,
+		startedAtMs: cell.startedAtMs,
+		state,
+		...(queuedBehind === undefined ? {} : { queuedBehind }),
 		outputTail: detachedOutputTail(result),
 		result,
 		stateRetained: cell.stateRetained,
@@ -39,6 +46,19 @@ export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: numb
 	};
 }
 
+export function queuedBehindCell(
+	cell: Pick<DetachedCellResultSource, "state" | "kernel" | "cellId">,
+): readonly string[] | undefined {
+	if (cell.state !== "queued") return undefined;
+	const queue = cell.kernel?.queueSnapshot();
+	if (queue === undefined) return [];
+	const index = queue.queuedCellIds.indexOf(cell.cellId);
+	return [
+		...(queue.activeCellId === null || queue.activeCellId === cell.cellId ? [] : [queue.activeCellId]),
+		...queue.queuedCellIds.slice(0, index < 0 ? undefined : index),
+	];
+}
+
 export function currentDetachedResult(cell: DetachedCellResultSource): AgentToolResult<EvalToolDetails> {
 	return cell.terminalResult ?? cell.liveResult?.() ?? fallbackResult(cell.input);
 }
@@ -54,7 +74,11 @@ export function detachedErrorResult(cell: DetachedCellResultSource, error: Error
 			},
 			...current.content.filter((part) => part.type === "image"),
 		],
-		details: { ...current.details, isError: true },
+		details: {
+			...current.details,
+			isError: true,
+			...(error instanceof EvalKernelResetRefusedError ? { code: error.code } : {}),
+		},
 	};
 }
 

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

@@ -5,20 +5,21 @@ interface DetachedCellIdentity {
 	readonly cellId: string;
 	readonly input: EvalToolInput;
 	readonly state: EvalDetachedCellState;
+	readonly detached?: boolean;
 }
 
 export function activeDetachedCellReuseError(cell: DetachedCellIdentity): Error {
 	return new Error(
-		`Eval cell ${cell.cellId} from a previous call is still ${cell.state} in the ${cell.input.language} kernel. Use eval({ action: "peek", cell_id: "${cell.cellId}" }) to read it or eval({ action: "stop", cell_id: "${cell.cellId}" }) to end it before its id can be reused.`,
+		`Eval cell ${cell.cellId} from a previous call is still ${cell.detached ? "detached" : cell.state} in the ${cell.input.language} kernel. Use eval({ action: "peek", cell_id: "${cell.cellId}" }) to read it or eval({ action: "stop", cell_id: "${cell.cellId}" }) to end it before its id can be reused.`,
 	);
 }
 
 export function allowsDetachedCellTransition(from: EvalDetachedCellState, to: EvalDetachedCellState): boolean {
-	if (from === "running") return to === "detached" || to === "completed" || to === "failed" || to === "cancelled";
-	if (from === "detached") return to === "completed" || to === "failed" || to === "cancelled";
+	if (from === "queued") return to === "running" || to === "failed" || to === "cancelled";
+	if (from === "running") return to === "completed" || to === "failed" || to === "cancelled";
 	return false;
 }
 
 export function detachedCellIsActive(state: EvalDetachedCellState): boolean {
-	return state === "running" || state === "detached";
+	return state === "queued" || state === "running" || state === "detached";
 }

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

@@ -1,5 +1,7 @@
 import { SENPI_CODEMODE_WAKE_SOURCE, type WakeSourceState } from "../extension/wake-source-state.ts";
 import type { EvalDetachedCellStatusEntry } from "./detached-cell-manager.ts";
+import { queuedBehindCell } from "./detached-cell-snapshot.ts";
+import type { ManagedCell } from "./managed-cell.ts";
 
 export interface LiveDetachedCell {
 	readonly cellId: string;
@@ -7,11 +9,12 @@ export interface LiveDetachedCell {
 	readonly input: { readonly language: EvalDetachedCellStatusEntry["language"]; readonly summary?: string };
 }
 
-export function detachedStatusEntries(liveCells: readonly LiveDetachedCell[]): EvalDetachedCellStatusEntry[] {
+export function detachedStatusEntries(liveCells: readonly ManagedCell[]): EvalDetachedCellStatusEntry[] {
 	return liveCells.map((cell) => ({
 		cellId: cell.cellId,
 		language: cell.input.language,
-		startedAtMs: cell.startedAtMs,
+		startedAtMs: cell.runStartedAtMs ?? cell.startedAtMs,
+		...(cell.state === "queued" ? { queuedBehind: queuedBehindCell(cell) } : {}),
 		...(cell.input.summary === undefined ? {} : { summary: cell.input.summary }),
 	}));
 }

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

@@ -5,27 +5,87 @@ import type {
 	EvalDetachedCellState,
 } from "./detached-cell-manager.ts";
 import { interruptionStateNote } from "./interrupt-note.ts";
-import type { EvalCellResult, EvalControlInput, EvalLanguage, EvalToolDetails, EvalToolInput } from "./types.ts";
+import type {
+	EvalCellResult,
+	EvalControlInput,
+	EvalListDetails,
+	EvalListedCell,
+	EvalResultDetails,
+	EvalToolDetails,
+	EvalToolInput,
+} from "./types.ts";
+
+export class EvalBackgroundCapacityError extends Error {
+	readonly code = "eval_background_capacity_reached";
+	readonly name = "EvalBackgroundCapacityError";
+
+	constructor(cap: number, cellId: string, foregroundMs: number, liveCellIds: readonly string[]) {
+		super(
+			`Background capacity (${cap}) reached: cell ${cellId} ran ${Math.floor(foregroundMs / 1_000)}s in the foreground and was cancelled when the foreground window elapsed. Live cells: ${liveCellIds.join(", ")}. Stop one with eval({ action: "stop", cell_id }) or wait for a notification, then re-run this step.`,
+		);
+	}
+}
 
 export async function executeEvalControl(
 	cellManager: EvalDetachedCellManager,
 	request: EvalControlInput,
-): Promise<AgentToolResult<EvalToolDetails>> {
+): Promise<AgentToolResult<EvalResultDetails>> {
+	if (request.action === "list") return createEvalListResult(cellManager);
 	const snapshot =
 		request.action === "stop" ? await cellManager.stop(request.cell_id) : cellManager.peek(request.cell_id);
 	return createDetachedControlResult(snapshot);
 }
 
+function createEvalListResult(cellManager: EvalDetachedCellManager): AgentToolResult<EvalListDetails> {
+	const { live, recent } = cellManager.list();
+	const snapshots = [...live, ...recent];
+	const cells: EvalListedCell[] = snapshots.map((snapshot) => {
+		const summary = snapshot.result.details.summary;
+		return {
+			cellId: snapshot.cellId,
+			language: snapshot.language,
+			state: snapshot.state,
+			startedAtMs: snapshot.startedAtMs,
+			...(snapshot.queuedBehind === undefined || snapshot.queuedBehind.length === 0
+				? {}
+				: { queuedBehind: [...snapshot.queuedBehind] }),
+			...(summary ? { summary } : {}),
+		};
+	});
+	const text = snapshots
+		.map((snapshot, index) => {
+			const cell = cells[index];
+			const preview = (cell.summary || snapshot.result.details.cells?.[0]?.code?.slice(0, 60) || "").replace(
+				/\s+/gu,
+				" ",
+			);
+			const elapsed = Math.floor(snapshot.result.details.durationMs / 1000);
+			const queued = cell.queuedBehind === undefined ? "" : ` queued behind ${cell.queuedBehind.join(", ")}`;
+			return `${cell.cellId} ${cell.language} ${cell.state} ${elapsed}s${queued} - ${preview}`;
+		})
+		.join("\n");
+	return {
+		content: [{ type: "text", text: text || "No eval cells are live; recent: none" }],
+		details: { action: "list", cells },
+	};
+}
+
 export function resultAfterDetach(
 	snapshot: EvalDetachedCellSnapshot,
 	input: EvalToolInput,
+	otherLiveCells: number,
 ): AgentToolResult<EvalToolDetails> {
 	if (snapshot.state !== "detached" && snapshot.state !== "running") return createDetachedControlResult(snapshot);
+	const predecessors = snapshot.queuedBehind?.join(", ");
+	const text =
+		predecessors === undefined
+			? `Eval cell ${snapshot.cellId} detached and is running in the ${input.language} kernel (${otherLiveCells} other live cells). Completion arrives as a notification; do not re-run it. eval({ action: "peek" | "stop", cell_id }) or eval({ action: "list" }).`
+			: `Eval cell ${snapshot.cellId} is queued behind ${predecessors} in the ${input.language} kernel and detached; it runs after ${predecessors} and completes as one notification. peek/stop/list with eval({ action, cell_id })`;
 	return {
 		content: [
 			{
 				type: "text",
-				text: `Eval cell ${snapshot.cellId} detached and is still running in the ${input.language} kernel. Completion will arrive as a notification. Use eval({ action: "peek", cell_id: "${snapshot.cellId}" }) or eval({ action: "stop", cell_id: "${snapshot.cellId}" }).`,
+				text,
 			},
 		],
 		details: snapshot.result.details,
@@ -55,21 +115,23 @@ export function resultForDetachedState(
 	result: AgentToolResult<EvalToolDetails>,
 	state: EvalDetachedCellState,
 	durationMs: number,
+	queuedBehind?: readonly string[],
 ): AgentToolResult<EvalToolDetails> {
 	const details = result.details;
 	const cells = details.cells ?? [];
 	const nextCells =
 		cells.length === 0
 			? []
-			: cells.map((cell, index) =>
-					index === 0
-						? {
-								...cell,
-								durationMs: terminalDuration(cell, state, durationMs),
-								status: cellStatus(state),
-							}
-						: { ...cell },
-				);
+			: cells.map((cell, index) => {
+					if (index !== 0) return { ...cell };
+					const { queuedBehind: _previousQueue, ...current } = cell;
+					return {
+						...current,
+						durationMs: terminalDuration(cell, state, durationMs),
+						status: state === "detached" && queuedBehind !== undefined ? "queued" : cellStatus(state),
+						...(queuedBehind === undefined ? {} : { queuedBehind }),
+					};
+				});
 	return {
 		content: result.content.map((part) => ({ ...part })),
 		details: {
@@ -102,19 +164,6 @@ export function resultForDetachedState(
 	};
 }
 
-export function detachedKernelBusyError(
-	snapshot: EvalDetachedCellSnapshot,
-	idleLanguages: readonly EvalLanguage[] = [],
-): Error {
-	const tail = snapshot.outputTail.length === 0 ? "(no output yet)" : snapshot.outputTail;
-	const peek = `eval({ action: "peek", cell_id: "${snapshot.cellId}" })`;
-	const idleHint =
-		idleLanguages.length === 0 ? "" : ` or continue this step in an idle kernel: ${idleLanguages.join(", ")}`;
-	return new Error(
-		`The ${snapshot.language} eval kernel is busy running detached cell ${snapshot.cellId} - peek with ${peek}${idleHint}. Do not re-run the busy cell. Current output tail:\n${tail}`,
-	);
-}
-
 function textContent(result: AgentToolResult<EvalToolDetails>): string {
 	return result.content
 		.filter((part) => part.type === "text")
@@ -133,6 +182,8 @@ function terminalDuration(
 
 function cellStatus(state: EvalDetachedCellState): EvalCellResult["status"] {
 	switch (state) {
+		case "queued":
+			return "queued";
 		case "running":
 			return "running";
 		case "detached":

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

@@ -30,6 +30,7 @@ interface EvalExecutionBasePayload {
 	readonly completedAt: number;
 	readonly durationMs: number;
 	readonly kernelDurationMs?: number;
+	readonly queued_ms: number;
 	readonly detached: boolean;
 	readonly toolCallCount: number;
 	readonly pendingToolCallCount: number;
@@ -66,6 +67,7 @@ export interface BuildEvalExecutionEventPayloadOptions {
 	readonly state: CellState;
 	readonly outcome: EvalExecutionSettleOutcome;
 	readonly completedAt: number;
+	readonly queuedMs?: number;
 	readonly detached: boolean;
 }
 
@@ -87,6 +89,7 @@ export function buildEvalExecutionEventPayload(
 		startedAt: state.startedAt,
 		completedAt,
 		durationMs: Math.max(0, completedAt - state.startedAt),
+		queued_ms: options.queuedMs ?? 0,
 		...(result === undefined ? {} : { kernelDurationMs: result.details.durationMs }),
 		detached,
 		toolCallCount: state.toolCallMetrics.length,
@@ -110,6 +113,7 @@ export function toEvalExecutionRpcPayload(payload: EvalExecutionEventPayload): E
 		startedAt: payload.startedAt,
 		completedAt: payload.completedAt,
 		durationMs: payload.durationMs,
+		queued_ms: payload.queued_ms,
 		...(payload.kernelDurationMs === undefined ? {} : { kernelDurationMs: payload.kernelDurationMs }),
 		detached: payload.detached,
 		toolCallCount: payload.toolCallCount,

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-kernel-reset-refused-error.ts

@@ -0,0 +1,12 @@
+import type { EvalLanguage } from "./types.ts";
+
+export class EvalKernelResetRefusedError extends Error {
+	readonly name = "EvalKernelResetRefusedError";
+	readonly code = "eval_kernel_busy_reset_refused";
+
+	constructor(language: EvalLanguage, liveCellIds: readonly string[]) {
+		super(
+			`eval_kernel_busy_reset_refused: Cannot reset the ${language} kernel: live cells ${liveCellIds.join(", ")}. Stop them with eval({ action: "stop", cell_id }) or wait for their notifications, then reset.`,
+		);
+	}
+}

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

@@ -18,6 +18,7 @@ export function clampEvalSummary(value: unknown): string | undefined {
 
 export function parseEvalRequest(params: unknown): EvalToolRequest {
 	if (!isRecord(params)) throw new TypeError("eval parameters must be an object");
+	if (params.action === "list") return { action: "list" };
 	if (params.action === "peek" || params.action === "stop") {
 		if (typeof params.cell_id !== "string" || params.cell_id.length === 0)
 			throw new TypeError(`eval action "${params.action}" requires cell_id`);
@@ -46,7 +47,7 @@ export function parseEvalRequest(params: unknown): EvalToolRequest {
 }
 
 export function isEvalControlRequest(request: EvalToolRequest): request is EvalControlInput {
-	return request.action === "peek" || request.action === "stop";
+	return request.action === "peek" || request.action === "stop" || request.action === "list";
 }
 
 export function evalTimeoutBehavior(input: EvalToolInput, ctx: ExtensionContext): "detach" | "error" {

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

@@ -11,6 +11,7 @@ import type {
 	EnabledEvalLanguages,
 	EvalInputSchema,
 	EvalKernelManager,
+	EvalResultDetails,
 	EvalRuntimes,
 	EvalToolDetails,
 	EvalToolInput,
@@ -34,6 +35,7 @@ export interface CreateEvalToolOptions {
 	 * replaces it. Rendered into the tool schema and description; also seeds a self-created manager.
 	 */
 	readonly runBudgetSeconds?: number;
+	readonly maxDetachedCells?: number;
 	readonly executeTool: ExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
@@ -45,7 +47,7 @@ export interface CreateEvalToolOptions {
 	readonly onCellSettled?: (payload: EvalExecutionEventPayload) => void;
 	readonly timeoutFactory?: EvalTimeoutFactory;
 	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;
-	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalToolDetails>, "renderCall" | "renderResult">;
+	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalResultDetails>, "renderCall" | "renderResult">;
 	readonly spawns?: boolean;
 	/** Whether the session registry exposes the monitor tool through eval. */
 	readonly monitor?: boolean;