@code-yeongyu/senpi 2026.9.9 → 2026.9.10

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

@@ -15,6 +15,8 @@ export interface DetachedCellResultSource {
 	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
 	hardLimited?: boolean;
 	hardLimitSeconds?: number;
+	runBudgetExhausted?: boolean;
+	runBudgetSeconds?: number;
 }
 
 export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: number): EvalDetachedCellSnapshot {
@@ -31,6 +33,9 @@ export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: numb
 		...(cell.hardLimited === true && cell.hardLimitSeconds !== undefined
 			? { hardLimitSeconds: cell.hardLimitSeconds }
 			: {}),
+		...(cell.runBudgetExhausted === true && cell.runBudgetSeconds !== undefined
+			? { runBudgetSeconds: cell.runBudgetSeconds }
+			: {}),
 	};
 }
 

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

@@ -20,15 +20,20 @@ import type {
 export interface CreateEvalToolOptions {
 	readonly enabledLanguages: EnabledEvalLanguages;
 	readonly kernelManager: EvalKernelManager;
+	/** Idle time an interactive (detach-behavior) call blocks the agent loop before the cell detaches. */
 	readonly cellTimeoutSeconds: number;
 	/**
-	 * Longest an interactive (detach-behavior) call blocks the agent loop before the cell detaches,
-	 * capping the `timeout` detach budget. Defaults to {@link DEFAULT_FOREGROUND_WINDOW_SECONDS}.
-	 * Does not affect `on_timeout: "error"` calls or the wall-clock hard limit.
+	 * Caps `cellTimeoutSeconds` and the bridge-parked grace for interactive calls. Defaults to
+	 * {@link DEFAULT_FOREGROUND_WINDOW_SECONDS}. Does not affect the kill deadlines.
 	 */
 	readonly foregroundWindowSeconds?: number;
 	/** Wall-clock kill deadline applied to every cell; only used when this factory creates its own manager. */
 	readonly hardLimitSeconds?: number;
+	/**
+	 * Kill deadline for a cell's own execution time (host tool calls excluded); a per-call `timeout`
+	 * replaces it. Rendered into the tool schema and description; also seeds a self-created manager.
+	 */
+	readonly runBudgetSeconds?: number;
 	readonly executeTool: ExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;

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

@@ -1,19 +1,14 @@
-import { randomUUID } from "node:crypto";
-import { join } from "node:path";
-import type { AgentToolResult, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
-import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } from "../config/settings.ts";
+import type { ToolDefinition } from "@code-yeongyu/senpi";
+import { DEFAULT_FOREGROUND_WINDOW_SECONDS } from "../config/settings.ts";
 import { buildEvalPrompt } from "../prompt/eval-prompt.ts";
-import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
-import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-execution.ts";
-import { CellHandler, type CellState } from "./cell-handler.ts";
 import { EvalDetachedCellManager } from "./detached-cell-manager.ts";
-import { detachedKernelBusyError, executeEvalControl, resultAfterDetach } from "./detached-eval-result.ts";
-import { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from "./eval-execution-event.ts";
-import { clampEvalSummary, evalTimeoutBehavior, isEvalControlRequest, parseEvalRequest } from "./eval-request.ts";
-import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
-import { describeTimeoutState } from "./interrupt-note.ts";
+import { detachedKernelBusyError, 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";
 import {
 	createEvalInputSchema,
+	defaultEvalDeadlineSeconds,
 	type EvalInputSchema,
 	type EvalToolDetails,
 	type EvalToolRequest,
@@ -25,10 +20,18 @@ export type { CreateEvalToolOptions } from "./eval-tool-options.ts";
 export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./types.ts";
 
 export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<EvalInputSchema, EvalToolDetails> {
-	const parameters = createEvalInputSchema(options.enabledLanguages);
+	const foregroundWindowSeconds = options.foregroundWindowSeconds ?? DEFAULT_FOREGROUND_WINDOW_SECONDS;
+	const deadlines = {
+		runBudgetSeconds: options.runBudgetSeconds ?? defaultEvalDeadlineSeconds.runBudgetSeconds,
+		detachAfterSeconds: Math.min(options.cellTimeoutSeconds, foregroundWindowSeconds),
+		foregroundWindowSeconds,
+		hardLimitSeconds: options.hardLimitSeconds ?? defaultEvalDeadlineSeconds.hardLimitSeconds,
+	};
+	const parameters = createEvalInputSchema(options.enabledLanguages, deadlines);
 	const prompt = buildEvalPrompt(options.enabledLanguages, {
 		spawns: options.spawns ?? false,
 		monitor: options.monitor,
+		runBudgetSeconds: deadlines.runBudgetSeconds,
 		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
 		...(options.modelId === undefined ? {} : { modelId: options.modelId }),
 		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
@@ -41,6 +44,7 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 		new EvalDetachedCellManager({
 			...(options.artifactsDir === undefined ? {} : { artifactsDir: options.artifactsDir }),
 			...(options.hardLimitSeconds === undefined ? {} : { hardLimitSeconds: options.hardLimitSeconds }),
+			...(options.runBudgetSeconds === undefined ? {} : { runBudgetSeconds: options.runBudgetSeconds }),
 		});
 	return {
 		name: "eval",
@@ -94,177 +98,3 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 		},
 	};
 }
-
-async function runEvalCell(
-	options: CreateEvalToolOptions,
-	cellManager: EvalDetachedCellManager,
-	invocation: EvalCellInvocation,
-): Promise<AgentToolResult<EvalToolDetails>> {
-	if (invocation.signal.aborted) throw abortError(invocation.signal.reason);
-	const timeoutBehavior = evalTimeoutBehavior(invocation.input, invocation.ctx);
-	const requestedTimeoutMs = Math.floor((invocation.input.timeout ?? options.cellTimeoutSeconds) * 1_000);
-	// The `timeout` (and its `cellTimeoutSeconds` default) is the detach budget for interactive calls.
-	// Cap it at the foreground window so a large `timeout` — whose real purpose is to raise the
-	// wall-clock hard limit (see EvalDetachedCellManager) — frees the turn at the window instead of
-	// blocking the agent loop for its full duration. `on_timeout: "error"` (and print/json) keep the
-	// unclamped deadline, since there the cell is killed rather than detached.
-	const foregroundWindowMs = (options.foregroundWindowSeconds ?? DEFAULT_FOREGROUND_WINDOW_SECONDS) * 1_000;
-	const timeoutMs =
-		timeoutBehavior === "detach" ? Math.min(requestedTimeoutMs, foregroundWindowMs) : requestedTimeoutMs;
-	// A cell that pauses its watchdog for a host bridge call would otherwise wait the full pause grace
-	// (~10 min) before detaching; cap the grace at the foreground window too so the detach guarantee
-	// holds for bridge-parked cells. Error mode keeps the default grace (its timeout is the deadline).
-	const bridgeAbortController = new AbortController();
-	const cellSignal = AbortSignal.any([invocation.signal, bridgeAbortController.signal]);
-	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
-	const runtime = options.runtimes?.[invocation.input.language];
-	const state: CellState = {
-		input: invocation.input,
-		...(runtime === undefined ? {} : { runtime }),
-		startedAt: Date.now(),
-		signal: cellSignal,
-		onUpdate: invocation.onUpdate,
-		toolCalls: [],
-		toolCallMetrics: [],
-		pendingBridgeCalls: [],
-		statusEvents: [],
-		active: true,
-		output: "",
-		phase: undefined,
-		error: undefined,
-		durationMs: 0,
-		status: "pending",
-	};
-	const cell = cellManager.create(invocation.cellId, invocation.input);
-	let detached = false;
-	let execution: CellExecution;
-	execution = new CellExecution({
-		callerSignal: invocation.signal,
-		cellId: invocation.cellId,
-		timeoutMs,
-		...(timeoutBehavior === "detach" ? { maxPauseGraceMs: foregroundWindowMs } : {}),
-		timeoutFactory: options.timeoutFactory ?? defaultTimeoutFactory,
-		onTimeout: (error) => {
-			if (timeoutBehavior === "detach" && cellManager.detach(cell)) {
-				detached = true;
-				execution.detach();
-				return;
-			}
-			execution.cancel(error);
-		},
-		onAbort: (error) => {
-			state.active = false;
-			bridgeAbortController.abort(error);
-		},
-	});
-	const running = executeCell(
-		options,
-		invocation,
-		cellManager,
-		cell,
-		state,
-		execution,
-		bridgeContext,
-		bridgeAbortController,
-	);
-	let settleEventEmitted = false;
-	const emitSettled = (outcome: EvalExecutionSettleOutcome): void => {
-		if (settleEventEmitted) return;
-		settleEventEmitted = true;
-		options.onCellSettled?.(
-			buildEvalExecutionEventPayload({
-				cellId: invocation.cellId,
-				state,
-				outcome,
-				completedAt: Date.now(),
-				detached,
-			}),
-		);
-	};
-	const finalized = running.then(
-		(result) => {
-			cellManager.complete(cell, result);
-			emitSettled({ result });
-			return result;
-		},
-		(error: unknown) => {
-			cellManager.fail(cell, error instanceof Error ? error : new Error(String(error)));
-			emitSettled({ error });
-			throw error;
-		},
-	);
-	const outcome = await Promise.race([
-		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);
-	return outcome.result;
-}
-
-async function executeCell(
-	options: CreateEvalToolOptions,
-	invocation: EvalCellInvocation,
-	cellManager: EvalDetachedCellManager,
-	cell: Parameters<EvalDetachedCellManager["markRunning"]>[0],
-	state: CellState,
-	execution: CellExecution,
-	bridgeContext: ExtensionContext,
-	bridgeAbortController: AbortController,
-): 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();
-						return;
-					}
-					if (message.event.op === TIMEOUT_RESUME_OP) {
-						execution.resume();
-						return;
-					}
-				}
-				const pending = handler.handle(message);
-				void pending.catch((error: unknown) => execution.cancel(error));
-			}),
-		);
-		execution.setKernel(kernel);
-		const activeHandler = new CellHandler(kernel, state, {
-			executeTool: options.executeTool,
-			...(options.listTools === undefined ? {} : { listTools: options.listTools }),
-			settings: options.settings ?? defaultCodemodeSettings,
-			...(options.complete === undefined ? {} : { complete: options.complete }),
-			ctx: bridgeContext,
-			...(options.artifactsDir === undefined
-				? {}
-				: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
-			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
-		});
-		handler = activeHandler;
-		cellManager.markRunning(
-			cell,
-			kernel,
-			() => activeHandler.liveResult(),
-			(error) => execution.cancel(error),
-		);
-		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 }));
-		if (result.ok && state.pendingBridgeCalls.length > 0) await execution.wait(Promise.all(state.pendingBridgeCalls));
-		return await handler.finalize(result);
-	} catch (error) {
-		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);
-		throw error;
-	} finally {
-		state.active = false;
-		bridgeAbortController.abort();
-		execution.finish();
-		if (handler) await handler.flushOutput();
-	}
-}

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

