@code-yeongyu/senpi-codemode 2026.9.3 → 2026.9.4-3

package/CHANGELOG.md

@@ -12,6 +12,76 @@
 
 ### Removed
 
+## [2026.9.4-3] - 2026-09-04
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- The package `test` script runs `vitest run test/` instead of `npx tsx …/vitest/dist/cli.js`, matching every other workspace package. The old form spawned npm and tsx to reach the vitest CLI that is already a direct dependency.
+### Fixed
+
+### Removed
+
+## [2026.9.4-2] - 2026-09-04
+
+### Breaking Changes
+
+### Added
+
+- `foregroundWindowSeconds` codemode setting (default `60`, env `SENPI_CODEMODE_FOREGROUND_SECONDS`): the longest an interactive `eval` call blocks the turn before the cell detaches. A larger `timeout` now frees the turn at this window while the cell keeps running to the hard limit, instead of blocking the agent loop for the whole `timeout`.
+
+### Changed
+
+- The Bun kernel line of the `eval` description now names `new Bun.WebView()` as the headless browser and states when to reach for it (a page that needs JS, a login, or a screenshot) instead of `curl` or a browser CLI. The line previously advertised `Bun.*` builtins generically, so sessions on a Bun kernel resolved page work to `curl`/`fetch` and never discovered the in-process browser. Node kernels are unchanged.
+- The `eval` tool description is dieted a second time: the `Fields:` list now defers to the parameter schema (its single home), the detach guidance is one paragraph, and helper lines keep every signature with fewer words. gpt/codex dialect 1,489 -> 1,087 o200k tokens (description + guidelines); claude 1,173, kimi 1,190, default 1,189. Also fixes the fused `jl` handle form in the all-languages render.
+
+- The `eval` tool description is dieted from ~2002 to ~1588 tokens (codex dialect): the three reuse-chain JSON examples, the `<workflow>` graph prose, the repeated state-persistence rules, and the per-dialect wait-doctrine clause are removed or folded; every helper signature and dialect routing is kept. The workflow block's fused `handle=True{ handle: true }` is fixed into per-language correct forms.
+
+### Fixed
+
+### Removed
+
+## [2026.9.4] - 2026-09-04
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.3-3] - 2026-09-03
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.3-2] - 2026-09-03
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- JavaScript eval cells no longer leak child-process output onto the host terminal under Bun: `Bun.$` commands awaited without `.quiet()`/`.text()` and `Bun.spawn` children with the default stderr now route their output into the cell's stdout/stderr streams instead of the inherited fd 1/2 that the interactive TUI owns.
+
+### Removed
+
 ## [2026.9.3] - 2026-09-03
 
 ### Breaking Changes
@@ -209,6 +279,7 @@
 
 ### Fixed
 
+- An explicit `timeout` no longer silently disables detach for interactive `eval` cells. Previously `timeout` was both the detach budget and the hard-limit extension with no cap, so a call like `timeout: 7000` (intended to keep a long detached cell alive) blocked the agent loop for ~2h before the hard limit killed it. The detach point is now capped at the foreground window; `on_timeout: "error"` (and print/json) keep `timeout` as the unclamped deadline, and the hard-limit extension (`max(hardLimitSeconds, timeout)`) is unchanged.
 - Detached-eval same-language busy errors now name each idle enabled kernel and tell the agent to continue the step there (`continue this step in an idle kernel: js`), instead of only pointing at peek and the output tail. A busy Python kernel no longer reads as "eval is unavailable", which previously sent agents to `bash`+`python3` while JavaScript (or another idle kernel) was free. Single-language sessions and fully-busy sessions omit the idle-kernel claim.
 - JavaScript eval cells now persist only top-level declarations, including destructuring bindings and uninitialized variables, without rewriting declaration-shaped text inside literals or comments.
 - Eval completion and detached-cell handling retain explicit lifecycle observability: nested tool counts, wall/kernel timing, detach state, `peek`, `stop`, hard limits, and crash recovery remain bounded and machine-readable for hosts and telemetry consumers.

package/README.md

@@ -71,6 +71,7 @@ Configuration is loaded in this order:
     "jl": false
   },
   "cellTimeoutSeconds": 30,
