@code-yeongyu/senpi-codemode 2026.7.31 → 2026.8.3-3

package/CHANGELOG.md

@@ -12,6 +12,75 @@
 
 ### Removed
 
+## [2026.8.3-3] - 2026-08-03
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.8.3-2] - 2026-08-03
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.8.3] - 2026-08-03
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.8.1] - 2026-08-01
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Preserve rich live and terminal `eval` details when peeking detached cells,
+  including code, title, output, phase, status events, tool-call summaries,
+  duration, and structured displays; cancellation now remains authoritative
+  over late completion races
+  ([#603](https://github.com/code-yeongyu/senpi/pull/603)).
+
+### Removed
+
+## [2026.7.31-2] - 2026-07-31
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- Include a live elapsed label in detached `eval` footer status. The ticker updates only when the rendered duration
+  changes and is disposed when the cell completes, fails, or is stopped.
+
+### Fixed
+
+### Removed
+
 ## [2026.7.31] - 2026-07-31
 
 ### Breaking Changes

package/README.md

@@ -11,9 +11,12 @@ task-tool names are known.
 - Persistent JavaScript, Python, Ruby, and Julia cells. State survives later
   cells in the same language until reset, restart, or session disposal.
 - Timeout detachment for interactive `eval`: long pure-compute cells return a
-  handle and continue in their existing kernel. Completion is injected with the
-  final value/error and buffered output; use `eval({ action: "peek"|"stop",
-  cell_id })` to inspect or terminate a detached cell.
+	handle and continue in their existing kernel. Completion is injected with the
+	final value/error and buffered output; use `eval({ action: "peek"|"stop",
+	cell_id })` to inspect or terminate a detached cell. A running peek preserves
+	the original code and title together with current output, phase, status
+	events, tool-call summaries, elapsed duration, and structured display state;
+	a terminal peek preserves the exact final result.
 - Loopback, bearer-authenticated kernel bridge with bounded JSONL frames.
 - Structured status events for file operations, environment access, phases,
   bridge activity, and delegated task progress.

package/package.json

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

package/src/extension/eval-status-ticker.ts

@@ -0,0 +1,79 @@
+import type { EvalDetachedCellStatusEntry } from "../tool/detached-cell-manager.ts";
+import { formatEvalCellStatus } from "./eval-status.ts";
+
+/** Footer live-elapsed refresh cadence while at least one detached cell is running. */
+export const EVAL_STATUS_TICK_INTERVAL_MS = 1000;
+
+/** Receives the freshly formatted footer status text (undefined clears the status). */
+export type EvalStatusRender = (status: string | undefined) => void;
+
+export interface EvalStatusTickerOptions {
+	readonly render: EvalStatusRender;
+	/** Injectable clock for tests; defaults to Date.now. */
+	readonly now?: () => number;
+}
+
+/**
+ * Drives a once-per-second footer refresh while detached eval cells are running so
+ * the "↗ py · … (Ns)" elapsed label advances live instead of freezing between
+ * cell-set transitions. Same shape as the terminal builtin's MonitorStatusTicker:
+ * the interval is unref'd, and ticks producing the already-rendered label are skipped.
+ */
+export class EvalStatusTicker {
+	private readonly render: EvalStatusRender;
+	private readonly now: () => number;
+	private intervalId: NodeJS.Timeout | undefined;
+	private entries: readonly EvalDetachedCellStatusEntry[] = [];
+	private lastRenderedStatus: string | undefined;
+	private hasRendered = false;
+
+	constructor(options: EvalStatusTickerOptions) {
+		this.render = options.render;
+		this.now = options.now ?? Date.now;
+	}
+
+	get running(): boolean {
+		return this.intervalId !== undefined;
+	}
+
+	/**
+	 * Point the ticker at the current detached-cell set, render once immediately,
+	 * and start the interval while cells are live (or stop it when none remain).
+	 */
+	sync(entries: readonly EvalDetachedCellStatusEntry[]): void {
+		this.entries = entries;
+		this.hasRendered = false;
+		this.tick();
+		if (entries.length === 0) {
+			this.stopInterval();
+			return;
+		}
+		if (this.intervalId !== undefined) return;
+		const handle = setInterval(() => this.tick(), EVAL_STATUS_TICK_INTERVAL_MS);
+		handle.unref();
+		this.intervalId = handle;
+	}
+
+	/** Stop the interval and drop the retained entries. */
+	stop(): void {
+		this.stopInterval();
+		this.entries = [];
+		this.lastRenderedStatus = undefined;
+		this.hasRendered = false;
+	}
+
+	private stopInterval(): void {
+		if (this.intervalId !== undefined) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+
+	private tick(): void {
+		const status = formatEvalCellStatus(this.entries, this.now());
+		if (this.hasRendered && status === this.lastRenderedStatus) return;
+		this.hasRendered = true;
+		this.lastRenderedStatus = status;
+		this.render(status);
+	}
+}

package/src/extension/eval-status.ts

@@ -31,14 +31,47 @@ function labelOf(entry: EvalDetachedCellStatusEntry): string {
 	return entry.title === undefined || entry.title.length === 0 ? entry.cellId : entry.title;
 }
 
+/**
+ * Goal-style compact elapsed label (`5s`, `3m`, `2h 30m`, `1d 2h 3m`). Mirrors
+ * the monitor builtin's formatElapsedSeconds; kept local like the rest of the
+ * duplicated status-file helpers between the two packages.
+ */
+export function formatElapsedSeconds(value: number): string {
+	const seconds = Math.max(0, Math.trunc(value));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.trunc(seconds / 60);
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.trunc(minutes / 60);
+	const remainingMinutes = minutes % 60;
+	if (hours >= 24) {
+		const days = Math.trunc(hours / 24);
+		const remainingHours = hours % 24;
+		return `${days}d ${remainingHours}h ${remainingMinutes}m`;
+	}
+	if (remainingMinutes === 0) return `${hours}h`;
+	return `${hours}h ${remainingMinutes}m`;
+}
+
+/** Whole seconds since the oldest detached cell was created; never negative on clock skew. */
+export function evalCellElapsedSeconds(entries: readonly EvalDetachedCellStatusEntry[], nowMs: number): number {
+	let oldest = Number.POSITIVE_INFINITY;
+	for (const entry of entries) oldest = Math.min(oldest, entry.startedAtMs);
+	if (!Number.isFinite(oldest)) return 0;
+	return Math.max(0, Math.round((nowMs - oldest) / 1000));
+}
+
 /** Brief footer text for the cells still running detached; undefined clears the status. */
-export function formatEvalCellStatus(entries: readonly EvalDetachedCellStatusEntry[]): string | undefined {
+export function formatEvalCellStatus(
+	entries: readonly EvalDetachedCellStatusEntry[],
+	nowMs: number,
+): string | undefined {
 	const first = entries[0];
 	if (first === undefined) return undefined;
+	const suffix = ` (${formatElapsedSeconds(evalCellElapsedSeconds(entries, nowMs))})`;
 	if (entries.length === 1) {
 		const head = `${DETACHED_GLYPH} ${first.language} · `;
-		return head + truncateEnd(labelOf(first), MAX_STATUS_LENGTH - head.length);
+		return head + truncateEnd(labelOf(first), MAX_STATUS_LENGTH - head.length - suffix.length) + suffix;
 	}
 	const head = `${DETACHED_GLYPH} eval ${entries.length}: `;
-	return head + packLabels(entries.map(labelOf), MAX_STATUS_LENGTH - head.length);
+	return head + packLabels(entries.map(labelOf), MAX_STATUS_LENGTH - head.length - suffix.length) + suffix;
 }

package/src/index.ts

@@ -5,7 +5,8 @@ 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 { EvalNotifier } from "./extension/eval-notifier.ts";
-import { EVAL_CELLS_STATUS_KEY, formatEvalCellStatus } from "./extension/eval-status.ts";
+import { EVAL_CELLS_STATUS_KEY } from "./extension/eval-status.ts";
+import { EvalStatusTicker } from "./extension/eval-status-ticker.ts";
 import {
 	createExecuteTool,
 	createRuntime,
@@ -44,6 +45,8 @@ export interface SenpiCodemodeOptions {
 		options: CreateCodemodeSessionManagerOptions,
 	) => CodemodeSessionManager | Promise<CodemodeSessionManager>;
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+	/** Injectable clock for detached-cell elapsed labels; defaults to Date.now. */
+	readonly now?: () => number;
 }
 
 export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
@@ -59,17 +62,22 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		getContext: () => activeContext,
 		getMode: () => "wake",
 	});
+	const statusTicker = new EvalStatusTicker({
+		...(options.now === undefined ? {} : { now: options.now }),
+		render: (status) => {
+			const ctx = activeContext;
+			if (ctx?.ui?.setStatus === undefined) return;
+			const theme = ctx.ui.theme;
+			ctx.ui.setStatus(
+				EVAL_CELLS_STATUS_KEY,
+				status === undefined || ctx.mode !== "tui" || theme === undefined
+					? status
+					: theme.bg("selectedBg", theme.fg("text", status)),
+			);
+		},
+	});
 	const showDetachedCells = (entries: readonly EvalDetachedCellStatusEntry[]): void => {
-		const ctx = activeContext;
-		if (ctx?.ui?.setStatus === undefined) return;
-		const status = formatEvalCellStatus(entries);
-		const theme = ctx.ui.theme;
-		ctx.ui.setStatus(
-			EVAL_CELLS_STATUS_KEY,
-			status === undefined || ctx.mode !== "tui" || theme === undefined
-				? status
-				: theme.bg("selectedBg", theme.fg("text", status)),
-		);
+		statusTicker.sync(entries);
 	};
 	const registerEvalForRuntime = (
 		runtime: SessionRuntime,
@@ -101,6 +109,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		activeRuntime = undefined;
 		activeModelId = undefined;
 		activeCells = undefined;
+		statusTicker.stop();
 		await cells?.dispose();
 		activeContext = undefined;
 		await manager.dispose();
@@ -114,7 +123,11 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			listTools: () => pi.getAllTools(),
 			complete,
 			settings: defaultCodemodeSettings,
-			cellManager: new EvalDetachedCellManager({ notifier, onStatusChange: showDetachedCells }),
+			cellManager: new EvalDetachedCellManager({
+				notifier,
+				onStatusChange: showDetachedCells,
+				...(options.now === undefined ? {} : { now: options.now }),
+			}),
 			executionTracker: manager,
 			renderers,
 			hostLine: hostLine(),
@@ -143,6 +156,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			artifactsDir: runtime.artifactsDir,
 			notifier,
 			onStatusChange: showDetachedCells,
+			...(options.now === undefined ? {} : { now: options.now }),
 		});
 		activeCells = cellManager;
 		activeRuntime = runtime;

package/src/tool/cell-execution.ts

@@ -0,0 +1,146 @@
+import { IdleTimeout, type IdleTimeoutOptions, type TimeoutPauseHandle } from "../timeouts/idle-timeout.ts";
+import type { EvalKernel } from "./types.ts";
+
+const INTERRUPT_DELIVERY_GRACE_MS = 100;
+
+export interface EvalTimeoutFactory {
+	create(options: IdleTimeoutOptions): TimeoutPauseHandle & { dispose(): void };
+}
+
+export const defaultTimeoutFactory: EvalTimeoutFactory = {
+	create(options): IdleTimeout {
+		return new IdleTimeout(options);
+	},
+};
+
+export interface CellExecutionOptions {
+	readonly callerSignal: AbortSignal;
+	readonly cellId: string;
+	readonly timeoutMs: number;
+	readonly timeoutFactory: EvalTimeoutFactory;
+	readonly onTimeout: (error: Error) => void;
+	readonly onAbort: (error: Error) => void;
+}
+
+export class CellExecution {
+	readonly #callerSignal: AbortSignal;
+	readonly #onAbort: (error: Error) => void;
+	readonly #abortPromise: Promise<never>;
+	readonly #detachedPromise: Promise<void>;
+	readonly #watchdog: TimeoutPauseHandle & { dispose(): void };
+	#rejectAbort: ((reason?: unknown) => void) | undefined;
+	#resolveDetached: (() => void) | undefined;
+	#kernel: EvalKernel | undefined;
+	#interruptDeadline: ReturnType<typeof setTimeout> | undefined;
+	#active = true;
+
+	constructor(options: CellExecutionOptions) {
+		this.#callerSignal = options.callerSignal;
+		this.#onAbort = options.onAbort;
+		this.#abortPromise = new Promise<never>((_resolve, reject) => {
+			this.#rejectAbort = reject;
+		});
+		this.#detachedPromise = new Promise<void>((resolve) => {
+			this.#resolveDetached = resolve;
+		});
+		this.#watchdog = options.timeoutFactory.create({
+			cellId: options.cellId,
+			timeoutMs: options.timeoutMs,
+			onTimeout: ({ error }) => options.onTimeout(error),
+		});
+		this.#callerSignal.addEventListener("abort", this.#handleCallerAbort, {
+			once: true,
+		});
+	}
+
+	get detached(): Promise<void> {
+		return this.#detachedPromise;
+	}
+
+	pause(): void {
+		this.#watchdog.pause();
+	}
+
+	resume(): void {
+		this.#watchdog.resume();
+	}
+
+	setKernel(kernel: EvalKernel): void {
+		this.#kernel = kernel;
+	}
+
+	detach(): void {
+		if (!this.#active) return;
+		this.#watchdog.dispose();
+		this.#resolveDetached?.();
+		this.#resolveDetached = undefined;
+	}
+
+	cancel(reason: unknown): void {
+		this.#abort(reason);
+	}
+
+	finish(): void {
+		this.#active = false;
+		this.#cleanup();
+	}
+
+	async wait<Result>(operation: Promise<Result>): Promise<Result> {
+		const guarded = operation.then(
+			(value): Result | Promise<never> => (this.#active ? value : this.#abortPromise),
+			(reason: unknown): Promise<never> => (this.#active ? Promise.reject(reason) : this.#abortPromise),
+		);
+		return await Promise.race([guarded, this.#abortPromise]);
+	}
+
+	readonly #handleCallerAbort = (): void => {
+		this.#abort(this.#callerSignal.reason);
+	};
+
+	interruptStateRetained: Promise<boolean> | undefined;
+
+	#abort(reason: unknown): void {
+		if (!this.#active) return;
+		this.#active = false;
+		this.#cleanup();
+		const error = abortError(reason);
+		this.#onAbort(error);
+		const kernel = this.#kernel;
+		if (kernel === undefined) {
+			this.#settleAbort(error);
+			return;
+		}
+		this.#interruptDeadline = setTimeout(() => this.#settleAbort(error), INTERRUPT_DELIVERY_GRACE_MS);
+		void Promise.resolve()
+			.then(async () => {
+				const handle = await kernel.interrupt(error.message);
+				this.interruptStateRetained = handle?.stateRetained;
+			})
+			.then(
+				() => this.#settleAbort(error),
+				(interruptError: unknown) => this.#settleAbort(interruptError),
+			);
+	}
+
+	#settleAbort(reason: unknown): void {
+		const reject = this.#rejectAbort;
+		if (reject === undefined) return;
+		this.#rejectAbort = undefined;
+		if (this.#interruptDeadline !== undefined) clearTimeout(this.#interruptDeadline);
+		reject(reason);
+	}
+
+	#cleanup(): void {
+		this.#callerSignal.removeEventListener("abort", this.#handleCallerAbort);
+		this.#watchdog.dispose();
+		if (this.#interruptDeadline !== undefined) clearTimeout(this.#interruptDeadline);
+		this.#interruptDeadline = undefined;
+	}
+}
+
+export function abortError(reason: unknown): Error {
+	if (reason instanceof Error && reason.name !== "AbortError") return reason;
+	const error = new Error(typeof reason === "string" ? reason : "Eval interrupted", { cause: reason });
+	error.name = "AbortError";
+	return error;
+}