@@ -0,0 +1,189 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import type { AgentToolResult, ExtensionContext } from "@code-yeongyu/senpi";
+import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } from "../config/settings.ts";
+import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
+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 { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from "./eval-execution-event.ts";
+import { evalTimeoutBehavior } from "./eval-request.ts";
+import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
+import { describeTimeoutState } from "./interrupt-note.ts";
+import type { EvalToolDetails } from "./types.ts";
+
+export async function runEvalCell(
+	options: CreateEvalToolOptions,
+	cellManager: EvalDetachedCellManager,
+	invocation: EvalCellInvocation,
+): Promise<AgentToolResult<EvalToolDetails>> {
+	if (invocation.signal.aborted) throw abortError(invocation.signal.reason);
+	const detaches = evalTimeoutBehavior(invocation.input, invocation.ctx) === "detach";
+	// The per-call `timeout` is the cell's run budget (owned by the cell manager's deadlines); how long
+	// an interactive call blocks the turn is the idle detach budget, capped at the foreground window
+	// — including the grace a bridge-parked cell gets — so `timeout` never delays the detach.
+	const foregroundWindowMs = (options.foregroundWindowSeconds ?? DEFAULT_FOREGROUND_WINDOW_SECONDS) * 1_000;
+	const detachAfterMs = Math.min(Math.floor(options.cellTimeoutSeconds * 1_000), foregroundWindowMs);
+	const bridgeAbortController = new AbortController();
+	const cellSignal = AbortSignal.any([invocation.signal, bridgeAbortController.signal]);
+	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
+	const runtime = options.runtimes?.[invocation.input.language];
+	const state: CellState = {
+		input: invocation.input,
+		...(runtime === undefined ? {} : { runtime }),
+		startedAt: Date.now(),
+		signal: cellSignal,
+		onUpdate: invocation.onUpdate,
+		toolCalls: [],
+		toolCallMetrics: [],
+		pendingBridgeCalls: [],
+		statusEvents: [],
+		active: true,
+		output: "",
+		phase: undefined,
+		error: undefined,
+		durationMs: 0,
+		status: "pending",
+	};
+	let detached = false;
+	let execution: CellExecution;
+	const cell = cellManager.create(invocation.cellId, invocation.input, (error) => execution.cancel(error));
+	execution = new CellExecution({
+		callerSignal: invocation.signal,
+		cellId: invocation.cellId,
+		...(detaches
+			? {
+					idle: {
+						timeoutMs: detachAfterMs,
+						maxPauseGraceMs: foregroundWindowMs,
+						onTimeout: (error: Error) => {
+							if (cellManager.detach(cell)) {
+								detached = true;
+								execution.detach();
+								return;
+							}
+							execution.cancel(error);
+						},
+					},
+				}
+			: {}),
+		timeoutFactory: options.timeoutFactory ?? defaultTimeoutFactory,
+		onAbort: (error) => {
+			state.active = false;
+			bridgeAbortController.abort(error);
+		},
+	});
+	const running = executeCell(
+		options,
+		invocation,
+		cellManager,
+		cell,
+		state,
+		execution,
+		bridgeContext,
+		bridgeAbortController,
+	);
+	let settleEventEmitted = false;
+	const emitSettled = (outcome: EvalExecutionSettleOutcome): void => {
+		if (settleEventEmitted) return;
+		settleEventEmitted = true;
+		options.onCellSettled?.(
+			buildEvalExecutionEventPayload({
+				cellId: invocation.cellId,
+				state,
+				outcome,
+				completedAt: Date.now(),
+				detached,
+			}),
+		);
+	};
+	const finalized = running.then(
+		(result) => {
+			cellManager.complete(cell, result);
+			emitSettled({ result });
+			return result;
+		},
+		(error: unknown) => {
+			cellManager.fail(cell, error instanceof Error ? error : new Error(String(error)));
+			emitSettled({ error });
+			throw error;
+		},
+	);
+	const outcome = await Promise.race([
+		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);
+	return outcome.result;
+}
+
+async function executeCell(
+	options: CreateEvalToolOptions,
+	invocation: EvalCellInvocation,
+	cellManager: EvalDetachedCellManager,
+	cell: Parameters<EvalDetachedCellManager["markRunning"]>[0],
+	state: CellState,
+	execution: CellExecution,
+	bridgeContext: ExtensionContext,
+	bridgeAbortController: AbortController,
+): 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 pending = handler.handle(message);
+				void pending.catch((error: unknown) => execution.cancel(error));
+			}),
+		);
+		execution.setKernel(kernel);
+		const activeHandler = new CellHandler(kernel, state, {
+			executeTool: options.executeTool,
+			...(options.listTools === undefined ? {} : { listTools: options.listTools }),
+			settings: options.settings ?? defaultCodemodeSettings,
+			...(options.complete === undefined ? {} : { complete: options.complete }),
+			ctx: bridgeContext,
+			...(options.artifactsDir === undefined
+				? {}
+				: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
+			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
+		});
+		handler = activeHandler;
+		cellManager.markRunning(
+			cell,
+			kernel,
+			() => activeHandler.liveResult(),
+			(error) => execution.cancel(error),
+		);
+		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 }));
+		if (result.ok && state.pendingBridgeCalls.length > 0) await execution.wait(Promise.all(state.pendingBridgeCalls));
+		return await handler.finalize(result);
+	} catch (error) {
+		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);
+		throw error;
+	} finally {
+		state.active = false;
+		bridgeAbortController.abort();
+		execution.finish();
+		if (handler) await handler.flushOutput();
+	}
+}

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