+  "foregroundWindowSeconds": 60,
   "parallelPoolWidth": 4,
   "taskTools": {
     "task": "task",
@@ -88,6 +89,7 @@ Configuration is loaded in this order:
 | --- | --- | --- |
 | `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`. |
 | `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()`. |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.3",
+	"version": "2026.9.4-3",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -16,7 +16,7 @@
 		"LICENSE"
 	],
 	"scripts": {
-		"test": "npx tsx ../../node_modules/vitest/dist/cli.js --run test/",
+		"test": "vitest run test/",
 		"clean": "node -e \"\"",
 		"build": "node -e \"\""
 	},
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.3",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.4-3",
 		"typebox": "1.3.18"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.3"
+		"@code-yeongyu/senpi": "2026.9.4-3"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.3"
+		"@code-yeongyu/senpi": "2026.9.4-3"
 	},
 	"keywords": [
 		"senpi",

package/src/config/settings.ts

@@ -19,6 +19,7 @@ export const codemodeSettingsSchema = Type.Object(
 			),
 		),
 		cellTimeoutSeconds: Type.Optional(Type.Number({ minimum: 1 })),
+		foregroundWindowSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		hardLimitSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		parallelPoolWidth: Type.Optional(Type.Number({ minimum: 1 })),
 		taskTools: Type.Optional(
@@ -64,6 +65,13 @@ export interface CodemodeSettings {
 		readonly jl: boolean;
 	};
 	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.
+	 */
+	readonly foregroundWindowSeconds: number;
 	/** Wall-clock kill deadline for a single cell; bounds detached cells too. */
 	readonly hardLimitSeconds: number;
 	readonly parallelPoolWidth: number;
@@ -98,6 +106,16 @@ export const DEFAULT_HARD_LIMIT_SECONDS = 1800;
 
 export const HARD_LIMIT_ENVIRONMENT_FLAG = "SENPI_CODEMODE_HARD_LIMIT_SECONDS";
 
+/**
+ * Bash parity: `terminal/tools/foreground-window.ts` auto-detaches a still-running bash command to a
+ * background session at 60s regardless of its `timeout` kill deadline. An eval cell gets the same
+ * default foreground window so a large `timeout` extends the cell's lifetime without holding the turn
+ * hostage for hours.
+ */
+export const DEFAULT_FOREGROUND_WINDOW_SECONDS = 60;
+
+export const FOREGROUND_WINDOW_ENVIRONMENT_FLAG = "SENPI_CODEMODE_FOREGROUND_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 = {
@@ -108,6 +126,7 @@ export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
 		jl: false,
 	},
 	cellTimeoutSeconds: 30,
+	foregroundWindowSeconds: DEFAULT_FOREGROUND_WINDOW_SECONDS,
 	hardLimitSeconds: DEFAULT_HARD_LIMIT_SECONDS,
 	parallelPoolWidth: 4,
 	taskTools: {
@@ -166,6 +185,15 @@ export function resolveHardLimitSeconds(settings: CodemodeSettings, env: Environ
 	return parsed;
 }
 
+/** 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;
+}
+
 async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
 	const raw = await readFile(path, "utf8");
 	let parsed: unknown;
@@ -200,6 +228,7 @@ function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
 			jl: input.languages?.jl ?? defaultCodemodeSettings.languages.jl,
 		},
 		cellTimeoutSeconds: input.cellTimeoutSeconds ?? defaultCodemodeSettings.cellTimeoutSeconds,
+		foregroundWindowSeconds: input.foregroundWindowSeconds ?? defaultCodemodeSettings.foregroundWindowSeconds,
 		hardLimitSeconds: input.hardLimitSeconds ?? defaultCodemodeSettings.hardLimitSeconds,
 		parallelPoolWidth: input.parallelPoolWidth ?? defaultCodemodeSettings.parallelPoolWidth,
 		taskTools: {

package/src/index.ts

@@ -3,7 +3,7 @@ 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, resolveHardLimitSeconds } from "./config/settings.ts";
+import { defaultCodemodeSettings, resolveForegroundWindowSeconds, resolveHardLimitSeconds } 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";
@@ -64,6 +64,15 @@ export interface SenpiCodemodeOptions {
 	readonly now?: () => number;
 }
 
+/** Whether the session registry holds `monitor`; false when the runtime cannot be read yet. */
+function monitorIsRegistered(pi: CodemodeExtensionAPI): boolean {
+	try {
+		return pi.getAllTools().some((tool) => tool.name === "monitor");
+	} catch {
+		return false;
+	}
+}
+
 export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
@@ -108,11 +117,17 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			pi.rpc?.emit(EVAL_EXECUTION_EVENT, toEvalExecutionRpcPayload(payload));
 			pi.events?.emit(EVAL_EXECUTION_EVENT, payload);
 		};
