@code-yeongyu/senpi-codemode 2026.9.5 → 2026.9.7-2

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

@@ -0,0 +1,30 @@
+import { SENPI_CODEMODE_WAKE_SOURCE, type WakeSourceState } from "../extension/wake-source-state.ts";
+import type { EvalDetachedCellStatusEntry } from "./detached-cell-manager.ts";
+
+export interface LiveDetachedCell {
+	readonly cellId: string;
+	readonly startedAtMs: number;
+	readonly input: { readonly language: EvalDetachedCellStatusEntry["language"]; readonly summary?: string };
+}
+
+export function detachedStatusEntries(liveCells: readonly LiveDetachedCell[]): EvalDetachedCellStatusEntry[] {
+	return liveCells.map((cell) => ({
+		cellId: cell.cellId,
+		language: cell.input.language,
+		startedAtMs: cell.startedAtMs,
+		...(cell.input.summary === undefined ? {} : { summary: cell.input.summary }),
+	}));
+}
+
+export function detachedWakeSourceState(liveCells: readonly LiveDetachedCell[]): WakeSourceState {
+	return {
+		source: SENPI_CODEMODE_WAKE_SOURCE,
+		activeCount: liveCells.length,
+		items: liveCells.map((cell) => ({
+			id: cell.cellId,
+			description:
+				cell.input.summary === undefined || cell.input.summary.length === 0 ? cell.cellId : cell.input.summary,
+			startedAtMs: cell.startedAtMs,
+		})),
+	};
+}

package/src/tool/detached-eval-result.ts

@@ -40,6 +40,7 @@ export function createDetachedControlResult(snapshot: EvalDetachedCellSnapshot):
 		`Eval cell ${snapshot.cellId} (${snapshot.language}) is ${snapshot.state}.`,
 		output.length === 0 ? "(no buffered output)" : output,
 		...(terminationNote === undefined ? [] : [terminationNote]),