@@ -1,6 +1,12 @@
 import type { AgentToolResult, AgentToolUpdateCallback } from "@code-yeongyu/senpi";
-import { type TUnsafe, Type } from "typebox";
+import { type TSchema, type TUnsafe, Type } from "typebox";
 import type { HostToKernelMessage, KernelToHostMessage } from "../bridge/protocol.ts";
+import {
+	DEFAULT_FOREGROUND_WINDOW_SECONDS,
+	DEFAULT_HARD_LIMIT_SECONDS,
+	DEFAULT_RUN_BUDGET_SECONDS,
+	defaultCodemodeSettings,
+} from "../config/settings.ts";
 import type { TruncationMeta } from "../output/output-meta.ts";
 
 export const evalLanguageOrder = ["js", "py", "rb", "jl"] as const;
@@ -13,11 +19,30 @@ export function enabledLanguageList(enabled: EnabledEvalLanguages): EvalLanguage
 
 export const EVAL_SUMMARY_MAX_LENGTH = 80;
 
-const TIMEOUT_FIELD_DESCRIPTION =
-	"Seconds the cell may block the turn before it detaches, and the amount by which it raises the wall-clock hard limit. In interactive sessions the detach point is capped at the foreground window (default 60s), so a large value frees the turn at the window while the cell keeps running; on_timeout:'error' (and print/json) keep the full value as the uncapped deadline.";
+/** The deadlines the schema teaches the model; every number comes from the resolved settings. */
+export interface EvalDeadlineSeconds {
+	readonly runBudgetSeconds: number;
+	/** Effective interactive detach point: `cellTimeoutSeconds` capped by the foreground window. */
+	readonly detachAfterSeconds: number;
+	/** Longest a host tool call can hold an interactive call before it detaches anyway. */
+	readonly foregroundWindowSeconds: number;
+	readonly hardLimitSeconds: number;
+}
+
+export const defaultEvalDeadlineSeconds: EvalDeadlineSeconds = {
+	runBudgetSeconds: DEFAULT_RUN_BUDGET_SECONDS,
+	detachAfterSeconds: Math.min(defaultCodemodeSettings.cellTimeoutSeconds, DEFAULT_FOREGROUND_WINDOW_SECONDS),
+	foregroundWindowSeconds: DEFAULT_FOREGROUND_WINDOW_SECONDS,
+	hardLimitSeconds: DEFAULT_HARD_LIMIT_SECONDS,
+};
 
