@code-yeongyu/senpi-codemode 2026.7.31-2 → 2026.8.1

package/CHANGELOG.md

@@ -12,6 +12,24 @@
 
 ### 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

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-2",
+	"version": "2026.8.1",
 	"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-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@^2026.8.1",
 		"typebox": "1.3.8"
 	},
 	"peerDependencies": {
 		"@code-yeongyu/senpi": "*"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.7.31-2"
+		"@code-yeongyu/senpi": "2026.8.1"
 	},
 	"keywords": [
 		"senpi",

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;
+}

package/src/tool/cell-handler.ts

@@ -1,9 +1,4 @@
-import {
-	type AgentToolResult,
-	type AgentToolUpdateCallback,
-	type ExtensionContext,
-	sanitizeTerminalLabel,
-} from "@code-yeongyu/senpi";
+import { type AgentToolResult, type ExtensionContext, sanitizeTerminalLabel } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import type { AgentExecuteTool } from "../bridges/agent-bridge.ts";
 import { isReservedToolName, runReservedTool } from "../bridges/reserved-dispatch.ts";
@@ -13,15 +8,12 @@ import type { CompletionRequest, CompletionResult } from "../completion/handler.
 import { handleCompletionToolCall } from "../completion/tool-bridge.ts";
 import type { ResolvedCodemodeSettings } from "../config/settings.ts";
 import { boundToolCallArgs, capCodePoints, MAX_ENRICHED_TOOL_CALLS, toolCallResultPreview } from "./call-capture.ts";
-import {
-	type EvalImageResizer,
-	EvalOutputCollector,
-	type EvalOutputResult,
-	marshalToolResult,
-	toolResultIsError,
-} from "./image.ts";
+import { CellResultBuilder, type CellState } from "./cell-runtime.ts";
+import { type EvalImageResizer, marshalToolResult, toolResultIsError } from "./image.ts";
 import { upsertStatusEvent } from "./status-events.ts";
