@code-yeongyu/senpi 2026.9.9 → 2026.9.10

package/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/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);
+	}
+}

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

@@ -13,21 +13,28 @@ export const defaultTimeoutFactory: EvalTimeoutFactory = {
 	},
 };
 
+export interface CellIdleWatchdogOptions {
+	readonly timeoutMs: number;
+	/** Caps how long a host-bridge pause may suspend the idle watchdog (the foreground window for a detaching cell). */
+	readonly maxPauseGraceMs: number;
+	readonly onTimeout: (error: Error) => void;
+}
+
 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;
+	/** Interactive calls detach at this idle watchdog; a call that never detaches is bounded by its deadlines alone. */
+	readonly idle?: CellIdleWatchdogOptions;
 	readonly timeoutFactory: EvalTimeoutFactory;
-	readonly onTimeout: (error: Error) => void;
 	readonly onAbort: (error: Error) => void;
 }
 
+const NO_WATCHDOG: TimeoutPauseHandle & { dispose(): void } = {
+	pause(): void {},
+	resume(): void {},
+	dispose(): void {},
+};
+
 export class CellExecution {
 	readonly #callerSignal: AbortSignal;
 	readonly #onAbort: (error: Error) => void;
@@ -49,12 +56,16 @@ export class CellExecution {
 		this.#detachedPromise = new Promise<void>((resolve) => {
 			this.#resolveDetached = resolve;
 		});
-		this.#watchdog = options.timeoutFactory.create({
-			cellId: options.cellId,
-			timeoutMs: options.timeoutMs,
-			...(options.maxPauseGraceMs === undefined ? {} : { maxPauseGraceMs: options.maxPauseGraceMs }),
-			onTimeout: ({ error }) => options.onTimeout(error),
-		});
+		const idle = options.idle;
+		this.#watchdog =
+			idle === undefined
+				? NO_WATCHDOG
+				: options.timeoutFactory.create({
+						cellId: options.cellId,
+						timeoutMs: idle.timeoutMs,
+						maxPauseGraceMs: idle.maxPauseGraceMs,
+						onTimeout: ({ error }) => idle.onTimeout(error),
+					});
 		this.#callerSignal.addEventListener("abort", this.#handleCallerAbort, {
 			once: true,
 		});

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