+		...(snapshot.interruptNote === undefined ? [] : [snapshot.interruptNote.trim()]),
 	].join("\n");
 	return {
 		content: [{ type: "text", text }, ...snapshot.result.content.filter((part) => part.type === "image")],

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

@@ -2,7 +2,7 @@ import type { EvalDetachedCellNotifier, EvalDetachedCellSnapshot } from "./detac
 import { buildDetachedCellNotification } from "./detached-cell-notification.ts";
 
 export interface PendingDetachedNotification {
-	readonly snapshot: () => EvalDetachedCellSnapshot;
+	readonly snapshot: () => EvalDetachedCellSnapshot | Promise<EvalDetachedCellSnapshot>;
 	readonly spillPath: string | undefined;
 }
 
@@ -30,7 +30,7 @@ export class DetachedNotificationQueue {
 		const flush = Promise.resolve().then(async () => {
 			const pending = this.#pending.splice(0);
 			const notifications = await Promise.all(
-				pending.map(async (item) => await buildDetachedCellNotification(item.snapshot(), item.spillPath)),
+				pending.map(async (item) => await buildDetachedCellNotification(await item.snapshot(), item.spillPath)),
 			);
 			this.#notifier?.notify(notifications);
 		});

package/src/tool/image.ts

@@ -119,7 +119,7 @@ export class EvalOutputCollector {
 	async finish(): Promise<EvalOutputResult> {
 		await this.#processImages();
 		const summary = await this.#finalSummary();
-		const meta = truncationMetaFromSummary(summary);
+		const meta = truncationMetaFromSummary(summary, this.#options.maxColumns);
 		const notice = summary.artifactId === undefined ? undefined : artifactNotice(summary.artifactId);
 		return {
 			output: summary.output.trimEnd(),
@@ -215,7 +215,7 @@ function formatDisplayJson(value: unknown): string {
 	return `${text.slice(0, MAX_DISPLAY_TEXT_BYTES)}\n[…${text.length - MAX_DISPLAY_TEXT_BYTES}ch elided…]`;
 }
 
-function truncationMetaFromSummary(summary: OutputSummary): TruncationMeta | undefined {
+function truncationMetaFromSummary(summary: OutputSummary, maxColumns: number): TruncationMeta | undefined {
 	if (!summary.truncated) return undefined;
 	const artifact = summary.artifactId === undefined ? {} : { artifactId: summary.artifactId };
 	if (summary.elidedBytes !== undefined && summary.elidedBytes > 0) {
@@ -239,9 +239,18 @@ function truncationMetaFromSummary(summary: OutputSummary): TruncationMeta | und
 			...artifact,
 		};
 	}
+	const droppedBytes = Math.max(0, summary.totalBytes - summary.outputBytes);
+	const clampedLines = summary.columnTruncatedLines ?? 0;
+	const columnOnly = clampedLines > 0 && (summary.columnDroppedBytes ?? 0) >= droppedBytes;
+	const byteCapped = summary.totalBytes - (summary.columnDroppedBytes ?? 0) > DEFAULT_MAX_BYTES;
 	return {
 		direction: "tail",
-		truncatedBy: summary.outputBytes < summary.totalBytes ? "bytes" : "lines",
+		truncatedBy: columnOnly ? "columns" : byteCapped ? "bytes" : "lines",
+		...(columnOnly
+			? { maxColumns, columnTruncatedLines: clampedLines }
+			: byteCapped
+				? { maxBytes: DEFAULT_MAX_BYTES }
+				: {}),
 		totalLines: summary.totalLines,
 		totalBytes: summary.totalBytes,
 		outputLines: summary.outputLines,

package/src/tool/interrupt-note.ts

@@ -1,4 +1,4 @@
-import type { EvalLanguage } from "./types.ts";
+import type { EvalLanguage, KernelInterruptHandle } from "./types.ts";
 
 const TIMEOUT_STATE_GRACE_MS = 5_500;
 
@@ -13,30 +13,40 @@ function fallbackTimeoutMessage(base: string): string {
  */
 export async function describeTimeoutState(
 	error: Error,
-	execution: { readonly interruptStateRetained: Promise<boolean> | undefined },
+	execution: { readonly interruptHandle: Promise<KernelInterruptHandle> | undefined },
 ): Promise<Error> {
-	const outcome = execution.interruptStateRetained;
-	if (outcome === undefined) {
+	const pending = execution.interruptHandle;
+	if (pending === undefined) {
 		error.message = fallbackTimeoutMessage(error.message);
 		return error;
 	}
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	const retained = await Promise.race([
-		outcome,
-		new Promise<boolean | undefined>((resolve) => {
-			timer = setTimeout(() => resolve(undefined), TIMEOUT_STATE_GRACE_MS);
-		}),
-	]).finally(() => {
-		if (timer !== undefined) clearTimeout(timer);
-	});
-	if (retained === undefined) error.message = fallbackTimeoutMessage(error.message);
-	else if (retained)
+	const outcome = await withinGrace(
+		pending.then(async (handle) => ({ retained: await handle.stateRetained, note: handle.note })),
+		TIMEOUT_STATE_GRACE_MS,
+	);
+	if (outcome === undefined) error.message = fallbackTimeoutMessage(error.message);
+	else if (outcome.retained)
 		error.message = `${error.message} The kernel remains running; its existing variables are preserved.`;
 	else
 		error.message = `${error.message} The kernel was unresponsive and restarted; variables from earlier cells are lost.`;
+	if (outcome?.note !== undefined) error.message = `${error.message} ${outcome.note.trim()}`;
 	return error;
 }
 
+async function withinGrace<T>(operation: Promise<T>, graceMs: number): Promise<T | undefined> {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	try {
+		return await Promise.race([
+			operation,
+			new Promise<undefined>((resolve) => {
+				timer = setTimeout(() => resolve(undefined), graceMs);
+			}),
+		]);
+	} finally {
+		if (timer !== undefined) clearTimeout(timer);
+	}
+}
+
 const LANGUAGE_LABEL: Record<EvalLanguage, string> = {
 	py: "Python kernel",
 	js: "JavaScript worker",
@@ -56,3 +66,7 @@ export function interruptionStateNote(language: EvalLanguage, stateRetained: boo
 	if (stateRetained) return `${label} was interrupted and remains running; its existing variables are preserved.`;
 	return `${label} was unresponsive to interrupt and was restarted; variables from earlier cells are lost.`;
 }
+
+export function unknownInterruptionStateNote(language: EvalLanguage): string {
+	return `${LANGUAGE_LABEL[language]} interrupt outcome is unknown; re-establish any variables the next cell needs.`;
+}

package/src/tool/types.ts

@@ -112,6 +112,8 @@ export interface EvalKernelRunInput {
 export interface KernelInterruptHandle {
 	/** Resolves once the kernel knows whether user state survived the interrupt. */
 	readonly stateRetained: Promise<boolean>;
+	/** Extra outcome detail worth showing the model, e.g. that a blocked worker was abandoned. */
+	readonly note?: string;
 }
 
 export interface EvalKernel {