-import type { EvalKernel, EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
+import type { EvalKernel, EvalStatusEvent, EvalToolDetails } from "./types.ts";
+
+export type { CellState } from "./cell-runtime.ts";
 
 type ResolvedToolReply = {
 	readonly value: unknown;
@@ -37,22 +29,6 @@ type ToolCallEnrichment = {
 	readonly argsTruncated?: true;
 };
 
-const LIVE_OUTPUT_PREVIEW_LINES = 8;
-
-export interface CellState {
-	readonly input: EvalToolInput;
-	readonly signal: AbortSignal;
-	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
-	readonly toolCalls: EvalToolDetails["toolCalls"] extends readonly (infer Item)[] ? Item[] : never;
-	readonly pendingBridgeCalls: Promise<void>[];
-	readonly statusEvents: EvalStatusEvent[];
-	active: boolean;
-	output: string;
-	phase: string | undefined;
-	durationMs: number;
-	status: "pending" | "running" | "complete" | "error";
-}
-
 export interface CellBridgeRuntime {
 	readonly executeTool: AgentExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
@@ -67,46 +43,40 @@ export class CellHandler {
 	readonly #kernel: EvalKernel;
 	readonly #state: CellState;
 	readonly #runtime: CellBridgeRuntime;
-	readonly #output: EvalOutputCollector;
+	readonly #resultBuilder: CellResultBuilder;
 
 	constructor(kernel: EvalKernel, state: CellState, runtime: CellBridgeRuntime) {
 		this.#kernel = kernel;
 		this.#state = state;
 		this.#runtime = runtime;
 		const settings = runtime.settings.outputSink;
-		this.#output = new EvalOutputCollector({
+		this.#resultBuilder = new CellResultBuilder({
+			state,
 			headBytes: settings.headBytes,
 			maxColumns: settings.maxColumns,
 			model: runtime.ctx.model,
 			...(runtime.artifactPath === undefined ? {} : { artifactPath: runtime.artifactPath }),
 			...(runtime.imageResizer === undefined ? {} : { imageResizer: runtime.imageResizer }),
-			onChunk: (_aggregate, cell) => {
-				state.output = cell;
-				this.#emitUpdate(false);
-			},
 		});
-		state.status = "running";
-		this.#emitUpdate(false);
 	}
 
 	async handle(message: KernelToHostMessage): Promise<void> {
 		if (!this.#state.active) return;
 		switch (message.type) {
 			case "text":
-				this.#output.push(message.data);
+				this.#resultBuilder.push(message.data);
 				return;
 			case "phase":
-				this.#state.phase = message.title;
-				this.#emitUpdate(false);
+				this.#resultBuilder.setPhase(message.title);
 				return;
 			case "status":
 				this.#recordStatus(message.event);
 				return;
 			case "log":
-				this.#output.push(`${message.message}\n`);
+				this.#resultBuilder.push(`${message.message}\n`);
 				return;
 			case "display":
-				this.#output.display(message);
+				this.#resultBuilder.display(message);
 				return;
 			case "tool-call": {
 				const pending = this.#handleToolCall(message);
@@ -125,38 +95,19 @@ export class CellHandler {
 	}
 
 	async finalize(result: Extract<KernelToHostMessage, { type: "result" }>): Promise<AgentToolResult<EvalToolDetails>> {
-		this.#state.durationMs = result.durationMs;
-		if (result.ok) {
-			if (result.valueRepr) this.#output.push(`${result.valueRepr}\n`);
-			this.#state.status = "complete";
-		} else {
-			this.#output.push(`${result.error.message}\n`);
-			this.#state.status = "error";
-		}
-		return await this.#finish(!result.ok);
+		return await this.#resultBuilder.finalize(result);
 	}
 
 	async finalizeCancellation(error: Error): Promise<AgentToolResult<EvalToolDetails>> {
-		this.#output.push(`${error.message}\n`);
-		this.#state.status = "error";
-		return await this.#finish(true);
+		return await this.#resultBuilder.finalizeCancellation(error);
 	}
 
 	async flushOutput(): Promise<void> {
-		await this.#output.flush();
+		await this.#resultBuilder.flushOutput();
 	}
 
-	async #finish(isError: boolean): Promise<AgentToolResult<EvalToolDetails>> {
-		const output = await this.#output.finish();
-		this.#state.output = output.output;
-		const details = this.#details(output, isError);
-		this.#emitUpdate(isError);
-		const text =
-			output.output ||
-			(output.images.length > 0
-				? `(displayed ${output.images.length} image${output.images.length === 1 ? "" : "s"}; no text output)`
-				: "(no output)");
-		return { content: [{ type: "text", text }, ...output.images], details };
+	liveResult(): AgentToolResult<EvalToolDetails> {
+		return this.#resultBuilder.liveResult();
 	}
 
 	async #handleToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
@@ -202,7 +153,7 @@ export class CellHandler {
 					? { name: message.toolName, ok: true }
 					: { name: message.toolName, ok: false, error: result.error },
 			);
-			this.#emitUpdate(false);
+			this.#resultBuilder.emitUpdate(false);
 			return;
 		}
 		const capturedArgs = boundToolCallArgs(message.args);
@@ -268,7 +219,7 @@ export class CellHandler {
 				error: { message: text },
 			});
 		}
-		this.#emitUpdate(false);
+		this.#resultBuilder.emitUpdate(false);
 	}
 
 	#pushToolCall(
@@ -301,55 +252,6 @@ export class CellHandler {
 	#recordStatus(event: EvalStatusEvent): void {
 		if (!this.#runtime.settings.statusEvents) return;
 		upsertStatusEvent(this.#state.statusEvents, event);
-		this.#emitUpdate(false);
-	}
-
-	#details(output: EvalOutputResult | undefined, isError: boolean): EvalToolDetails {
-		const statusEvents = this.#state.statusEvents.length > 0 ? [...this.#state.statusEvents] : undefined;
-		return {
-			language: this.#state.input.language,
-			languages: [this.#state.input.language],
-			...(this.#state.input.title === undefined ? {} : { title: this.#state.input.title }),
-			durationMs: this.#state.durationMs,
-			toolCalls: [...this.#state.toolCalls],
-			truncated: output?.truncated ?? false,
-			...(isError ? { isError: true } : {}),
-			...(this.#state.phase === undefined ? {} : { phase: this.#state.phase }),
-			cells: [
-				{
-					index: 0,
-					...(this.#state.input.title === undefined ? {} : { title: this.#state.input.title }),
-					code: this.#state.input.code,
-					language: this.#state.input.language,
-					output: this.#state.output,
-					status: this.#state.status,
-					durationMs: this.#state.durationMs,
-					...(statusEvents === undefined ? {} : { statusEvents }),
-					...(output?.hasMarkdown ? { hasMarkdown: true } : {}),
-				},
-			],
-			...(statusEvents === undefined ? {} : { statusEvents }),
-			...(output === undefined || output.jsonOutputs.length === 0 ? {} : { jsonOutputs: output.jsonOutputs }),
-			...(output?.notice === undefined ? {} : { notice: output.notice }),
-			...(output?.meta === undefined ? {} : { meta: output.meta }),
-		};
-	}
-
-	#liveUpdateText(): string {
-		const title = this.#state.input.title === undefined ? "" : ` ${this.#state.input.title}`;
-		const aggregateOutput = this.#output.aggregateText();
-		const outputLines = aggregateOutput.split("\n");
-		const hasTrailingNewline = aggregateOutput.endsWith("\n");
-		if (hasTrailingNewline) outputLines.pop();
-		const output = `${outputLines.slice(-LIVE_OUTPUT_PREVIEW_LINES).join("\n")}${hasTrailingNewline ? "\n" : ""}`;
-		return `1/1 cells ${this.#state.status}\n[1] ${this.#state.input.language}${title} ${this.#state.status}${output.length === 0 ? "" : `\n${output}`}`;
-	}
-
-	#emitUpdate(isError: boolean): void {
-		if (!this.#state.active) return;
-		this.#state.onUpdate?.({
-			content: [{ type: "text", text: this.#liveUpdateText() }],
-			details: this.#details(undefined, isError),
-		});
+		this.#resultBuilder.emitUpdate(false);
 	}
 }

package/src/tool/cell-runtime.ts

@@ -0,0 +1,157 @@
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import { type EvalImageResizer, EvalOutputCollector, type EvalOutputResult } from "./image.ts";
+import type { EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
+
+type KernelResult = Extract<KernelToHostMessage, { type: "result" }>;
+type DisplayMessage = Extract<KernelToHostMessage, { type: "display" }>;
+type ToolCall = EvalToolDetails["toolCalls"] extends readonly (infer Item)[] ? Item : never;
+
+export interface CellState {
+	readonly input: EvalToolInput;
+	readonly signal: AbortSignal;
+	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
+	readonly toolCalls: ToolCall[];
+	readonly pendingBridgeCalls: Promise<void>[];
+	readonly statusEvents: EvalStatusEvent[];
+	active: boolean;
+	output: string;
+	phase: string | undefined;
+	durationMs: number;
+	status: "pending" | "running" | "complete" | "error";
+}
+
+export interface CellResultBuilderOptions {
+	readonly artifactPath?: string;
+	readonly headBytes: number;
+	readonly imageResizer?: EvalImageResizer;
+	readonly maxColumns: number;
+	readonly model: ExtensionContext["model"];
+	readonly state: CellState;
+}
+
+export class CellResultBuilder {
+	readonly #output: EvalOutputCollector;
+	readonly #state: CellState;
+
+	constructor(options: CellResultBuilderOptions) {
+		this.#state = options.state;
+		this.#output = new EvalOutputCollector({
+			headBytes: options.headBytes,
+			maxColumns: options.maxColumns,
+			model: options.model,
+			...(options.artifactPath === undefined ? {} : { artifactPath: options.artifactPath }),
+			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
+			onChunk: (_aggregate, cell) => {
+				options.state.output = cell;
+				this.emitUpdate(false);
+			},
+		});
+		options.state.status = "running";
+		this.emitUpdate(false);
+	}
+
+	push(text: string): void {
+		this.#output.push(text);
+	}
+
+	display(message: DisplayMessage): void {
+		this.#output.display(message);
+	}
+
+	setPhase(title: string): void {
+		this.#state.phase = title;
+		this.emitUpdate(false);
+	}
+
+	async finalize(result: KernelResult): Promise<AgentToolResult<EvalToolDetails>> {
+		this.#state.durationMs = result.durationMs;
+		if (result.ok) {
+			if (result.valueRepr) this.#output.push(`${result.valueRepr}\n`);
+			this.#state.status = "complete";
+		} else {
+			this.#output.push(`${result.error.message}\n`);
+			this.#state.status = "error";
+		}
+		return await this.#finish(!result.ok);
+	}
+
+	async finalizeCancellation(error: Error): Promise<AgentToolResult<EvalToolDetails>> {
+		this.#output.push(`${error.message}\n`);
+		this.#state.status = "error";
+		return await this.#finish(true);
+	}
+
+	async flushOutput(): Promise<void> {
+		await this.#output.flush();
+	}
+
+	liveResult(): AgentToolResult<EvalToolDetails> {
+		return {
+			content: [{ type: "text", text: this.#liveUpdateText() }],
+			details: this.#details(undefined, this.#state.status === "error"),
+		};
+	}
+
+	emitUpdate(isError: boolean): void {
+		if (!this.#state.active) return;
+		this.#state.onUpdate?.({
+			content: [{ type: "text", text: this.#liveUpdateText() }],
+			details: this.#details(undefined, isError),
+		});
+	}
+
+	async #finish(isError: boolean): Promise<AgentToolResult<EvalToolDetails>> {
+		const output = await this.#output.finish();
+		this.#state.output = output.output;
+		const details = this.#details(output, isError);
+		this.emitUpdate(isError);
+		const text =
+			output.output ||
+			(output.images.length > 0
+				? `(displayed ${output.images.length} image${output.images.length === 1 ? "" : "s"}; no text output)`
+				: "(no output)");
+		return { content: [{ type: "text", text }, ...output.images], details };
+	}
+
+	#details(output: EvalOutputResult | undefined, isError: boolean): EvalToolDetails {
+		const statusEvents = this.#state.statusEvents.length > 0 ? [...this.#state.statusEvents] : undefined;
+		return {
+			language: this.#state.input.language,
+			languages: [this.#state.input.language],
+			...(this.#state.input.title === undefined ? {} : { title: this.#state.input.title }),
+			durationMs: this.#state.durationMs,
+			toolCalls: [...this.#state.toolCalls],
+			truncated: output?.truncated ?? false,
+			...(isError ? { isError: true } : {}),
+			...(this.#state.phase === undefined ? {} : { phase: this.#state.phase }),
+			cells: [
+				{
+					index: 0,
+					...(this.#state.input.title === undefined ? {} : { title: this.#state.input.title }),
+					code: this.#state.input.code,
+					language: this.#state.input.language,
+					output: this.#state.output,
+					status: this.#state.status,
+					durationMs: this.#state.durationMs,
+					...(statusEvents === undefined ? {} : { statusEvents }),
+					...(output?.hasMarkdown ? { hasMarkdown: true } : {}),
+				},
+			],
+			...(statusEvents === undefined ? {} : { statusEvents }),
+			...(output === undefined || output.jsonOutputs.length === 0 ? {} : { jsonOutputs: output.jsonOutputs }),
+			...(output?.notice === undefined ? {} : { notice: output.notice }),
+			...(output?.meta === undefined ? {} : { meta: output.meta }),
+		};
+	}
+
+	#liveUpdateText(): string {
+		const title = this.#state.input.title === undefined ? "" : ` ${this.#state.input.title}`;
+		const aggregateOutput = this.#output.aggregateText();
+		const outputLines = aggregateOutput.split("\n");
+		const hasTrailingNewline = aggregateOutput.endsWith("\n");
+		if (hasTrailingNewline) outputLines.pop();
+		const output = `${outputLines.slice(-8).join("\n")}${hasTrailingNewline ? "\n" : ""}`;
+		return `1/1 cells ${this.#state.status}\n[1] ${this.#state.input.language}${title} ${this.#state.status}${output.length === 0 ? "" : `\n${output}`}`;
+	}
+}