@code-yeongyu/senpi-codemode 2026.8.12-4 → 2026.8.13

package/CHANGELOG.md

@@ -12,6 +12,20 @@
 
 ### Removed
 
+## [2026.8.13] - 2026-08-13
+
+### Breaking Changes
+
+### Added
+
+- Gave every eval cell a wall-clock hard limit (`hardLimitSeconds`, default 1800s, overridable with `SENPI_CODEMODE_HARD_LIMIT_SECONDS`) so a detached or tool-call-heavy cell can no longer run unbounded: the deadline survives `detach()` and is never paused by bridge tool calls, and a cell it kills reports itself to the agent as killed at the hard limit ([#857](https://github.com/code-yeongyu/senpi/pull/857)).
+
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.8.12-4] - 2026-08-12
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.8.12-4",
+	"version": "2026.8.13",
 	"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.8.12-4",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.8.13",
 		"typebox": "1.3.8"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.8.12-4"
+		"@code-yeongyu/senpi": "2026.8.13"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.8.12-4"
+		"@code-yeongyu/senpi": "2026.8.13"
 	},
 	"keywords": [
 		"senpi",

package/src/config/settings.ts

@@ -19,6 +19,7 @@ export const codemodeSettingsSchema = Type.Object(
 			),
 		),
 		cellTimeoutSeconds: Type.Optional(Type.Number({ minimum: 1 })),
+		hardLimitSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		parallelPoolWidth: Type.Optional(Type.Number({ minimum: 1 })),
 		taskTools: Type.Optional(
 			Type.Object(
@@ -63,6 +64,8 @@ export interface CodemodeSettings {
 		readonly jl: boolean;
 	};
 	readonly cellTimeoutSeconds: number;
+	/** Wall-clock kill deadline for a single cell; bounds detached cells too. */
+	readonly hardLimitSeconds: number;
 	readonly parallelPoolWidth: number;
 	readonly taskTools?: CodemodeTaskTools;
 	readonly outputSink?: CodemodeOutputSink;
@@ -86,6 +89,15 @@ export interface LoadedCodemodeSettings {
 	readonly warnings: readonly string[];
 }
 
+/**
+ * Bash parity: `bash-timeout/timeout.ts` kills a command at 1800s. An eval cell gets the same
+ * unconditional wall-clock kill deadline, which — unlike `cellTimeoutSeconds` — is neither paused by
+ * host tool calls nor discarded when the cell detaches.
+ */
+export const DEFAULT_HARD_LIMIT_SECONDS = 1800;
+
+export const HARD_LIMIT_ENVIRONMENT_FLAG = "SENPI_CODEMODE_HARD_LIMIT_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 = {
@@ -96,6 +108,7 @@ export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
 		jl: false,
 	},
 	cellTimeoutSeconds: 30,
+	hardLimitSeconds: DEFAULT_HARD_LIMIT_SECONDS,
 	parallelPoolWidth: 4,
 	taskTools: {
 		task: "task",
@@ -144,6 +157,15 @@ 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;
+}
+
 async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
 	const raw = await readFile(path, "utf8");
 	let parsed: unknown;
@@ -178,6 +200,7 @@ function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
 			jl: input.languages?.jl ?? defaultCodemodeSettings.languages.jl,
 		},
 		cellTimeoutSeconds: input.cellTimeoutSeconds ?? defaultCodemodeSettings.cellTimeoutSeconds,