+		// `listTools` below survives because it is lazy; this read is eager, and the loader's
+		// action methods throw while extensions are still loading (the bundled codemode path
+		// reaches this before the runtime is bound). An unreadable registry means "do not teach
+		// a tool we cannot confirm"; session_start / model_select re-register once it is live.
+		const monitor = monitorIsRegistered(pi);
 		pi.registerTool(
 			createEvalTool({
 				enabledLanguages: runtime.enabledLanguages,
 				kernelManager: manager,
 				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
+				foregroundWindowSeconds: resolveForegroundWindowSeconds(runtime.settings),
 				executeTool: runtime.executeTool,
 				listTools: () => pi.getAllTools(),
 				complete,
@@ -122,6 +137,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 				executionTracker: manager,
 				onCellSettled,
 				renderers,
+				monitor,
 				spawns: runtime.spawns,
 				spawnDefaultAgent: runtime.settings.taskTools.task,
 				hostLine: hostLine(),
@@ -146,6 +162,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			enabledLanguages: { py: true, js: true, rb: true, jl: true },
 			kernelManager: manager,
 			cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
+			foregroundWindowSeconds: resolveForegroundWindowSeconds(defaultCodemodeSettings),
 			executeTool: createExecuteTool(pi),
 			listTools: () => pi.getAllTools(),
 			complete,
@@ -159,6 +176,8 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			}),
 			executionTracker: manager,
 			renderers,
+			// The baseline tool is registered before extensions such as monitor load.
+			monitor: false,
 			hostLine: hostLine(),
 			runtimes: { js: jsRuntimeInfo() },
 			...(bunSkillPath === undefined ? {} : { bunSkillPath }),

package/src/kernels/js/worker-runtime.js

@@ -3,6 +3,7 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { inspect } from "node:util";
 import { awaitMaybePromise, indirectEval, wrapUserCode } from "./worker-indirect-eval.js";
+import { installShellCapture } from "./worker-shell-capture.js";
 
 const PREPARED_CELL_PREFIX = "/*senpi:prepared-cell*/";
 const INTERNAL_URL = /^([a-z][a-z0-9+.-]*):\/\/(.*)$/iu;
@@ -84,11 +85,16 @@ export class JsWorkerRuntime {
 		process.stderr.write = routeWrite(process.stderr, originalStderrWrite, "stderr");
 		console.log = (...values) => this.#emitText("stdout", `${values.map(formatValue).join(" ")}\n`);
 		console.error = (...values) => this.#emitText("stderr", `${values.map(formatValue).join(" ")}\n`);
+		const restoreShellCapture = installShellCapture({
+			isActive: () => this.#hooks !== null,
+			emitText: (stream, data) => this.#emitText(stream, data),
+		});
 		globalThis.__senpi_restore_console__ = () => {
 			console.log = originalLog;
 			console.error = originalError;
 			process.stdout.write = originalStdoutWrite;
 			process.stderr.write = originalStderrWrite;
+			restoreShellCapture();
 		};
 	}
 

package/src/kernels/js/worker-shell-capture.d.ts

@@ -0,0 +1,10 @@
+export type ShellCaptureStream = "stdout" | "stderr";
+
+export type ShellCaptureRestore = () => void;
+
+export interface ShellCaptureOptions {
+	readonly isActive: () => boolean;
+	readonly emitText: (stream: ShellCaptureStream, data: string) => void;
+}
+
+export function installShellCapture(options: ShellCaptureOptions): ShellCaptureRestore;

package/src/kernels/js/worker-shell-capture.js

@@ -0,0 +1,126 @@
+const SHELL_CONFIG_METHODS = ["env", "cwd", "nothrow", "throws"];
+const SHELL_READ_METHODS = ["text", "json", "lines", "arrayBuffer", "bytes", "blob"];
+
+export function installShellCapture(options) {
+	const bun = globalThis.Bun;
+	if (!isBunRuntime(bun)) return () => {};
+	const originalShell = bun.$;
+	const originalSpawn = bun.spawn;
+	bun.$ = capturedShell(originalShell, options);
+	bun.spawn = capturedSpawn(originalSpawn, options);
+	return () => {
+		bun.$ = originalShell;
+		bun.spawn = originalSpawn;
+	};
+}
+
+function isBunRuntime(bun) {
+	return bun !== null && typeof bun === "object" && typeof bun.$ === "function" && typeof bun.spawn === "function";
+}
+
+function capturedShell(originalShell, options) {
+	const shell = (strings, ...expressions) => {
+		const promise = originalShell(strings, ...expressions);
+		return options.isActive() ? captureShellPromise(promise, options.emitText) : promise;
+	};
+	for (const key of Object.keys(originalShell)) shell[key] = originalShell[key];
+	for (const method of SHELL_CONFIG_METHODS) {
+		shell[method] = (...args) => {
+			originalShell[method](...args);
+			return shell;
+		};
+	}
+	return shell;
+}
+
+function captureShellPromise(promise, emitText) {
+	const prototype = Object.getPrototypeOf(promise);
+	let echo = true;
+	const echoOnce = (output) => {
+		if (!echo) return;
+		echo = false;
+		emitShellOutput(output, emitText);
+	};
+	prototype.quiet.call(promise);
+	promise.quiet = function quiet() {
+		echo = false;
+		return prototype.quiet.call(this);
+	};
+	for (const method of SHELL_READ_METHODS) {
+		if (typeof prototype[method] !== "function") continue;
+		promise[method] = function read(...args) {
+			echo = false;
+			return prototype[method].apply(this, args);
+		};
+	}
+	promise.then = function then(onFulfilled, onRejected) {
+		return prototype.then.call(
+			this,
+			(output) => {
+				echoOnce(output);
+				return onFulfilled ? onFulfilled(output) : output;
+			},
+			(error) => {
+				echoOnce(error);
+				if (onRejected) return onRejected(error);
+				throw error;
+			},
+		);
+	};
+	return promise;
+}
+
+function emitShellOutput(output, emitText) {
+	if (output === null || typeof output !== "object") return;
+	const stdout = outputText(output.stdout);
+	if (stdout) emitText("stdout", stdout);
+	const stderr = outputText(output.stderr);
+	if (stderr) emitText("stderr", stderr);
+}
+
+function outputText(value) {
+	if (value instanceof Uint8Array) return new TextDecoder().decode(value);
+	return typeof value === "string" ? value : "";
+}
+
+function capturedSpawn(originalSpawn, options) {
+	return (...args) => {
+		if (!options.isActive()) return originalSpawn(...args);
+		const [first, second] = args;
+		if (Array.isArray(first)) {
+			const spawnOptions = second === undefined ? {} : second;
+			if (!needsStderrCapture(spawnOptions)) return originalSpawn(...args);
+			return drainStderr(originalSpawn(first, { ...spawnOptions, stderr: "pipe" }), options.emitText);
+		}
+		if (!needsStderrCapture(first)) return originalSpawn(...args);
+		return drainStderr(originalSpawn({ ...first, stderr: "pipe" }), options.emitText);
+	};
+}
+
+function needsStderrCapture(spawnOptions) {
+	return (
+		spawnOptions !== null &&
+		typeof spawnOptions === "object" &&
+		spawnOptions.stdio === undefined &&
+		spawnOptions.stderr === undefined
+	);
+}
+
+function drainStderr(child, emitText) {
+	const stream = child?.stderr;
+	if (!(stream instanceof ReadableStream)) return child;
+	void readStream(stream, emitText).catch((error) => {
+		emitText("stderr", `[spawn stderr capture failed: ${String(error)}]\n`);
+	});
+	return child;
+}
+
+async function readStream(stream, emitText) {
+	const decoder = new TextDecoder();
+	for await (const chunk of stream) {
+		const text = decoder.decode(chunk, { stream: true });
+		if (text) emitText("stderr", text);
+	}
+	const tail = decoder.decode();
+	if (tail) emitText("stderr", tail);
+}

package/src/prompt/eval-prompt.ts

@@ -15,6 +15,8 @@ export interface EvalPromptParts {
 
 export interface EvalPromptOptions {
 	readonly spawns: boolean;
+	/** Whether the session registry exposes the monitor tool through eval. */
+	readonly monitor?: boolean;
 	readonly spawnDefaultAgent?: string;
 	/** Active model id; selects the emphasis dialect of the batching guidance. */
 	readonly modelId?: string;
@@ -62,86 +64,48 @@ export function evalEmphasisStyle(modelId: string | undefined): EvalEmphasisStyl
 
 type ContextValue = string | boolean;
 type Context = Readonly<Record<string, ContextValue>>;
-type EvalPromptExample = {
-	readonly caption: string;
-	readonly language: keyof EnabledLanguages;
-	readonly summary: string;
-	readonly code: string;
-};
-
-// senpi ToolDefinition has no examples field, so description embeds the examples.
-// ADAPTATION: payloads diverge from omp's json-config chain to teach batch read,
-// comprehension filtering, and parallel tool.<name> fan-out while keeping the
-// three-cell reuse narrative.
-const REUSE_CHAIN_EXAMPLES = [
-	{
-		caption: "First call — set up once",
-		language: "js",
-		summary: "Count all TypeScript source files under src/ excluding tests",
-		code: "import { readdir } from 'node:fs/promises'\nimport { extname } from 'node:path'\nconst files = (await readdir('src', { recursive: true })).filter(f => extname(f) === '.ts' && !f.includes('test'))\nprint(files.length)",
-	},
-	{
-		caption: "Second call — reuse `files`, fan out session tools in parallel",
-		language: "js",
-		summary: "Grep legacyClient per directory in one cell",
-		code: "const dirs = [...new Set(files.map(f => f.split('/')[0]))]\nconst hits = await Promise.all(dirs.map(d => tool.grep({ pattern: 'legacyClient', path: d })))\ndisplay(hits.map(h => h.matches?.length ?? 0))",
-	},
-	{
-		caption: "JS kernel is busy with a detached cell — continue in py",
-		language: "py",
-		summary: "Aggregate legacyClient hits while JS is busy",
-		code: "from pathlib import Path\nprint(sum('legacyClient' in read(p) for p in Path('src').rglob('*.ts')))",
-	},
-] as const satisfies readonly EvalPromptExample[];
-
 const EVAL_PROMPT_TEMPLATE = `Run one step of code in a persistent kernel.
 
 <instruction>
-**One eval call = one cell = one logical step.** State persists per language across separate eval calls and tool calls{{#if spawns}}, and \`task\` subagents{{/if}} — define helpers, datasets, and clients in one call, then later calls reuse them directly.
-
-Work incrementally: imports in one call, define in the next, test, then use — each its own eval call. Re-run setup ONLY after \`reset\`, a kernel crash, or a \`NameError\`/\`ReferenceError\` proving the state is gone.
+**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>
 \`eval\` is your default execution surface: if a step needs more than one tool call, write ONE cell that performs the whole step — never issue the calls one at a time.
 - Enumerate every lookup the step needs, then run all independent ones simultaneously with \`parallel(thunks)\` inside the cell; keep calls sequential only when one result feeds the next.
 - Write real code around the calls: loop or comprehend over file sets with \`read()\`/stdlib, branch per case, and wrap risky calls in try/except so one failure degrades only its item — recover or retry inside the cell, keep the batch alive.
-- Post-process \`tool.<name>()\` results programmatically and return distilled facts, not raw dumps.
+- Post-process \`tool.<name>()\` results programmatically — filter, join, aggregate — and return distilled facts, not raw dumps.
+{{#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: compose multi-tool work inside one cell with \`tool.<name>(args)\` and \`parallel(thunks)\`; do not split a planned step into serial tool calls.
-- Long pure-compute cells detach on timeout and notify on completion. Do not poll or re-run them; use \`eval({ action: "peek"|"stop", cell_id })\` only to inspect or stop a detached cell.
-- Reduce tool results in the cell and return only decision-relevant facts.
+- Long cells detach on timeout and notify on completion; do not poll or re-run them.
+- Filter, join, and aggregate tool results in the cell; return only decision-relevant facts.
+{{#if monitor}}- For long-running build, test run, deploy, or watch work, start \`tool.monitor({ command, filter })\` with the decisive-line filter in the same cell; keep working until its event wakes the turn.{{/if}}
 </gpt_eval_dialect>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
-- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
+- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically — filter, join, aggregate.
 - Wrap failable calls in try/except inside the cell; a failed item degrades only itself. After two distinct failed strategies for the same fact, fall back to direct tool calls.
-- Reduce large results in-kernel to the facts the task needs before returning.{{/if}}{{#if styleKimi}}**EVAL IS YOUR SUPERPOWER — MAKE IT YOUR DEFAULT WAY TO ACT.** Before any step, think: "how do I execute this WHOLE step in ONE parallelized cell?" — then write that ONE cell.
+- Reduce large results in-kernel to the facts the task needs before returning.
+{{#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}}**EVAL IS YOUR SUPERPOWER — MAKE IT YOUR DEFAULT WAY TO ACT.** Before any step, think: "how do I execute this WHOLE step in ONE parallelized cell?" — then write that ONE cell.
 - **BATCH EVERYTHING AT ONCE:** enumerate EVERY independent lookup the step needs and dispatch them ALL simultaneously with \`parallel(thunks)\` in that cell; keep calls sequential only when one result feeds the next.
 - **WRITE REAL CODE, NOT CALL CHAINS:** loop or comprehend over file sets with \`read()\`/stdlib, post-process \`tool.<name>()\` results programmatically, and put try/except around each risky call so the rest of the batch completes.
-- **DISTILL IN-KERNEL:** filter and aggregate results in code, then return ONLY the distilled facts.{{/if}}{{#if styleDefault}}**EVAL IS YOUR PRIMARY EXECUTION SURFACE.** Any step that needs MORE THAN ONE tool call MUST be written as ONE cell — NEVER as a chain of single tool calls.
+- **DISTILL IN-KERNEL:** filter, join, and aggregate \`tool.<name>()\` results in code, then return ONLY the distilled facts.
+{{#if monitor}}- **DO 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}}**EVAL IS YOUR PRIMARY EXECUTION SURFACE.** Any step that needs MORE THAN ONE tool call MUST be written as ONE cell — NEVER as a chain of single tool calls.
 - **PLAN THE WHOLE STEP, THEN BATCH IT.** Enumerate every read/search/lookup the step needs and dispatch ALL independent ones through \`parallel(thunks)\` in one cell.
 - **WRITE REAL CODE, NOT CALL LISTS.** Loop or comprehend over file sets with \`read()\`/stdlib, branch \`if\`/\`else\` per case, post-process \`tool.<name>()\` results programmatically, and wrap EVERY risky call in try/except so ONE failure NEVER kills the batch.
-- **DISTILL IN-KERNEL.** Filter, diff, and aggregate in code before returning; return facts, NOT dumps.{{/if}}
+- **DISTILL IN-KERNEL.** Filter, join, diff, and aggregate in code before returning; return facts, NOT dumps.
+{{#if monitor}}- **LONG-RUNNING build, test run, deploy, or watch work MUST start 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}}
 
-Fields:
-
-- \`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}}.
-- \`code\` — cell body, verbatim. Newlines/quotes JSON-encoded; no fences, no headers.
-- \`summary\` (REQUIRED for run) — ONE line in the USER'S conversational language stating WHAT this cell does and FOR WHAT PURPOSE (e.g. Korean conversation -> "src 전체에서 legacyClient 사용처 집계"); shown in the TUI while the cell runs; >80 chars is force-truncated.
-- \`timeout\` (optional) — seconds. Raise only for heavy compute or long{{#if spawns}} non-agent{{/if}} tool calls.
-- \`on_timeout\` (optional) — \`"detach"\` keeps pure computation running in interactive sessions (the default); \`"error"\` interrupts for deadline-sensitive work and is the print/json default.
-- Every cell is killed at a wall-clock hard limit (default 1800s) that survives detach and is never paused by tool calls; a larger explicit \`timeout\` raises it, and a killed cell notifies you that it hit the limit.
-- \`reset\` (optional) — wipe this language's kernel first.{{#ifAll py js}} Per-language: a \`py\` reset never touches the JS VM.{{/ifAll}}
-- \`action\` (optional) — defaults to \`"run"\`. A detached cell returns its id: use \`eval({ action: "peek", cell_id })\` for buffered output/state or \`eval({ action: "stop", cell_id })\` to cancel it.
+\`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 detached cell keeps its language kernel busy while it finishes; another language can continue. Do not re-run a detached cell: the same-language busy error names its cell id and output tail. Completion arrives as one notification with the final value/error and buffered output. Stopping a cell interrupts its kernel; the stop result states whether kernel state survived or the kernel was restarted and its variables lost.
+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}}Live event loop: use top-level \`await\` directly; \`asyncio.run(…)\` raises "cannot be called from a running event loop".{{/if}}
-{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available.{{#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 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.{{#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. State usually survives a normal error, but a timeout or stop may have restarted the kernel — its message says which. Before rebuilding state, check a sentinel (a variable you defined earlier); only re-establish what is actually gone, since blind re-runs duplicate side effects.
+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>
@@ -156,25 +120,21 @@ read(path, offset?=1, limit?=None) → str
 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 of \`key\`; two → set \`key=value\`, return value.
+    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\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
+    Task/agent output by id. Reads immediately: running tasks return their status; \`format\` \`"raw"\` = full, \`"tail"\` = trailing.
 {{/if}}tool.<name>(args) → unknown
     Invoke any session tool; \`args\` = its parameter object.
 tool_schema(name?) → dict
-    Parameter schema of a tool without calling it; omit \`name\` to list tool names.
-    Use it before calling a tool you have not called before — a failed call also
-    returns the expected parameters, so fix the args and retry in the next cell
-    instead of abandoning eval.
+    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 (no history/tools). \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → structured output, parsed object.
+    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 another discovered agent; omit it to use \`{{spawnDefaultAgent}}\`. \`schema\` as in completion(). Background via \`local://\` files named in the prompt. \`handle\` → workflow node dict { text, output, handle: \`agent://<id>\`, id, agent } (parsed under \`data\` when \`schema\` set).
-{{#if js}}    JS: options are ONE trailing object — agent(prompt, { agent, schema, handle }).
-{{/if}}{{/if}}parallel(thunks) → list
-    Thunks through a bounded pool (wide as a \`task\` batch — don't pre-shrink), input order kept; returns when all finish, a throwing thunk propagates.
+    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 left-to-right, barrier between stages; stage 1 gets the item, later stages the previous result.
+    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
@@ -183,18 +143,10 @@ phase(title) → None
 </prelude>
 {{#if spawns}}
 <workflow>
-Define the workflow spec IN CODE: partition the work into logically distinct steps, one node per step, then wire them as acyclic waves — never hand-author the graph as a single opaque call.
-- **Name nodes.** Capture each \`agent(…, {{#if py}}handle=True{{/if}}{{#if js}}{ handle: true }{{/if}}{{#if jl}}handle=true{{/if}})\` result; carries \`handle\` (\`agent://<id>\`) + \`output\`.
-- **Wire edges by reference.** Put an upstream node's \`handle\`/\`output\` in the dependent stage's prompt — large transcript never re-inlined. Bulk: \`write("local://<name>.md", …)\`, pass the URI.
-- **\`pipeline(items, *stages)\` = staged waves**, barrier between stages (every item clears stage N before any enters N+1). **\`parallel(thunks)\` = one wave** of independent nodes.
-- **Isolate failure.** A raising node re-raises the lowest-index error, aborts its wave; wrap risky nodes in try/except so a failure degrades only its dependent subtree, independent branches finish.
-- **Acyclic only.** A node never waits on its own descendant.
+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}}
-
-<critical>
-Prior top-level names (\`data\`, \`sessions\`, helpers, imports) survive into the next eval call — reuse them; NEVER re-import, re-require, or re-declare a helper. Re-read a file only if it may have changed since the last read.
-</critical>`;
+`;
 
 export function buildEvalPrompt(
 	enabled: EnabledLanguages,
@@ -211,6 +163,7 @@ export function buildEvalPrompt(
 		rb: enabled.rb,
 		jl: enabled.jl,
 		spawns: options.spawns,
+		monitor: options.monitor === true,
 		spawnDefaultAgent,
 		styleClaude: style === "claude",
 		styleCodex: style === "codex",
@@ -222,20 +175,9 @@ export function buildEvalPrompt(
 		jsVersion: options.jsRuntime?.version ?? "",
 		bunSkillPath: options.bunSkillPath ?? "",
 	};
-	const examples = REUSE_CHAIN_EXAMPLES.filter((example) => enabled[example.language])
-		.map((example) => {
-			const call = { language: example.language, summary: example.summary, code: example.code };
-			return `### ${example.caption}\n\`\`\`json\n${JSON.stringify(call, null, 2)}\n\`\`\``;
-		})
-		.join("\n\n");
-	const description = [
-		renderTemplate(EVAL_PROMPT_TEMPLATE, context)
-			.replace(/\n{3,}/g, "\n\n")
-			.trim(),
-		examples === "" ? "" : `<examples>\n${examples}\n</examples>`,
-	]
-		.filter((part) => part !== "")
-		.join("\n\n");
+	const description = renderTemplate(EVAL_PROMPT_TEMPLATE, context)
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
 	return {
 		description,
 		promptSnippet: "Run one incremental code cell in a persistent language kernel.",

package/src/tool/cell-execution.ts

@@ -17,6 +17,12 @@ export interface CellExecutionOptions {
 	readonly callerSignal: AbortSignal;
 	readonly cellId: string;
 	readonly timeoutMs: number;
+	/**
+	 * Caps how long a host-bridge pause may suspend the idle watchdog. When the cell will detach on
+	 * timeout this is set to the foreground window so a bridge-parked cell still frees the turn at the
+	 * window; left undefined (error mode) it keeps the idle-timeout default grace.
+	 */
+	readonly maxPauseGraceMs?: number;
 	readonly timeoutFactory: EvalTimeoutFactory;
 	readonly onTimeout: (error: Error) => void;
 	readonly onAbort: (error: Error) => void;
@@ -46,6 +52,7 @@ export class CellExecution {
 		this.#watchdog = options.timeoutFactory.create({
 			cellId: options.cellId,
 			timeoutMs: options.timeoutMs,
+			...(options.maxPauseGraceMs === undefined ? {} : { maxPauseGraceMs: options.maxPauseGraceMs }),
 			onTimeout: ({ error }) => options.onTimeout(error),
 		});
 		this.#callerSignal.addEventListener("abort", this.#handleCallerAbort, {

package/src/tool/eval-tool-options.ts

@@ -21,6 +21,12 @@ export interface CreateEvalToolOptions {
 	readonly enabledLanguages: EnabledEvalLanguages;
 	readonly kernelManager: EvalKernelManager;
 	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.
+	 */
+	readonly foregroundWindowSeconds?: number;
 	/** Wall-clock kill deadline applied to every cell; only used when this factory creates its own manager. */
 	readonly hardLimitSeconds?: number;
 	readonly executeTool: ExecuteTool;
@@ -36,6 +42,8 @@ export interface CreateEvalToolOptions {
 	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;
 	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalToolDetails>, "renderCall" | "renderResult">;
 	readonly spawns?: boolean;
+	/** Whether the session registry exposes the monitor tool through eval. */
+	readonly monitor?: boolean;
 	readonly spawnDefaultAgent?: string;
 	readonly modelId?: string;
 	readonly hostLine?: string;

package/src/tool/eval-tool.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import type { AgentToolResult, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
-import { defaultCodemodeSettings } from "../config/settings.ts";
+import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } 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";
@@ -28,6 +28,7 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 	const parameters = createEvalInputSchema(options.enabledLanguages);
 	const prompt = buildEvalPrompt(options.enabledLanguages, {
 		spawns: options.spawns ?? false,
+		monitor: options.monitor,
 		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
 		...(options.modelId === undefined ? {} : { modelId: options.modelId }),
 		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
@@ -100,8 +101,19 @@ async function runEvalCell(
 	invocation: EvalCellInvocation,
 ): Promise<AgentToolResult<EvalToolDetails>> {
 	if (invocation.signal.aborted) throw abortError(invocation.signal.reason);
-	const timeoutMs = Math.floor((invocation.input.timeout ?? options.cellTimeoutSeconds) * 1_000);
 	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 };
@@ -130,6 +142,7 @@ async function runEvalCell(
 		callerSignal: invocation.signal,
 		cellId: invocation.cellId,
 		timeoutMs,
+		...(timeoutBehavior === "detach" ? { maxPauseGraceMs: foregroundWindowMs } : {}),
 		timeoutFactory: options.timeoutFactory ?? defaultTimeoutFactory,
 		onTimeout: (error) => {
 			if (timeoutBehavior === "detach" && cellManager.detach(cell)) {

package/src/tool/types.ts

@@ -13,6 +13,12 @@ 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.";
+
+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.";
+
 export interface EvalToolInput {
 	readonly language: EvalLanguage;
 	readonly code: string;
@@ -47,10 +53,10 @@ const fullEvalInputSchema = Type.Object({
 				"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 in seconds." })),
+	timeout: Type.Optional(Type.Number({ minimum: 1, description: TIMEOUT_FIELD_DESCRIPTION })),
 	on_timeout: Type.Optional(
 		Type.Union([Type.Literal("detach"), Type.Literal("error")], {
-			description: "Timeout behavior. Interactive sessions detach by default; print/json sessions error by default.",
+			description: ON_TIMEOUT_FIELD_DESCRIPTION,
 		}),
 	),
 	reset: Type.Optional(Type.Boolean({ description: "Reset this language kernel before running." })),
@@ -83,11 +89,10 @@ export function createEvalInputSchema(enabled: EnabledEvalLanguages): EvalInputS
 						"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 in seconds." })),
+			timeout: Type.Optional(Type.Number({ minimum: 1, description: TIMEOUT_FIELD_DESCRIPTION })),
 			on_timeout: Type.Optional(
 				Type.Union([Type.Literal("detach"), Type.Literal("error")], {
-					description:
-						"Timeout behavior. Interactive sessions detach by default; print/json sessions error by default.",
+					description: ON_TIMEOUT_FIELD_DESCRIPTION,
 				}),
 			),
 			reset: Type.Optional(Type.Boolean({ description: "Reset this language kernel before running." })),