@@ -15,6 +15,8 @@ export interface EvalDetachedCellSnapshot {
 	readonly interruptNote?: string;
 	/** Set only when the wall-clock kill deadline ended this cell. */
 	readonly hardLimitSeconds?: number;
+	/** Set only when the cell's own execution time exhausted its run budget. */
+	readonly runBudgetSeconds?: number;
 }
 
 export interface EvalDetachedCellNotification {
@@ -38,6 +40,8 @@ export interface EvalDetachedCellManagerOptions {
 	readonly notifier?: EvalDetachedCellNotifier;
 	/** Wall-clock kill deadline in seconds; defaults to the bash-parity 1800s. */
 	readonly hardLimitSeconds?: number;
+	/** Kill deadline for a cell's own execution time in seconds; a per-call `timeout` replaces it. Defaults to 300s. */
+	readonly runBudgetSeconds?: number;
 	readonly onStatusChange?: (entries: readonly EvalDetachedCellStatusEntry[]) => void;
 	/** Receives a full per-source liveness snapshot on every detached-cell transition; used by the goal builtin. */
 	readonly onWakeSourceState?: (state: WakeSourceState) => void;

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

@@ -1,6 +1,7 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
-import { DEFAULT_HARD_LIMIT_SECONDS } from "../config/settings.ts";
+import { DEFAULT_HARD_LIMIT_SECONDS, DEFAULT_RUN_BUDGET_SECONDS } from "../config/settings.ts";
 import type { WakeSourceState } from "../extension/wake-source-state.ts";
+import { type CellDeadlineExpiry, CellDeadlines } from "./cell-deadlines.ts";
 import type {
 	EvalDetachedCellManagerOptions,
 	EvalDetachedCellSnapshot,
@@ -46,18 +47,15 @@ type ManagedCell = {
 	liveResult: LiveResultProvider | undefined;
 	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
 	notificationQueued: boolean;
-	hardLimitSeconds: number;
-	hardLimitTimer: ReturnType<typeof setTimeout> | undefined;
+	readonly deadlines: CellDeadlines;
+	readonly hardLimitSeconds: number;
+	readonly runBudgetSeconds: number;
 	hardLimited: boolean;
-	onHardLimit: ((error: Error) => void) | undefined;
+	runBudgetExhausted: boolean;
+	/** Foreground killer: the still-awaited CellExecution owns interrupting and rejecting its own call; bound from creation so a deadline firing during kernel boot still ends it. */
+	onKill: ((error: Error) => void) | undefined;
 };
 
-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;
-}
-
 export class EvalDetachedCellManager {
 	readonly #artifactsDir: string | undefined;
 	readonly #onStatusChange: ((entries: readonly EvalDetachedCellStatusEntry[]) => void) | undefined;
@@ -67,6 +65,7 @@ export class EvalDetachedCellManager {
 	readonly #notificationQueue: DetachedNotificationQueue;
 	readonly #now: () => number;
 	readonly #hardLimitSeconds: number;
+	readonly #runBudgetSeconds: number;
 
 	constructor(options: EvalDetachedCellManagerOptions = {}) {
 		this.#artifactsDir = options.artifactsDir;
@@ -75,14 +74,18 @@ export class EvalDetachedCellManager {
 		this.#notificationQueue = new DetachedNotificationQueue(options.notifier);
 		this.#now = options.now ?? Date.now;
 		this.#hardLimitSeconds = options.hardLimitSeconds ?? DEFAULT_HARD_LIMIT_SECONDS;
+		this.#runBudgetSeconds = options.runBudgetSeconds ?? DEFAULT_RUN_BUDGET_SECONDS;
 	}
 
-	create(cellId: string, input: EvalToolInput): ManagedCell {
+	create(cellId: string, input: EvalToolInput, onKill?: (error: Error) => void): ManagedCell {
 		const existing = this.#cells.get(cellId);
 		if (existing !== undefined) {
 			if (detachedCellIsActive(existing.state)) throw activeDetachedCellReuseError(existing);
 			this.#cells.delete(cellId);
 		}
+		// An explicit longer per-call timeout raises the deadline, mirroring bash keeping explicit timeouts.
+		const hardLimitSeconds = Math.max(this.#hardLimitSeconds, input.timeout ?? 0);
+		const runBudgetSeconds = input.timeout ?? this.#runBudgetSeconds;
 		const cell: ManagedCell = {
 			cellId,
 			input,
@@ -98,15 +101,23 @@ export class EvalDetachedCellManager {
 			liveResult: undefined,
 			terminalResult: undefined,
 			notificationQueued: false,
-			// An explicit longer per-call timeout raises the deadline, mirroring bash keeping explicit timeouts.
-			hardLimitSeconds: Math.max(this.#hardLimitSeconds, input.timeout ?? 0),
-			hardLimitTimer: undefined,
+			deadlines: new CellDeadlines({
+				cellId,
+				hardLimitSeconds,
+				runBudgetSeconds,
+				onExpire: (expiry) => {
+					const managed = this.#cells.get(cellId);
+					if (managed !== undefined) void this.#expireDeadline(managed, expiry);
+				},
+			}),
+			hardLimitSeconds,
+			runBudgetSeconds,
 			hardLimited: false,
-			onHardLimit: undefined,
+			runBudgetExhausted: false,
+			onKill,
 			terminal: Promise.withResolvers<EvalDetachedCellSnapshot>(),
 		};
 		this.#cells.set(cellId, cell);
-		this.#armHardLimit(cell);
 		return cell;
 	}
 
@@ -114,16 +125,24 @@ export class EvalDetachedCellManager {
 		cell: ManagedCell,
 		kernel: EvalKernel,
 		liveResult: LiveResultProvider,
-		/** Foreground killer: the still-awaited CellExecution owns interrupting and rejecting its own call. */
-		onHardLimit?: (error: Error) => void,
+		onKill?: (error: Error) => void,
 	): void {
 		if (cell.state !== "running") return;
-		cell.onHardLimit = onHardLimit;
+		cell.onKill = onKill ?? cell.onKill;
 		cell.kernel = kernel;
 		cell.liveResult = liveResult;
 		cell.canDetach = true;
 	}
 
+	/** A host bridge call is in flight for this cell; its run budget stops charging until {@link resume}. */
+	pause(cell: ManagedCell): void {
+		cell.deadlines.pause();
+	}
+
+	resume(cell: ManagedCell): void {
+		cell.deadlines.resume();
+	}
+
 	detach(cell: ManagedCell): boolean {
 		if (!cell.canDetach || !allowsDetachedCellTransition(cell.state, "detached")) return false;
 		cell.state = "detached";
@@ -184,7 +203,7 @@ export class EvalDetachedCellManager {
 		result: AgentToolResult<EvalToolDetails>,
 	): boolean {
 		if (!allowsDetachedCellTransition(cell.state, state)) return false;
-		this.#clearHardLimit(cell);
+		cell.deadlines.clear();
 		cell.state = state;
 		cell.terminalResult = result;
 		cell.liveResult = undefined;
@@ -207,32 +226,20 @@ export class EvalDetachedCellManager {
 		return true;
 	}
 
-	#armHardLimit(cell: ManagedCell): void {
-		const timer = setTimeout(() => void this.#expireHardLimit(cell), cell.hardLimitSeconds * 1_000);
-		timer.unref?.();
-		cell.hardLimitTimer = timer;
-	}
-
-	#clearHardLimit(cell: ManagedCell): void {
-		if (cell.hardLimitTimer === undefined) return;
-		clearTimeout(cell.hardLimitTimer);
-		cell.hardLimitTimer = undefined;
-	}
-
 	/**
-	 * The wall-clock kill deadline. Unlike the idle watchdog it is never paused by a bridge tool call and
-	 * survives detach, so it is the only bound a detached cell has.
+	 * A kill deadline fired (see {@link CellDeadlines}). A foreground cell is killed through the
+	 * CellExecution that still awaits it; a detached cell is cancelled here, which interrupts its kernel.
 	 */
-	async #expireHardLimit(cell: ManagedCell): Promise<void> {
+	async #expireDeadline(cell: ManagedCell, expiry: CellDeadlineExpiry): Promise<void> {
 		if (!detachedCellIsActive(cell.state)) return;
-		const foreground = cell.state === "running" && cell.onHardLimit !== undefined;
-		cell.hardLimited = true;
-		const error = hardLimitError(cell.cellId, cell.hardLimitSeconds);
+		const foreground = cell.state === "running" && cell.onKill !== undefined;
+		cell.hardLimited = expiry.kind === "hard-limit";
+		cell.runBudgetExhausted = expiry.kind === "run-budget";
 		if (foreground) {
-			if (this.#settle(cell, "cancelled", currentDetachedResult(cell))) cell.onHardLimit?.(error);
+			if (this.#settle(cell, "cancelled", currentDetachedResult(cell))) cell.onKill?.(expiry.error);
 			return;
 		}
-		await this.#cancel(cell, error.message);
+		await this.#cancel(cell, expiry.error.message);
 	}
 
 	async #cancel(cell: ManagedCell, reason: string): Promise<void> {

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

@@ -69,6 +69,8 @@ function textContent(cell: EvalDetachedCellSnapshot): string {
 
 function outcomeOf(cell: EvalDetachedCellSnapshot): string {
 	if (cell.hardLimitSeconds !== undefined) return `was killed at the ${cell.hardLimitSeconds}s hard limit`;
+	if (cell.runBudgetSeconds !== undefined)
+		return `was killed after exhausting its ${cell.runBudgetSeconds}s run budget (own execution time; host tool calls excluded)`;
 	if (cell.state === "completed") return "completed";
 	if (cell.state === "cancelled") return "cancelled";
 	return "failed";