-const ON_TIMEOUT_FIELD_DESCRIPTION =
-	"Timeout behavior. Interactive sessions detach by default (at the foreground window); print/json sessions error by default. 'error' uses the full timeout as an uncapped deadline.";
+function timeoutFieldDescription(deadlines: EvalDeadlineSeconds): string {
+	return `Run budget in seconds for this cell's own execution (default ${deadlines.runBudgetSeconds}s); time parked in host tool calls such as agent() or tool.* is not charged. When it runs out the cell is killed, and a js cell that cannot settle (a pending timer or Bun.$ command, a synchronous call) restarts its kernel and loses every global. Raise it only for a declared long run; a value above ${deadlines.hardLimitSeconds}s also raises the wall-clock hard limit. It does not move the detach point.`;
+}
+
+function onTimeoutFieldDescription(deadlines: EvalDeadlineSeconds): string {
+	return `'detach' (interactive default): the call returns after ${deadlines.detachAfterSeconds}s of the cell's own work (a host tool call in flight can hold it up to the ${deadlines.foregroundWindowSeconds}s foreground window) while the cell keeps running; completion arrives as a notification. 'error' (print/json default): the call blocks until the cell settles or a deadline kills it.`;
+}
 
 export interface EvalToolInput {
 	readonly language: EvalLanguage;
@@ -36,69 +61,54 @@ export interface EvalControlInput {
 
 export type EvalToolRequest = EvalToolInput | EvalControlInput;
 
-const fullEvalInputSchema = Type.Object({
-	action: Type.Optional(
-		Type.Union([Type.Literal("run"), Type.Literal("peek"), Type.Literal("stop")], {
-			description: "Defaults to run. peek and stop require cell_id.",
-		}),
-	),
-	language: Type.Optional(
+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.",
+			}),
+		),
+		language: Type.Optional(languageSchema),
+		code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
+		summary: Type.Optional(
+			Type.String({
+				maxLength: EVAL_SUMMARY_MAX_LENGTH,
+				description:
+					"REQUIRED for run. ONE line in the USER'S conversational language (Korean conversation -> Korean summary) stating WHAT this cell does and FOR WHAT PURPOSE; shown in the TUI while the cell runs. Longer values are force-truncated to 80 chars.",
+			}),
+		),
+		timeout: Type.Optional(Type.Number({ minimum: 1, description: timeoutFieldDescription(deadlines) })),
+		on_timeout: Type.Optional(
+			Type.Union([Type.Literal("detach"), Type.Literal("error")], {
+				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." })),
+	};
+}
+
+const fullEvalInputSchema = Type.Object(
+	evalInputProperties(
 		Type.Union([Type.Literal("js"), Type.Literal("py"), Type.Literal("rb"), Type.Literal("jl")]),
+		defaultEvalDeadlineSeconds,
 	),
-	code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
-	summary: Type.Optional(
-		Type.String({
-			maxLength: EVAL_SUMMARY_MAX_LENGTH,
-			description:
-				"REQUIRED for run. ONE line in the USER'S conversational language (Korean conversation -> Korean summary) stating WHAT this cell does and FOR WHAT PURPOSE; shown in the TUI while the cell runs. Longer values are force-truncated to 80 chars.",
-		}),
-	),
-	timeout: Type.Optional(Type.Number({ minimum: 1, description: TIMEOUT_FIELD_DESCRIPTION })),
-	on_timeout: Type.Optional(
-		Type.Union([Type.Literal("detach"), Type.Literal("error")], {
-			description: ON_TIMEOUT_FIELD_DESCRIPTION,
-		}),
-	),
-	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." })),
-});
+);
 
 /** Runtime accepts a discriminated run/control union. */
 export type EvalInputSchema = TUnsafe<EvalToolRequest> & Pick<typeof fullEvalInputSchema, "properties">;
 
-export function createEvalInputSchema(enabled: EnabledEvalLanguages): EvalInputSchema {
+export function createEvalInputSchema(
+	enabled: EnabledEvalLanguages,
+	deadlines: EvalDeadlineSeconds = defaultEvalDeadlineSeconds,
+): EvalInputSchema {
 	const languages = enabledLanguageList(enabled);
 	if (languages.length === 0) throw new Error("eval requires at least one enabled language");
 	const languageSchema =
 		languages.length === 1
 			? Type.Union([Type.Literal(languages[0])])
 			: Type.Union(languages.map((item) => Type.Literal(item)));
-	return Type.Unsafe<EvalToolRequest>(
-		Type.Object({
-			action: Type.Optional(
-				Type.Union([Type.Literal("run"), Type.Literal("peek"), Type.Literal("stop")], {
-					description: "Defaults to run. peek and stop require cell_id.",
-				}),
-			),
-			language: Type.Optional(languageSchema),
-			code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
-			summary: Type.Optional(
-				Type.String({
-					maxLength: EVAL_SUMMARY_MAX_LENGTH,
-					description:
-						"REQUIRED for run. ONE line in the USER'S conversational language (Korean conversation -> Korean summary) stating WHAT this cell does and FOR WHAT PURPOSE; shown in the TUI while the cell runs. Longer values are force-truncated to 80 chars.",
-				}),
-			),
-			timeout: Type.Optional(Type.Number({ minimum: 1, description: TIMEOUT_FIELD_DESCRIPTION })),
-			on_timeout: Type.Optional(
-				Type.Union([Type.Literal("detach"), Type.Literal("error")], {
-					description: ON_TIMEOUT_FIELD_DESCRIPTION,
-				}),
-			),
-			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." })),
-		}),
-	) as EvalInputSchema;
+	return Type.Unsafe<EvalToolRequest>(Type.Object(evalInputProperties(languageSchema, deadlines))) as EvalInputSchema;
 }
 export type EvalKernelResult = Extract<KernelToHostMessage, { type: "result" }>;
 export type EvalToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;

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

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,KAAK,OAAO,EAEZ,WAAW,EAIX,MAAM,uBAAuB,CAAC;AAW/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmBD,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,SAAS,EAAE,MAAM;CAM7B;AA2ND,uGAAuG;AACvG,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,kBAAkB,CAAC,EAClE,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAIlB;AA+mBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,KAAK,OAAO,EAEZ,WAAW,EAIX,MAAM,uBAAuB,CAAC;AAW/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmBD,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,YAAY,SAAS,EAAE,MAAM,EAK5B;CACD;AA2ND,uGAAuG;AACvG,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,kBAAkB,CAAC,EAClE,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAIlB;AA+mBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}

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

@@ -891,7 +891,7 @@ async function executePreparedToolCall(prepared, signal, emit) {
         }
         acceptingUpdates = false;
         await Promise.all(updateEvents);
-        return { result: settled, isError: false };
+        return { result: settled, isError: settled.isError === true };
     }
     catch (error) {
         acceptingUpdates = false;