+		hardLimitSeconds: input.hardLimitSeconds ?? defaultCodemodeSettings.hardLimitSeconds,
 		parallelPoolWidth: input.parallelPoolWidth ?? defaultCodemodeSettings.parallelPoolWidth,
 		taskTools: {
 			task: input.taskTools?.task ?? defaultCodemodeSettings.taskTools.task,

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 } from "./config/settings.ts";
+import { defaultCodemodeSettings, 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";
@@ -131,6 +131,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			settings: defaultCodemodeSettings,
 			cellManager: new EvalDetachedCellManager({
 				notifier,
+				hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
 				onStatusChange: showDetachedCells,
 				onWakeSourceState: emitWakeSourceState,
 				...(options.now === undefined ? {} : { now: options.now }),
@@ -162,6 +163,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		const cellManager = new EvalDetachedCellManager({
 			artifactsDir: runtime.artifactsDir,
 			notifier,
+			hardLimitSeconds: resolveHardLimitSeconds(runtime.settings),
 			onStatusChange: showDetachedCells,
 			onWakeSourceState: emitWakeSourceState,
 			...(options.now === undefined ? {} : { now: options.now }),

package/src/prompt/eval-prompt.ts

@@ -125,6 +125,7 @@ Fields:
 - \`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.
 

package/src/tool/detached-cell-manager.ts

@@ -1,4 +1,5 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { DEFAULT_HARD_LIMIT_SECONDS } from "../config/settings.ts";
 import { SENPI_CODEMODE_WAKE_SOURCE, type WakeSourceState } from "../extension/wake-source-state.ts";
 import { detachedNotificationSpillPath } from "./detached-cell-notification.ts";
 import { currentDetachedResult, detachedErrorResult, snapshotDetachedCell } from "./detached-cell-snapshot.ts";
@@ -28,6 +29,10 @@ type ManagedCell = {
 	liveResult: LiveResultProvider | undefined;
 	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
 	notificationQueued: boolean;
+	hardLimitSeconds: number;
+	hardLimitTimer: ReturnType<typeof setTimeout> | undefined;
+	hardLimited: boolean;
+	onHardLimit: ((error: Error) => void) | undefined;
 };
 
 export interface EvalDetachedCellSnapshot {
@@ -37,6 +42,8 @@ export interface EvalDetachedCellSnapshot {
 	readonly outputTail: string;
 	readonly result: AgentToolResult<EvalToolDetails>;
 	readonly stateRetained: boolean | undefined;
+	/** Set only when the wall-clock kill deadline ended this cell. */
+	readonly hardLimitSeconds?: number;
 }
 
 export interface EvalDetachedCellNotification {
@@ -58,12 +65,20 @@ export interface EvalDetachedCellStatusEntry {
 export interface EvalDetachedCellManagerOptions {
 	readonly artifactsDir?: string;
 	readonly notifier?: EvalDetachedCellNotifier;
+	/** Wall-clock kill deadline in seconds; defaults to the bash-parity 1800s. */
+	readonly hardLimitSeconds?: 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;
 	readonly now?: () => number;
 }
 
+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;
@@ -72,6 +87,7 @@ export class EvalDetachedCellManager {
 	readonly #detachedByLanguage = new Map<EvalLanguage, ManagedCell>();
 	readonly #notificationQueue: DetachedNotificationQueue;
 	readonly #now: () => number;
+	readonly #hardLimitSeconds: number;
 
 	constructor(options: EvalDetachedCellManagerOptions = {}) {
 		this.#artifactsDir = options.artifactsDir;
@@ -79,6 +95,7 @@ export class EvalDetachedCellManager {
 		this.#onWakeSourceState = options.onWakeSourceState;
 		this.#notificationQueue = new DetachedNotificationQueue(options.notifier, options.artifactsDir);
 		this.#now = options.now ?? Date.now;
+		this.#hardLimitSeconds = options.hardLimitSeconds ?? DEFAULT_HARD_LIMIT_SECONDS;
 	}
 
 	create(cellId: string, input: EvalToolInput): ManagedCell {
@@ -100,14 +117,27 @@ 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,
+			hardLimited: false,
+			onHardLimit: undefined,
 			terminal: Promise.withResolvers<EvalDetachedCellSnapshot>(),
 		};
 		this.#cells.set(cellId, cell);
+		this.#armHardLimit(cell);
 		return cell;
 	}
 
-	markRunning(cell: ManagedCell, kernel: EvalKernel, liveResult: LiveResultProvider): void {
+	markRunning(
+		cell: ManagedCell,
+		kernel: EvalKernel,
+		liveResult: LiveResultProvider,
+		/** Foreground killer: the still-awaited CellExecution owns interrupting and rejecting its own call. */
+		onHardLimit?: (error: Error) => void,
+	): void {
 		if (cell.state !== "running") return;
+		cell.onHardLimit = onHardLimit;
 		cell.kernel = kernel;
 		cell.liveResult = liveResult;
 		cell.canDetach = true;
@@ -179,6 +209,7 @@ export class EvalDetachedCellManager {
 		result: AgentToolResult<EvalToolDetails>,
 	): boolean {
 		if (!allowsDetachedCellTransition(cell.state, state)) return false;
+		this.#clearHardLimit(cell);
 		cell.state = state;
 		cell.terminalResult = result;
 		cell.liveResult = undefined;
@@ -198,6 +229,37 @@ 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.
+	 */
+	async #expireHardLimit(cell: ManagedCell): 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);
+		if (!this.#settle(cell, "cancelled", currentDetachedResult(cell))) return;
+		if (foreground) {
+			cell.onHardLimit?.(error);
+			return;
+		}
+		if (cell.kernel === undefined) return;
+		const handle = await cell.kernel.interrupt(error.message);
+		cell.stateRetained = await handle.stateRetained;
+	}
+
 	#emitStatus(): void {
 		const liveCells = [...this.#detachedByLanguage.values()];
 		this.#onStatusChange?.(

package/src/tool/detached-cell-notification.ts

@@ -66,6 +66,7 @@ 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.state === "completed") return "completed";
 	if (cell.state === "cancelled") return "cancelled";
 	return "failed";

package/src/tool/detached-cell-snapshot.ts

@@ -12,6 +12,8 @@ export interface DetachedCellResultSource {
 	stateRetained: boolean | undefined;
 	liveResult: (() => AgentToolResult<EvalToolDetails>) | undefined;
 	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
+	hardLimited?: boolean;
+	hardLimitSeconds?: number;
 }
 
 export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: number): EvalDetachedCellSnapshot {
@@ -24,6 +26,9 @@ export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: numb
 		outputTail: detachedOutputTail(result),
 		result,
 		stateRetained: cell.stateRetained,
+		...(cell.hardLimited === true && cell.hardLimitSeconds !== undefined
+			? { hardLimitSeconds: cell.hardLimitSeconds }
+			: {}),
 	};
 }
 

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

@@ -19,6 +19,8 @@ export interface CreateEvalToolOptions {
 	readonly enabledLanguages: EnabledEvalLanguages;
 	readonly kernelManager: EvalKernelManager;
 	readonly cellTimeoutSeconds: number;
+	/** Wall-clock kill deadline applied to every cell; only used when this factory creates its own manager. */
+	readonly hardLimitSeconds?: number;
 	readonly executeTool: ExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;

package/src/tool/eval-tool.ts

@@ -32,7 +32,12 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
 	});
 	const languages = enabledLanguageList(options.enabledLanguages);
-	const cellManager = options.cellManager ?? new EvalDetachedCellManager({ artifactsDir: options.artifactsDir });
+	const cellManager =
+		options.cellManager ??
+		new EvalDetachedCellManager({
+			...(options.artifactsDir === undefined ? {} : { artifactsDir: options.artifactsDir }),
+			...(options.hardLimitSeconds === undefined ? {} : { hardLimitSeconds: options.hardLimitSeconds }),
+		});
 	return {
 		name: "eval",
 		label: "Eval",
@@ -194,7 +199,12 @@ async function executeCell(
 			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
 		});
 		handler = activeHandler;
-		cellManager.markRunning(cell, kernel, () => activeHandler.liveResult());
+		cellManager.markRunning(
+			cell,
+			kernel,
+			() => activeHandler.liveResult(),
+			(error) => execution.cancel(error),
+		);
 		if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
 			options.kernelManager.setContext(bridgeContext);
 		}