@code-yeongyu/senpi-codemode 2026.9.9-2 → 2026.9.10-2

package/CHANGELOG.md

@@ -12,6 +12,36 @@
 
 ### Removed
 
+## [2026.9.10-2] - 2026-09-10
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.10] - 2026-09-10
+
+### Breaking Changes
+
+- The eval `timeout` argument is now the cell's run budget (a kill deadline for the cell's own execution time) instead of the interactive detach budget; interactive calls detach at `cellTimeoutSeconds` capped by `foregroundWindowSeconds` regardless of `timeout`, and print/json calls are bounded by the run budget instead of a `cellTimeoutSeconds` idle kill.
+
+### Added
+
+- Every eval cell carries a run budget (`runBudgetSeconds`, default 300s, env `SENPI_CODEMODE_RUN_BUDGET_SECONDS`, per-call `timeout`) that charges only its own execution time, is paused while a host tool call is in flight, keeps counting after detach, and kills the cell through the cooperative interrupt path with a result or notification that names the exhausted budget and the kernel-state outcome.
+
+### Changed
+
+- The eval tool schema and description state the configured run budget, detach point, and hard limit, and say that a killed JavaScript cell that cannot settle restarts its kernel and loses every global.
+
+### Fixed
+
+### Removed
+
 ## [2026.9.9-2] - 2026-09-09
 
 ### Breaking Changes

package/README.md

@@ -85,6 +85,8 @@ Configuration is loaded in this order:
   },
   "cellTimeoutSeconds": 30,
   "foregroundWindowSeconds": 60,
+  "runBudgetSeconds": 300,
+  "hardLimitSeconds": 1800,
   "parallelPoolWidth": 4,
   "taskTools": {
     "task": "task",
@@ -101,8 +103,10 @@ Configuration is loaded in this order:
 | Key | Default | Effect |
 | --- | --- | --- |
 | `languages` | `py`/`js` enabled; `rb`/`jl` disabled | Selects desired languages before interpreter detection. |
-| `cellTimeoutSeconds` | `30` | Idle timeout for one cell unless the call supplies `timeout`; interactive calls detach by default and print/json calls error. |
-| `foregroundWindowSeconds` | `60` | Longest an interactive (detach-behavior) call blocks the turn before the cell detaches, capping the `timeout` detach budget. A larger `timeout` still raises the hard limit and keeps the cell running, but the turn is freed at this window. `on_timeout: "error"` calls keep the full `timeout` as an uncapped deadline. Env override: `SENPI_CODEMODE_FOREGROUND_SECONDS`. |
+| `cellTimeoutSeconds` | `30` | Idle time an interactive call blocks the turn before the cell detaches. Print/json calls never detach. |
+| `foregroundWindowSeconds` | `60` | Caps `cellTimeoutSeconds` and the grace a bridge-parked cell gets before it detaches, so an interactive call never blocks the turn longer than this. Env override: `SENPI_CODEMODE_FOREGROUND_SECONDS`. |
+| `runBudgetSeconds` | `300` | Kill deadline for a cell's own execution time - child processes, network, timers, CPU. Time parked in host tool calls (`agent()`, `tool.*`) is not charged, and the budget keeps counting after the cell detaches. A per-call `timeout` replaces it for that cell. Env override: `SENPI_CODEMODE_RUN_BUDGET_SECONDS`. |
+| `hardLimitSeconds` | `1800` | Wall-clock kill deadline for a cell, parked or not; a per-call `timeout` above it raises it. Env override: `SENPI_CODEMODE_HARD_LIMIT_SECONDS`. |
 | `parallelPoolWidth` | `4` | Maximum concurrent `parallel()` thunks. |
 | `taskTools.task` | `"task"` | Registered tool name used by `agent()`. |
 | `taskTools.output` | `"task_output"` | Registered tool name used by `output()`. |
@@ -173,6 +177,17 @@ cell keeps only its own language kernel busy. A new same-language call returns
 a busy error with its cell id and output tail; calls in other languages continue
 normally. Do not re-run the cell.
 
+Every cell, detached or not, is bounded by two kill deadlines. The run budget
+(`runBudgetSeconds`, or the call's `timeout`) charges only the cell's own
+execution time and is paused while a host tool call is in flight, so a cell
+waiting on `agent()` survives while a runaway child process or loop does not.
+The hard limit (`hardLimitSeconds`, raised by a larger `timeout`) is wall-clock
+and bounds parked cells too. A cell killed by either deadline reports which one
+in its result or completion notification, together with whether kernel state
+survived; the tool schema states the configured numbers. The `timeout` value
+never changes when an interactive call detaches: that is `cellTimeoutSeconds`
+capped by `foregroundWindowSeconds`.
+
 While any cell is detached, the interactive footer shows a highlighted
 `↗ <language> · <summary>` status on the extension status line (the cell id
 when the call had no summary), clearing as soon as the last detached cell settles.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.9-2",
+	"version": "2026.9.10-2",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.9-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.10-2",
 		"typebox": "1.3.18"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.9-2"
+		"@code-yeongyu/senpi": "2026.9.10-2"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.9-2"
+		"@code-yeongyu/senpi": "2026.9.10-2"
 	},
 	"keywords": [
 		"senpi",

package/src/config/settings.ts

@@ -20,6 +20,7 @@ export const codemodeSettingsSchema = Type.Object(
 		),
 		cellTimeoutSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		foregroundWindowSeconds: Type.Optional(Type.Number({ minimum: 1 })),
+		runBudgetSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		hardLimitSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		parallelPoolWidth: Type.Optional(Type.Number({ minimum: 1 })),
 		taskTools: Type.Optional(
@@ -64,15 +65,20 @@ export interface CodemodeSettings {
 		readonly rb: boolean;
 		readonly jl: boolean;
 	};
+	/** Idle time an interactive call blocks the turn before the cell detaches; capped by the foreground window. */
 	readonly cellTimeoutSeconds: number;
 	/**
-	 * Longest an interactive eval call blocks the agent loop before the cell detaches, independent
-	 * of `timeout` (which becomes the detach budget only up to this window). A still-running cell
-	 * keeps living up to the hard limit; this only frees the turn. Ignored for `on_timeout: "error"`
-	 * (and print/json) calls, where `timeout` stays the unclamped deadline.
+	 * Longest an interactive eval call blocks the agent loop before the cell detaches, capping
+	 * `cellTimeoutSeconds` and the bridge-parked grace. A still-running cell keeps living up to its
+	 * run budget and the hard limit; this only frees the turn. Print/json calls never detach.
 	 */
 	readonly foregroundWindowSeconds: number;
-	/** Wall-clock kill deadline for a single cell; bounds detached cells too. */
+	/**
+	 * Kill deadline for a cell's own execution time — child processes, network, timers, CPU — with
+	 * time parked on host tool calls excluded. A per-call `timeout` replaces it for that cell.
+	 */
+	readonly runBudgetSeconds: number;
+	/** Wall-clock kill deadline for a single cell; bounds detached and bridge-parked cells too. */
 	readonly hardLimitSeconds: number;
 	readonly parallelPoolWidth: number;
 	readonly taskTools?: CodemodeTaskTools;
@@ -116,6 +122,15 @@ export const DEFAULT_FOREGROUND_WINDOW_SECONDS = 60;
 
 export const FOREGROUND_WINDOW_ENVIRONMENT_FLAG = "SENPI_CODEMODE_FOREGROUND_SECONDS";
 
+/**
+ * One language kernel runs one cell at a time and a killed JavaScript cell that cannot settle
+ * cooperatively restarts its worker, so a runaway cell costs far more than a runaway bash command:
+ * five minutes of own execution time is the default before the cell is killed.
+ */
+export const DEFAULT_RUN_BUDGET_SECONDS = 300;
+
+export const RUN_BUDGET_ENVIRONMENT_FLAG = "SENPI_CODEMODE_RUN_BUDGET_SECONDS";
+
 // OMP settings-schema.ts:3211-3299 has language/path settings only; eval.ts:427
 // defaults timeout to 30s, and codemode pins concurrency-bridge.ts:30 width to 4.
 export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
@@ -127,6 +142,7 @@ export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
 	},
 	cellTimeoutSeconds: 30,
 	foregroundWindowSeconds: DEFAULT_FOREGROUND_WINDOW_SECONDS,
+	runBudgetSeconds: DEFAULT_RUN_BUDGET_SECONDS,
 	hardLimitSeconds: DEFAULT_HARD_LIMIT_SECONDS,
 	parallelPoolWidth: 4,
 	taskTools: {
@@ -178,20 +194,23 @@ export function resolveEnabledLanguages(
 
 /** Environment override wins over the settings file; a non-positive or malformed value is ignored. */
 export function resolveHardLimitSeconds(settings: CodemodeSettings, env: Environment = process.env): number {
-	const override = env[HARD_LIMIT_ENVIRONMENT_FLAG];
-	if (override === undefined) return settings.hardLimitSeconds;
-	const parsed = Number.parseInt(override, 10);
-	if (!Number.isFinite(parsed) || parsed <= 0) return settings.hardLimitSeconds;
-	return parsed;
+	return positiveSecondsOverride(env[HARD_LIMIT_ENVIRONMENT_FLAG]) ?? settings.hardLimitSeconds;
 }
 
 /** Environment override wins over the settings file; a non-positive or malformed value is ignored. */
 export function resolveForegroundWindowSeconds(settings: CodemodeSettings, env: Environment = process.env): number {
-	const override = env[FOREGROUND_WINDOW_ENVIRONMENT_FLAG];
-	if (override === undefined) return settings.foregroundWindowSeconds;
-	const parsed = Number.parseInt(override, 10);
-	if (!Number.isFinite(parsed) || parsed <= 0) return settings.foregroundWindowSeconds;
-	return parsed;
+	return positiveSecondsOverride(env[FOREGROUND_WINDOW_ENVIRONMENT_FLAG]) ?? settings.foregroundWindowSeconds;
+}
+
+/** Environment override wins over the settings file; a non-positive or malformed value is ignored. */
+export function resolveRunBudgetSeconds(settings: CodemodeSettings, env: Environment = process.env): number {
+	return positiveSecondsOverride(env[RUN_BUDGET_ENVIRONMENT_FLAG]) ?? settings.runBudgetSeconds;
+}
+
+function positiveSecondsOverride(value: string | undefined): number | undefined {
+	if (value === undefined) return undefined;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
 }
 
 async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
@@ -229,6 +248,7 @@ function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
 		},
 		cellTimeoutSeconds: input.cellTimeoutSeconds ?? defaultCodemodeSettings.cellTimeoutSeconds,
 		foregroundWindowSeconds: input.foregroundWindowSeconds ?? defaultCodemodeSettings.foregroundWindowSeconds,
+		runBudgetSeconds: input.runBudgetSeconds ?? defaultCodemodeSettings.runBudgetSeconds,
 		hardLimitSeconds: input.hardLimitSeconds ?? defaultCodemodeSettings.hardLimitSeconds,
 		parallelPoolWidth: input.parallelPoolWidth ?? defaultCodemodeSettings.parallelPoolWidth,
 		taskTools: {

package/src/index.ts

@@ -3,7 +3,12 @@ import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
 import type { EvalSchemaToolInfo } from "./bridges/schema-bridge.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
-import { defaultCodemodeSettings, resolveForegroundWindowSeconds, resolveHardLimitSeconds } from "./config/settings.ts";
+import {
+	defaultCodemodeSettings,
+	resolveForegroundWindowSeconds,
+	resolveHardLimitSeconds,
+	resolveRunBudgetSeconds,
+} from "./config/settings.ts";
 import { EvalNotifier } from "./extension/eval-notifier.ts";
 import { EVAL_CELLS_STATUS_KEY } from "./extension/eval-status.ts";
 import { EvalStatusTicker } from "./extension/eval-status-ticker.ts";
@@ -128,6 +133,8 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 				kernelManager: manager,
 				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
 				foregroundWindowSeconds: resolveForegroundWindowSeconds(runtime.settings),
+				runBudgetSeconds: resolveRunBudgetSeconds(runtime.settings),
+				hardLimitSeconds: resolveHardLimitSeconds(runtime.settings),
 				executeTool: runtime.executeTool,
 				listTools: () => pi.getAllTools(),
 				complete,
@@ -163,6 +170,8 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			kernelManager: manager,
 			cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
 			foregroundWindowSeconds: resolveForegroundWindowSeconds(defaultCodemodeSettings),
+			runBudgetSeconds: resolveRunBudgetSeconds(defaultCodemodeSettings),
+			hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
 			executeTool: createExecuteTool(pi),
 			listTools: () => pi.getAllTools(),
 			complete,
@@ -170,6 +179,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			cellManager: new EvalDetachedCellManager({
 				notifier,
 				hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
+				runBudgetSeconds: resolveRunBudgetSeconds(defaultCodemodeSettings),
 				onStatusChange: showDetachedCells,
 				onWakeSourceState: emitWakeSourceState,
 				...(options.now === undefined ? {} : { now: options.now }),
@@ -185,7 +195,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 	);
 	pi.registerRemovedToolHint(
 		"exec",
-		'exec was removed; use eval({ language: "js", code }) instead. Long eval cells detach on timeout and notify when complete.',
+		'exec was removed; use eval({ language: "js", code }) instead. Long eval cells detach on their own and notify when complete.',
 	);
 	pi.registerRemovedToolHint(
 		"wait",
@@ -207,6 +217,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			artifactsDir: runtime.artifactsDir,
 			notifier,
 			hardLimitSeconds: resolveHardLimitSeconds(runtime.settings),
+			runBudgetSeconds: resolveRunBudgetSeconds(runtime.settings),
 			onStatusChange: showDetachedCells,
 			onWakeSourceState: emitWakeSourceState,
 			...(options.now === undefined ? {} : { now: options.now }),

package/src/prompt/eval-prompt-template.ts

@@ -0,0 +1,76 @@
+export const EVAL_PROMPT_TEMPLATE = `Run one step of code in a persistent kernel.
+
+<instruction>
+**One eval call = one cell = one logical step.** Top-level names persist per language across eval calls{{#if spawns}}, tool calls and \`task\` subagents{{else}} and tool calls{{/if}}: define helpers and clients once and reuse them instead of re-importing or re-reading. Rebuild state only after \`reset\`, a kernel restart, or a \`NameError\`/\`ReferenceError\`, and check a sentinel variable first so a re-run cannot duplicate side effects.
+
+{{#if styleClaude}}<eval_first_batching>
+Batch a step's independent calls in one cell with \`parallel(thunks)\`; write real code around them - loops, branches, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
+{{#if monitor}}- Start long-running work (build, test run, deploy, or watch) through \`tool.monitor({ command, filter })\`, putting the decisive-line filter inside the same cell, then keep working until its event wakes the turn.{{/if}}
+</eval_first_batching>{{/if}}{{#if styleGpt}}<gpt_eval_dialect>
+GPT eval: batch a step's independent tool calls in one cell with \`tool.<name>(args)\` and \`parallel(thunks)\` and inspect every result.
+{{#if monitor}}- A wait or a long run (build, test run, deploy, watch) starts through \`tool.monitor({ command, filter })\` in that same cell with the decisive-line filter; its event wakes the turn, so no cell sits on the wait and no child is spawned for it.
+{{/if}}- Long cells detach on their own and notify on completion; do not poll or re-run them.
+- Keep every failed or missing item in the result verbatim and re-read truncated output before deciding.
+</gpt_eval_dialect>{{/if}}{{#if styleCodex}}Route a step's independent lookups through one eval cell via \`parallel(thunks)\` and inspect every result.
+- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
+- Wrap failable calls in try/except inside the cell and keep every failed item in the result verbatim; after two distinct failed strategies for the same fact, fall back to direct tool calls.
+- Re-read truncated output before deciding on it.
+{{#if monitor}}- Long-running build/test/deploy/watch work: start \`tool.monitor({ command, filter })\` with the decisive-line filter inside the same cell, then continue working until its event wakes the turn.{{/if}}{{/if}}{{#if styleKimi}}Put a step's independent calls into one cell with \`parallel(thunks)\`.
+- Write real code around the calls - loops, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
+{{#if monitor}}- Start long-running build, test run, deploy, or watch work with \`tool.monitor({ command, filter })\`, put the decisive-line filter inside the same cell, and keep working until its event wakes the turn.{{/if}}{{/if}}{{#if styleDefault}}Batch a step's independent calls in one cell with \`parallel(thunks)\`.
+- Write real code around the calls - loops, branches, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
+{{#if monitor}}- Long-running build, test run, deploy, or watch work starts with \`tool.monitor({ command, filter })\`, with the decisive-line filter inside the same cell; keep working until its event wakes the turn.{{/if}}{{/if}}
+{{#if hostLine}}
+Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to its cores; \`tool.<name>()\` shell commands must fit this platform, even when the code you are writing targets another machine.
+{{/if}}
+
+\`language\`: {{#if py}}\`"py"\` IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}\`"js"\` persistent JavaScript VM{{/if}}{{#if rb}}{{#ifAny py js}}, {{/ifAny}}\`"rb"\` persistent Ruby kernel{{/if}}{{#if jl}}{{#ifAny py js rb}}, {{/ifAny}}\`"jl"\` persistent Julia kernel{{/if}}.
+
+A cell that outlives the foreground window detaches: it keeps its language kernel busy (another language can continue) and completes as one notification with its value or error and buffered output. Its own execution time is capped at {{runBudgetSeconds}}s — time inside host tool calls is not charged; raise \`timeout\` only for a declared long run — and a killed js cell that cannot settle restarts its kernel with every global lost. Do not re-run a detached cell; read or cancel it with \`eval({ action: "peek", cell_id })\` / \`eval({ action: "stop", cell_id })\`.
+
+{{#if py}}Python runs on a live event loop: use top-level \`await\`; \`asyncio.run(…)\` raises.{{/if}}
+{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot. Shell out through \`Bun.$\` or \`Bun.spawn\`, never \`Bun.spawnSync\`: a synchronous child blocks the worker and cannot be interrupted.{{#if bunSkillPath}} MUST READ the bun-1-4 skill at {{bunSkillPath}} before your first js cell — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
+{{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
+{{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
+On error, fix and re-run only the failing step; a normal error keeps state, while a timeout or stop message says whether the kernel restarted.
+</instruction>
+
+<prelude>
+{{#ifAll py js}}Same helpers + arg order, both runtimes. Python: sync, options = trailing kwargs. JS: async/\`await\`able, options = ONE trailing object literal, never positional (extras throw).{{else}}{{#if py}}Sync; options = trailing kwargs.{{/if}}{{#if js}}Async/\`await\`able; options = ONE trailing object literal, never positional (extras throw).{{/if}}{{/ifAll}}{{#if rb}} Ruby: sync, options = trailing keyword args.{{/if}}{{#if jl}} Julia: sync, options = trailing keyword args.{{/if}}
+\`\`\`
+display(value) → None
+    Cell output. Images reach you only through display: pass a figure, image bytes, a tool result, or its \`images[i]\`.
+print(value, ...) → None
+    Text output.
+read(path, offset?=1, limit?=None) → str
+    File as text; offset/limit are 1-indexed lines. Accepts \`local://…\`.
+write(path, content) → str
+    Write file (creates parents) → resolved path. \`local://…\` persists across turns/subagents.
+env(key?=None, value?=None) → str | None | dict
+    No args → full env dict; one → value; two → set \`key=value\`.
+{{#if spawns}}output(*ids, format?="raw", offset?=None, limit?=None) → str | dict | list[dict]
+    Task/agent output by id. Reads immediately: running tasks return their status; \`format\` \`"raw"\` = full, \`"tail"\` = trailing.
+{{/if}}tool.<name>(args) → { text, images?, details?, hasError? }
+    Invoke any session tool; image results (e.g. \`tool.read\` on a png) arrive in \`images[i]\` as { mimeType, dataBase64 }.
+tool_schema(name?) → dict
+    Parameter schema of a tool (omit \`name\` to list tool names); a failed \`tool.<name>()\` call also returns the expected parameters.
+completion(prompt, model?="default", system?=None, schema?=None) → str | dict
+    Oneshot, stateless. \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → parsed structured output.
+{{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, handle?=False) → str | dict
+    Run a subagent → final output. \`agent\` picks a discovered agent. \`schema\` as in completion(). \`handle\` → workflow node { text, output, handle: \`agent://<id>\`, id, agent } (parsed under \`data\` with \`schema\`).
+{{/if}}parallel(thunks) → list
+    Thunks through a bounded pool (as wide as a \`task\` batch), input order kept; a throwing thunk propagates.
+pipeline(items, ...stages) → list
+    Map items through one-arg stages with a barrier between stages; each stage receives the previous stage's result.
+log(message) → None
+    Progress line above the status tree.
+phase(title) → None
+    Phase grouping subsequent status lines.
+\`\`\`
+</prelude>
+{{#if spawns}}
+<workflow>
+Multi-agent work is an acyclic graph in code: one \`agent(…)\` node per step with its handle option ({{#if py}}\`handle=True\`{{/if}}{{#ifAll py js}} / {{/ifAll}}{{#if js}}\`{ handle: true }\`{{/if}}{{#if jl}}{{#ifAny py js}} / {{/ifAny}}\`handle=true\`{{/if}}), \`parallel(thunks)\` for independent nodes, \`pipeline(items, *stages)\` for staged waves. Pass an upstream node's \`handle\` or \`output\` (or a \`write("local://…")\` URI for bulk text) into dependents instead of re-inlining transcripts, and wrap risky nodes in try/except so a failure aborts only its subtree.
+</workflow>
+{{/if}}
+`;

package/src/prompt/eval-prompt.ts

@@ -1,4 +1,6 @@
+import { DEFAULT_RUN_BUDGET_SECONDS } from "../config/settings.ts";
 import type { EvalRuntimeInfo } from "../tool/types.ts";
+import { EVAL_PROMPT_TEMPLATE } from "./eval-prompt-template.ts";
 
 export interface EnabledLanguages {
 	readonly py: boolean;
@@ -26,6 +28,8 @@ export interface EvalPromptOptions {
 	readonly jsRuntime?: EvalRuntimeInfo;
 	/** Absolute path of the active bun-1-4 skill; rendered as a MUST READ pointer only on a bun kernel. */
 	readonly bunSkillPath?: string;
+	/** Kill deadline for a cell's own execution time, as configured; the description states it. */
+	readonly runBudgetSeconds?: number;
 }
 
 /** Prompt dialect for the eval-first batching emphasis. */
@@ -64,82 +68,6 @@ export function evalEmphasisStyle(modelId: string | undefined): EvalEmphasisStyl
 
 type ContextValue = string | boolean;
 type Context = Readonly<Record<string, ContextValue>>;
-const EVAL_PROMPT_TEMPLATE = `Run one step of code in a persistent kernel.
-
-<instruction>
-**One eval call = one cell = one logical step.** Top-level names persist per language across eval calls{{#if spawns}}, tool calls and \`task\` subagents{{else}} and tool calls{{/if}}: define helpers and clients once and reuse them instead of re-importing or re-reading. Rebuild state only after \`reset\`, a kernel restart, or a \`NameError\`/\`ReferenceError\`, and check a sentinel variable first so a re-run cannot duplicate side effects.
-
-{{#if styleClaude}}<eval_first_batching>
-Batch a step's independent calls in one cell with \`parallel(thunks)\`; write real code around them - loops, branches, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
-{{#if monitor}}- Start long-running work (build, test run, deploy, or watch) through \`tool.monitor({ command, filter })\`, putting the decisive-line filter inside the same cell, then keep working until its event wakes the turn.{{/if}}
-</eval_first_batching>{{/if}}{{#if styleGpt}}<gpt_eval_dialect>
-GPT eval: batch a step's independent tool calls in one cell with \`tool.<name>(args)\` and \`parallel(thunks)\` and inspect every result.
-{{#if monitor}}- A wait or a long run (build, test run, deploy, watch) starts through \`tool.monitor({ command, filter })\` in that same cell with the decisive-line filter; its event wakes the turn, so no cell sits on the wait and no child is spawned for it.
-{{/if}}- Long cells detach on timeout and notify on completion; do not poll or re-run them.
-- Keep every failed or missing item in the result verbatim and re-read truncated output before deciding.
-</gpt_eval_dialect>{{/if}}{{#if styleCodex}}Route a step's independent lookups through one eval cell via \`parallel(thunks)\` and inspect every result.
-- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
-- Wrap failable calls in try/except inside the cell and keep every failed item in the result verbatim; after two distinct failed strategies for the same fact, fall back to direct tool calls.
-- Re-read truncated output before deciding on it.
-{{#if monitor}}- Long-running build/test/deploy/watch work: start \`tool.monitor({ command, filter })\` with the decisive-line filter inside the same cell, then continue working until its event wakes the turn.{{/if}}{{/if}}{{#if styleKimi}}Put a step's independent calls into one cell with \`parallel(thunks)\`.
-- Write real code around the calls - loops, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
-{{#if monitor}}- Start long-running build, test run, deploy, or watch work with \`tool.monitor({ command, filter })\`, put the decisive-line filter inside the same cell, and keep working until its event wakes the turn.{{/if}}{{/if}}{{#if styleDefault}}Batch a step's independent calls in one cell with \`parallel(thunks)\`.
-- Write real code around the calls - loops, branches, joins, a try/except per risky item - and keep every failed or missing item in the result verbatim; re-read truncated output before deciding.
-{{#if monitor}}- Long-running build, test run, deploy, or watch work starts with \`tool.monitor({ command, filter })\`, with the decisive-line filter inside the same cell; keep working until its event wakes the turn.{{/if}}{{/if}}
-{{#if hostLine}}
-Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to its cores; \`tool.<name>()\` shell commands must fit this platform, even when the code you are writing targets another machine.
-{{/if}}
-
-\`language\`: {{#if py}}\`"py"\` IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}\`"js"\` persistent JavaScript VM{{/if}}{{#if rb}}{{#ifAny py js}}, {{/ifAny}}\`"rb"\` persistent Ruby kernel{{/if}}{{#if jl}}{{#ifAny py js rb}}, {{/ifAny}}\`"jl"\` persistent Julia kernel{{/if}}.
-
-A cell that outlives the foreground window detaches: it keeps its language kernel busy (another language can continue) and completes as one notification with its value or error and buffered output. Do not re-run a detached cell; read or cancel it with \`eval({ action: "peek", cell_id })\` / \`eval({ action: "stop", cell_id })\`.
-
-{{#if py}}Python runs on a live event loop: use top-level \`await\`; \`asyncio.run(…)\` raises.{{/if}}
-{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot. Shell out through \`Bun.$\` or \`Bun.spawn\`, never \`Bun.spawnSync\`: a synchronous child blocks the worker, so a stop or timeout then loses every variable.{{#if bunSkillPath}} MUST READ the bun-1-4 skill at {{bunSkillPath}} before your first js cell — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
-{{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
-{{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
-On error, fix and re-run only the failing step; a normal error keeps state, while a timeout or stop message says whether the kernel restarted.
-</instruction>
-
-<prelude>
-{{#ifAll py js}}Same helpers + arg order, both runtimes. Python: sync, options = trailing kwargs. JS: async/\`await\`able, options = ONE trailing object literal, never positional (extras throw).{{else}}{{#if py}}Sync; options = trailing kwargs.{{/if}}{{#if js}}Async/\`await\`able; options = ONE trailing object literal, never positional (extras throw).{{/if}}{{/ifAll}}{{#if rb}} Ruby: sync, options = trailing keyword args.{{/if}}{{#if jl}} Julia: sync, options = trailing keyword args.{{/if}}
-\`\`\`
-display(value) → None
-    Cell output. Images reach you only through display: pass a figure, image bytes, a tool result, or its \`images[i]\`.
-print(value, ...) → None
-    Text output.
-read(path, offset?=1, limit?=None) → str
-    File as text; offset/limit are 1-indexed lines. Accepts \`local://…\`.
-write(path, content) → str
-    Write file (creates parents) → resolved path. \`local://…\` persists across turns/subagents.
-env(key?=None, value?=None) → str | None | dict
-    No args → full env dict; one → value; two → set \`key=value\`.
-{{#if spawns}}output(*ids, format?="raw", offset?=None, limit?=None) → str | dict | list[dict]
-    Task/agent output by id. Reads immediately: running tasks return their status; \`format\` \`"raw"\` = full, \`"tail"\` = trailing.
-{{/if}}tool.<name>(args) → { text, images?, details?, hasError? }
-    Invoke any session tool; image results (e.g. \`tool.read\` on a png) arrive in \`images[i]\` as { mimeType, dataBase64 }.
-tool_schema(name?) → dict
-    Parameter schema of a tool (omit \`name\` to list tool names); a failed \`tool.<name>()\` call also returns the expected parameters.
-completion(prompt, model?="default", system?=None, schema?=None) → str | dict
-    Oneshot, stateless. \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → parsed structured output.
-{{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, handle?=False) → str | dict
-    Run a subagent → final output. \`agent\` picks a discovered agent. \`schema\` as in completion(). \`handle\` → workflow node { text, output, handle: \`agent://<id>\`, id, agent } (parsed under \`data\` with \`schema\`).
-{{/if}}parallel(thunks) → list
-    Thunks through a bounded pool (as wide as a \`task\` batch), input order kept; a throwing thunk propagates.
-pipeline(items, ...stages) → list
-    Map items through one-arg stages with a barrier between stages; each stage receives the previous stage's result.
-log(message) → None
-    Progress line above the status tree.
-phase(title) → None
-    Phase grouping subsequent status lines.
-\`\`\`
-</prelude>
-{{#if spawns}}
-<workflow>
-Multi-agent work is an acyclic graph in code: one \`agent(…)\` node per step with its handle option ({{#if py}}\`handle=True\`{{/if}}{{#ifAll py js}} / {{/ifAll}}{{#if js}}\`{ handle: true }\`{{/if}}{{#if jl}}{{#ifAny py js}} / {{/ifAny}}\`handle=true\`{{/if}}), \`parallel(thunks)\` for independent nodes, \`pipeline(items, *stages)\` for staged waves. Pass an upstream node's \`handle\` or \`output\` (or a \`write("local://…")\` URI for bulk text) into dependents instead of re-inlining transcripts, and wrap risky nodes in try/except so a failure aborts only its subtree.
-</workflow>
-{{/if}}
-`;
 
 export function buildEvalPrompt(
 	enabled: EnabledLanguages,
@@ -167,6 +95,7 @@ export function buildEvalPrompt(
 		jsBun: options.jsRuntime?.name === "bun",
 		jsVersion: options.jsRuntime?.version ?? "",
 		bunSkillPath: options.bunSkillPath ?? "",
+		runBudgetSeconds: String(options.runBudgetSeconds ?? DEFAULT_RUN_BUDGET_SECONDS),
 	};
 	const description = renderTemplate(EVAL_PROMPT_TEMPLATE, context)
 		.replace(/\n{3,}/g, "\n\n")
@@ -197,7 +126,7 @@ const BATCHING_GUIDELINES: Record<EvalEmphasisStyle, string> = {
 	claude:
 		"Prefer eval for a step's independent calls: one cell runs them together and keeps every failure in its result.",
 	codex: "Route a step's independent calls through one eval cell and inspect every result; a direct tool call is right when one call is sufficient.",
-	gpt: "Use eval to batch a step's independent tool calls in one cell and inspect every result; long cells detach on timeout and notify on completion, so do not poll.",
+	gpt: "Use eval to batch a step's independent tool calls in one cell and inspect every result; long cells detach on their own and notify on completion, so do not poll.",
 	kimi: "Put a step's independent calls into one eval cell with parallel(thunks) and keep every failed item in the result.",
 };
 

package/src/timeouts/run-budget.ts

@@ -0,0 +1,107 @@
+import type { TimeoutPauseHandle } from "./idle-timeout.ts";
+
+export interface RunBudgetEvent {
+	readonly cellId: string;
+	readonly budgetMs: number;
+	readonly error: Error;
+}
+
+export interface RunBudgetOptions {
+	readonly cellId: string;
+	readonly budgetMs: number;
+	readonly onExhausted: (event: RunBudgetEvent) => void;
+}
+
+export function runBudgetError(cellId: string, budgetSeconds: number): Error {
+	const error = new Error(
+		`Eval cell ${cellId} exhausted its ${budgetSeconds}s run budget (own execution time; host tool calls excluded) and was killed.`,
+	);
+	error.name = "TimeoutError";
+	return error;
+}
+
+/**
+ * Bounds a cell's own execution time. Unlike the idle watchdog it accumulates across host tool
+ * calls instead of restarting after each one, and time spent parked on a bridge call is never
+ * charged, so a long `agent()` wait survives while a runaway loop or child process does not.
+ */
+export class RunBudget implements TimeoutPauseHandle {
+	readonly budgetMs: number;
+	readonly #cellId: string;
+	readonly #onExhausted: (event: RunBudgetEvent) => void;
+	#chargedMs = 0;
+	#runningSinceMs: number | undefined;
+	#pauseDepth = 0;
+	#timer: ReturnType<typeof setTimeout> | undefined;
+	#settled = false;
+
+	constructor(options: RunBudgetOptions) {
+		this.#cellId = options.cellId;
+		this.budgetMs = Math.max(1, Math.floor(options.budgetMs));
+		this.#onExhausted = options.onExhausted;
+		this.#start();
+	}
+
+	get consumedMs(): number {
+		const running = this.#runningSinceMs === undefined ? 0 : Date.now() - this.#runningSinceMs;
+		return this.#chargedMs + running;
+	}
+
+	pause(): void {
+		if (this.#settled) return;
+		this.#pauseDepth++;
+		if (this.#pauseDepth !== 1) return;
+		this.#chargedMs = this.consumedMs;
+		this.#runningSinceMs = undefined;
+		this.#clearTimer();
+	}
+
+	resume(): void {
+		if (this.#settled || this.#pauseDepth === 0) return;
+		this.#pauseDepth--;
+		if (this.#pauseDepth > 0) return;
+		this.#start();
+	}
+
+	dispose(): void {
+		if (this.#settled) return;
+		this.#settled = true;
+		this.#clearTimer();
+	}
+
+	#start(): void {
+		this.#runningSinceMs = Date.now();
+		this.#arm(this.budgetMs - this.#chargedMs);
+	}
+
+	#arm(delayMs: number): void {
+		this.#clearTimer();
+		const timer = setTimeout(() => this.#expire(), Math.max(0, delayMs));
+		timer.unref?.();
+		this.#timer = timer;
+	}
+
+	#clearTimer(): void {
+		if (this.#timer === undefined) return;
+		clearTimeout(this.#timer);
+		this.#timer = undefined;
+	}
+
+	#expire(): void {
+		this.#timer = undefined;
+		if (this.#settled || this.#pauseDepth > 0) return;
+		const remainingMs = this.budgetMs - this.consumedMs;
+		if (remainingMs > 0) {
+			this.#arm(remainingMs);
+			return;
+		}
+		this.#settled = true;
+		this.#chargedMs = this.consumedMs;
+		this.#runningSinceMs = undefined;
+		this.#onExhausted({
+			cellId: this.#cellId,
+			budgetMs: this.budgetMs,
+			error: runBudgetError(this.#cellId, this.budgetMs / 1_000),
+		});
+	}
+}

package/src/tool/cell-deadlines.ts

@@ -0,0 +1,76 @@
+import type { TimeoutPauseHandle } from "../timeouts/idle-timeout.ts";
+import { RunBudget } from "../timeouts/run-budget.ts";
+
+export type CellDeadlineKind = "hard-limit" | "run-budget";
+
+export interface CellDeadlineExpiry {
+	readonly kind: CellDeadlineKind;
+	readonly error: Error;
+}
+
+export interface CellDeadlinesOptions {
+	readonly cellId: string;
+	readonly hardLimitSeconds: number;
+	readonly runBudgetSeconds: number;
+	readonly onExpire: (expiry: CellDeadlineExpiry) => void;
+}
+
+export function hardLimitError(cellId: string, hardLimitSeconds: number): Error {
+	const error = new Error(`Eval cell ${cellId} was killed at the ${hardLimitSeconds}s hard limit.`);
+	error.name = "TimeoutError";
+	return error;
+}
+
+/**
+ * The two kill deadlines every cell carries from creation to settlement, detached or not: the
+ * wall-clock hard limit, which nothing pauses, and the run budget, which charges only the cell's
+ * own execution time and is paused while a host bridge call is in flight. Whichever expires first
+ * ends the cell; the other is disarmed with it.
+ */
+export class CellDeadlines implements TimeoutPauseHandle {
+	readonly hardLimitSeconds: number;
+	readonly runBudgetSeconds: number;
+	readonly #onExpire: (expiry: CellDeadlineExpiry) => void;
+	readonly #runBudget: RunBudget;
+	#hardLimitTimer: ReturnType<typeof setTimeout> | undefined;
+	#settled = false;
+
+	constructor(options: CellDeadlinesOptions) {
+		this.hardLimitSeconds = options.hardLimitSeconds;
+		this.runBudgetSeconds = options.runBudgetSeconds;
+		this.#onExpire = options.onExpire;
+		const hardLimitTimer = setTimeout(
+			() => this.#expire({ kind: "hard-limit", error: hardLimitError(options.cellId, options.hardLimitSeconds) }),
+			options.hardLimitSeconds * 1_000,
+		);
+		hardLimitTimer.unref?.();
+		this.#hardLimitTimer = hardLimitTimer;
+		this.#runBudget = new RunBudget({
+			cellId: options.cellId,
+			budgetMs: options.runBudgetSeconds * 1_000,
+			onExhausted: ({ error }) => this.#expire({ kind: "run-budget", error }),
+		});
+	}
+
+	pause(): void {
+		this.#runBudget.pause();
+	}
+
+	resume(): void {
+		this.#runBudget.resume();
+	}
+
+	clear(): void {
+		if (this.#settled) return;
+		this.#settled = true;
+		if (this.#hardLimitTimer !== undefined) clearTimeout(this.#hardLimitTimer);
+		this.#hardLimitTimer = undefined;
+		this.#runBudget.dispose();
+	}
+
+	#expire(expiry: CellDeadlineExpiry): void {
+		if (this.#settled) return;
+		this.clear();
+		this.#onExpire(expiry);
+	}
+}