@code-yeongyu/senpi-codemode 2026.10.10-3 → 2026.10.10-5

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

@@ -63,6 +63,23 @@ export function currentDetachedResult(cell: DetachedCellResultSource): AgentTool
 	return cell.terminalResult ?? cell.liveResult?.() ?? fallbackResult(cell.input);
 }
 
+/**
+ * The result a cell cancelled before its handler finished settles with: its buffered output, not the live progress
+ * frame ("1/1 cells running"), so a stopped cell never reads as still running.
+ */
+export function cancelledDetachedResult(cell: DetachedCellResultSource): AgentToolResult<EvalToolDetails> {
+	if (cell.terminalResult !== undefined) return cell.terminalResult;
+	const current = currentDetachedResult(cell);
+	const output = detachedOutputTail(current);
+	return {
+		content: [
+			{ type: "text", text: output.length > 0 ? output : "(no output)" },
+			...current.content.filter((part) => part.type === "image"),
+		],
+		details: current.details,
+	};
+}
+
 export function detachedErrorResult(cell: DetachedCellResultSource, error: Error): AgentToolResult<EvalToolDetails> {
 	const current = currentDetachedResult(cell);
 	const output = detachedOutputTail(current);

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

@@ -46,9 +46,7 @@ function createEvalListResult(cellManager: EvalDetachedCellManager): AgentToolRe
 			language: snapshot.language,
 			state: snapshot.state,
 			startedAtMs: snapshot.startedAtMs,
-			...(snapshot.queuedBehind === undefined || snapshot.queuedBehind.length === 0
-				? {}
-				: { queuedBehind: [...snapshot.queuedBehind] }),
+			...(snapshot.queuedBehind === undefined ? {} : { queuedBehind: [...snapshot.queuedBehind] }),
 			...(summary ? { summary } : {}),
 		};
 	});
@@ -60,7 +58,7 @@ function createEvalListResult(cellManager: EvalDetachedCellManager): AgentToolRe
 				" ",
 			);
 			const elapsed = Math.floor(snapshot.result.details.durationMs / 1000);
-			const queued = cell.queuedBehind === undefined ? "" : ` queued behind ${cell.queuedBehind.join(", ")}`;
+			const queued = cell.queuedBehind === undefined ? "" : ` ${queuedPhrase(cell.queuedBehind, cell.language)}`;
 			return `${cell.cellId} ${cell.language} ${cell.state} ${elapsed}s${queued} - ${preview}`;
 		})
 		.join("\n");
@@ -76,11 +74,13 @@ export function resultAfterDetach(
 	otherLiveCells: number,
 ): AgentToolResult<EvalToolDetails> {
 	if (snapshot.state !== "detached" && snapshot.state !== "running") return createDetachedControlResult(snapshot);
-	const predecessors = snapshot.queuedBehind?.join(", ");
+	const queuedBehind = snapshot.queuedBehind;
 	const text =
-		predecessors === undefined
+		queuedBehind === undefined
 			? `Eval cell ${snapshot.cellId} detached and is running in the ${input.language} kernel (${otherLiveCells} other live cells). Completion arrives as a notification; do not re-run it. eval({ action: "peek" | "stop", cell_id }) or eval({ action: "list" }).`
-			: `Eval cell ${snapshot.cellId} is queued behind ${predecessors} in the ${input.language} kernel and detached; it runs after ${predecessors} and completes as one notification. peek/stop/list with eval({ action, cell_id })`;
+			: queuedBehind.length === 0
+				? `Eval cell ${snapshot.cellId} is detached and waiting for the ${input.language} kernel to be ready; it runs first once the kernel is ready and completes as one notification. peek/stop/list with eval({ action, cell_id })`
+				: `Eval cell ${snapshot.cellId} is queued behind ${queuedBehind.join(", ")} in the ${input.language} kernel and detached; it runs after ${queuedBehind.join(", ")} and completes as one notification. peek/stop/list with eval({ action, cell_id })`;
 	return {
 		content: [
 			{
@@ -164,6 +164,12 @@ export function resultForDetachedState(
 	};
 }
 
+function queuedPhrase(queuedBehind: readonly string[], language: string): string {
+	return queuedBehind.length === 0
+		? `waiting for the ${language} kernel to be ready`
+		: `queued behind ${queuedBehind.join(", ")}`;
+}
+
 function textContent(result: AgentToolResult<EvalToolDetails>): string {
 	return result.content
 		.filter((part) => part.type === "text")

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

@@ -3,7 +3,6 @@ import { buildDetachedCellNotification } from "./detached-cell-notification.ts";
 
 export interface PendingDetachedNotification {
 	readonly snapshot: () => EvalDetachedCellSnapshot | Promise<EvalDetachedCellSnapshot>;
-	readonly spillPath: string | undefined;
 }
 
 export class DetachedNotificationQueue {
@@ -30,7 +29,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(await item.snapshot(), item.spillPath)),
+				pending.map(async (item) => buildDetachedCellNotification(await item.snapshot())),
 			);
 			this.#notifier?.notify(notifications);
 		});

package/src/tool/interrupt-note.ts

@@ -26,9 +26,8 @@ export async function describeTimeoutState(
 	);
 	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.`;
+		error.message = `${error.message} The kernel was not restarted; variables from earlier cells are kept.`;
+	else error.message = `${error.message} The kernel was restarted; variables from earlier cells are lost.`;
 	if (outcome?.note !== undefined) error.message = `${error.message} ${outcome.note.trim()}`;
 	return error;
 }
@@ -63,8 +62,8 @@ const LANGUAGE_LABEL: Record<EvalLanguage, string> = {
 export function interruptionStateNote(language: EvalLanguage, stateRetained: boolean | undefined): string | undefined {
 	if (stateRetained === undefined) return undefined;
 	const label = LANGUAGE_LABEL[language];
-	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.`;
+	if (stateRetained) return `The ${label} was not restarted; variables from earlier cells are kept.`;
+	return `The ${label} was restarted; variables from earlier cells are lost.`;
 }
 
 export function unknownInterruptionStateNote(language: EvalLanguage): string {

package/src/tool/live-headline.ts

@@ -0,0 +1,60 @@
+import { sanitizeTerminalLabel, visibleWidth } from "@code-yeongyu/senpi";
+import { type EvalCellResult, type EvalLanguage, evalLanguageOrder } from "./types.ts";
+
+const HEADLINED_STATUSES: ReadonlySet<EvalCellResult["status"]> = new Set(["pending", "queued", "running", "detached"]);
+
+/**
+ * A collapsed headline never wraps the frame: it gets what the language, state and timing leave on the line. This
+ * floor (in screen cells) only keeps a word or two visible in very narrow terminals.
+ */
+const MIN_HEADLINE_CELLS = 8;
+
+export function leadsWithHeadline(status: EvalCellResult["status"]): boolean {
+	return HEADLINED_STATUSES.has(status);
+}
+
+/**
+ * What an in-progress cell is doing, in one line: its summary, or else the first line of its code that has content once sanitized (the
+ * oh-my-pi fallback), or an ellipsis while the arguments are still streaming in. Collapsed rows cut it to
+ * `maxCells` screen cells (a wide character takes two), so the headline stays one line. Whichever is chosen is
+ * sanitized before it is measured, so escape and control characters never reach the row (senpi#2831, senpi#2839).
+ */
+export function liveHeadline(
+	summary: string | undefined,
+	code: string | undefined,
+	maxCells: number | undefined,
+): string {
+	const text = (summary === undefined ? "" : sanitizeTerminalLabel(summary)) || firstCodeLine(code) || "…";
+	const limit = maxCells === undefined ? undefined : Math.max(MIN_HEADLINE_CELLS, maxCells);
+	if (limit === undefined || visibleWidth(text) <= limit) return text;
+	return `${cellPrefix(text, limit - 1)}…`;
+}
+
+// A plain cut by screen cells: the headline is styled by the caller, so no reset codes may be inserted here.
+function cellPrefix(text: string, cells: number): string {
+	let kept = "";
+	let used = 0;
+	for (const { segment } of new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(text)) {
+		const width = visibleWidth(segment);
+		if (used + width > cells) break;
+		kept += segment;
+		used += width;
+	}
+	return kept;
+}
+
+export function knownLanguage(language: unknown): EvalLanguage | undefined {
+	return evalLanguageOrder.find((known) => known === language);
+}
+
+// The first line with something to show once it is sanitized: a line of only escape or control characters is skipped
+// (senpi#2850), and the later lines never reach the row.
+function firstCodeLine(code: string | undefined): string | undefined {
+	if (code === undefined) return undefined;
+	// Stops at the first line with content, so a long cell is not sanitized line by line on every frame.
+	for (const line of code.split("\n")) {
+		const clean = sanitizeTerminalLabel(line);
+		if (clean.length > 0) return clean;
+	}
+	return undefined;
+}

package/src/tool/managed-cell.ts

@@ -1,7 +1,6 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
 import { type CellDeadlineExpiry, CellDeadlines } from "./cell-deadlines.ts";
 import type { EvalDetachedCellSnapshot, EvalDetachedCellState } from "./detached-cell-contract.ts";
-import { detachedNotificationSpillPath } from "./detached-cell-notification.ts";
 import type { EvalKernel, EvalToolDetails, EvalToolInput } from "./types.ts";
 
 export type LiveResultProvider = () => AgentToolResult<EvalToolDetails>;
@@ -9,7 +8,6 @@ export type LiveResultProvider = () => AgentToolResult<EvalToolDetails>;
 export type ManagedCell = {
 	readonly cellId: string;
 	readonly input: EvalToolInput;
-	readonly spillPath: string | undefined;
 	readonly startedAtMs: number;
 	readonly terminal: PromiseWithResolvers<EvalDetachedCellSnapshot>;
 	state: Exclude<EvalDetachedCellState, "detached">;
@@ -37,7 +35,6 @@ export type ManagedCell = {
 export interface ManagedCellInit {
 	readonly cellId: string;
 	readonly input: EvalToolInput;
-	readonly artifactsDir: string | undefined;
 	readonly now: () => number;
 	readonly defaultHardLimitSeconds: number;
 	readonly defaultRunBudgetSeconds: number;
@@ -60,7 +57,6 @@ export function createManagedCell(init: ManagedCellInit): ManagedCell {
 	return {
 		cellId: init.cellId,
 		input: init.input,
-		spillPath: detachedNotificationSpillPath(init.artifactsDir, init.cellId),
 		startedAtMs: init.now(),
 		state: "queued",
 		runStartedAtMs: undefined,

package/src/tool/render.ts

@@ -7,6 +7,7 @@ import {
 	type ToolDefinition,
 	type ToolRenderResultOptions,
 	truncateToVisualLines,
+	visibleWidth,
 } from "@code-yeongyu/senpi";
 import type { TruncationMeta } from "../output/output-meta.ts";
 import { highlightedCode } from "./code-preview.ts";
@@ -21,6 +22,7 @@ import {
 	JSON_TREE_SCALAR_LEN_EXPANDED,
 	renderJsonTreeLines,
 } from "./json-tree.ts";
+import { knownLanguage, leadsWithHeadline, liveHeadline } from "./live-headline.ts";
 import { formatRuntimeBadge } from "./runtime-label.ts";
 import { codePointPrefix, formatDuration, renderToolCallWidget } from "./tool-widgets.ts";
 import type {
@@ -341,18 +343,37 @@ function cellHeader(cell: EvalCellResult, environment: RenderEnvironment, badges
 		environment.spinnerFrame ?? Math.floor((cellElapsedMs(cell, environment) ?? 0) / LIVE_RENDER_TICK_MS),
 	);
 	const runtimeBadge = cell.runtime === undefined ? "" : ` (${formatRuntimeBadge(cell.language, cell.runtime)})`;
-	let header = `eval ${cell.language}${runtimeBadge} ${presentation.label} ${presentation.icon}`;
+	let header = leadsWithHeadline(cell.status)
+		? `eval ${cell.language}${runtimeBadge} ${presentation.label}`
+		: `eval ${cell.language}${runtimeBadge} ${presentation.label} ${presentation.icon}`;
 	if (cell.queuedBehind !== undefined && cell.queuedBehind.length > 0)
 		header += ` · queued behind ${cell.queuedBehind.map(sanitizeTerminalLabel).join(", ")}`;
+	else if (cell.queuedBehind !== undefined && cell.status === "queued")
+		header += ` · waiting for the ${cell.language} kernel to be ready`;
 	const throughputBadge = badges.throughput === undefined ? undefined : formatThroughputBadge(badges.throughput);
 	if (throughputBadge !== undefined) header += ` · ${throughputBadge}`;
 	const elapsedMs = badges.throughput?.wallDurationMs ?? cellElapsedMs(cell, environment);
 	if (elapsedMs !== undefined) header += ` · ${formatDuration(elapsedMs)}`;
 	if (badges.reset) header += " · reset";
 	if (badges.timeout !== undefined) header += ` · timeout ${badges.timeout}s`;
+	if (leadsWithHeadline(cell.status))
+		header = headlined(presentation.icon, cell.summary, cell.code, header, environment);
 	return style(environment.theme, presentation.color, header);
 }
 
+// An in-progress row leads with what the cell is doing (senpi#2802); collapsed, the headline is cut so the whole
+// header stays on one line, and the code moves behind expand.
+function headlined(
+	icon: string,
+	summary: string | undefined,
+	code: string | undefined,
+	rest: string,
+	environment: RenderEnvironment,
+): string {
+	const budget = environment.expanded ? undefined : environment.width - 3 - visibleWidth(`${icon}  · ${rest}`);
+	return `${icon} ${liveHeadline(summary, code, budget)} · ${rest}`;
+}
+
 function previewText(
 	text: string,
 	maxLines: number,
@@ -612,12 +633,23 @@ function renderAgentProgressEvents(events: readonly EvalStatusEvent[], environme
 }
 
 function renderCell(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string[] {
+	if (leadsWithHeadline(cell.status) && !environment.expanded && cell.output.trim().length === 0) {
+		const statusEvents = (cell.statusEvents ?? []).filter((event) => event.op !== "agent");
+		if (statusEvents.length === 0) {
+			// Nothing to frame yet: the collapsed live row is its headline alone, one line, no empty box.
+			const lines = renderPrefixed(cellHeader(cell, environment, badges), environment, LIVE_LINE_PREFIX);
+			const agentEvents = (cell.statusEvents ?? []).filter((event) => event.op === "agent");
+			if (agentEvents.length > 0) appendLines(lines, renderAgentProgressEvents(agentEvents, environment));
+			return lines;
+		}
+	}
 	const lines = renderPrefixed(cellHeader(cell, environment, badges), environment, {
 		prefix: "╭─ ",
 		continuation: "│  ",
 		color: "borderAccent",
 	});
-	if (cell.summary !== undefined) {
+	const headlined = leadsWithHeadline(cell.status);
+	if (cell.summary !== undefined && !headlined) {
 		appendLines(
 			lines,
 			summaryVisualLines(cell.summary, Math.max(1, environment.width - 2), environment.expanded).map(
@@ -626,11 +658,14 @@ function renderCell(cell: EvalCellResult, environment: RenderEnvironment, badges
 		);
 	}
 	const innerWidth = Math.max(1, environment.width - 2);
-	const codePreview = previewText(
-		highlightedCode(cell.code, cell.language, environment.theme, environment.repaint),
-		environment.expanded ? Number.POSITIVE_INFINITY : CODE_PREVIEW_LINES,
-		innerWidth,
-	);
+	const codePreview =
+		headlined && !environment.expanded
+			? { lines: [], skipped: 0 }
+			: previewText(
+					highlightedCode(cell.code, cell.language, environment.theme, environment.repaint),
+					environment.expanded ? Number.POSITIVE_INFINITY : CODE_PREVIEW_LINES,
+					innerWidth,
+				);
 	if (codePreview.skipped > 0) {
 		appendLines(
 			lines,
@@ -879,6 +914,10 @@ function displaySummary(summary: string | undefined): string | undefined {
 	return normalizeEvalSummary(summary);
 }
 
+function cellIdSuffix(cellId: unknown): string {
+	return typeof cellId === "string" && cellId !== "" ? ` ${sanitizeTerminalLabel(cellId)}` : "";
+}
+
 export function renderEvalCall(
 	args: EvalToolRequest,
 	theme: Theme | undefined,
@@ -892,15 +931,23 @@ export function renderEvalCall(
 		return component;
 	}
 	if (!isEvalRunInput(args)) {
-		const title = args.action === "list" ? "eval list" : `eval ${args.action} ${args.cell_id}`;
+		// While a peek/stop call streams in, `cell_id` can still be missing; the title is the action alone until it arrives.
+		const title = args.action === "list" ? "eval list" : `eval ${args.action}${cellIdSuffix(args.cell_id)}`;
 		component.setBlocks([{ kind: "text", text: style(theme, "toolTitle", title) }]);
 		return component;
 	}
+	// While the model streams the call, `code` usually arrives before `language` and `summary`; a partial call still
+	// renders (the host would otherwise fall back to a raw key=value row).
+	const code = typeof args.code === "string" ? args.code : "";
+	const language = knownLanguage(args.language);
 	if (theme === undefined && context.spinnerFrame === undefined) {
 		const reset = args.reset === true ? " reset" : "";
 		const timeout = args.timeout === undefined ? "" : ` timeout ${args.timeout}s`;
 		component.setBlocks([
-			{ kind: "text", text: style(theme, "toolTitle", `eval ${args.language}${reset}${timeout}`) },
+			{
+				kind: "text",
+				text: style(theme, "toolTitle", `eval${language === undefined ? "" : ` ${language}`}${reset}${timeout}`),
+			},
 			...(displaySummary(args.summary) === undefined
 				? []
 				: [summaryBlock(displaySummary(args.summary) ?? "", theme, context.expanded)]),
@@ -909,9 +956,11 @@ export function renderEvalCall(
 				text: style(
 					theme,
 					"mdCodeBlock",
-					args.code.trim().length > 0
-						? displayCode(args.code, args.language, context.argsComplete ? context.invalidate : undefined)
-						: "...",
+					code.trim().length === 0
+						? "..."
+						: language === undefined
+							? code
+							: displayCode(code, language, context.argsComplete ? context.invalidate : undefined),
 				),
 				maxVisualLines: context.expanded ? undefined : CODE_PREVIEW_LINES,
 				collapseKind: "code",
@@ -933,11 +982,13 @@ export function renderEvalCall(
 					now: renderNow(context),
 					...(context.argsComplete ? { repaint: context.invalidate } : {}),
 				};
+				const summary = displaySummary(args.summary);
+				if (language === undefined) return streamingCallLines(summary, code, environment);
 				const cell: EvalCellResult = {
 					index: 0,
-					...(displaySummary(args.summary) === undefined ? {} : { summary: displaySummary(args.summary) ?? "" }),
-					code: args.code,
-					language: args.language,
+					...(summary === undefined ? {} : { summary }),
+					code,
+					language,
 					output: "",
 					status: context.spinnerFrame === undefined ? "pending" : "running",
 				};
@@ -952,6 +1003,14 @@ export function renderEvalCall(
 	return component;
 }
 
+/** A call whose language has not streamed in yet: the headline row alone, until the full frame can render. */
+function streamingCallLines(summary: string | undefined, code: string, environment: RenderEnvironment): string[] {
+	const icon = environment.spinnerFrame === undefined ? "○" : spinner(environment.spinnerFrame);
+	return renderPrefixed(headlined(icon, summary, code, "eval", environment), environment, LIVE_LINE_PREFIX);
+}
+
+const LIVE_LINE_PREFIX: PrefixStyle = { prefix: "╶─ ", continuation: "   ", color: "borderAccent" };
+
 export function renderEvalResult(
 	result: AgentToolResult<EvalResultDetails>,
 	options: ToolRenderResultOptions,

package/src/tool/run-eval-cell.ts

@@ -14,7 +14,7 @@ import {
 	type KernelToolsCapability,
 	type KernelToolsDescribeResult,
 } from "../kernels/js/kernel-tools-types.ts";
-import { sandboxCellExecutor } from "../kernels/sandbox/sandbox-cell.ts";
+import { sandboxCellExecutor, sandboxRuntimeInfo } from "../kernels/sandbox/sandbox-cell.ts";
 import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
 import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-execution.ts";
 import { CellHandler, type CellState } from "./cell-handler.ts";
@@ -44,7 +44,8 @@ export async function runEvalCell(
 	const bridgeAbortController = new AbortController();
 	const cellSignal = AbortSignal.any([invocation.signal, bridgeAbortController.signal]);
 	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
-	const runtime = options.runtimes?.[invocation.input.language];
+	const runtime =
+		invocation.input.isolate === true ? sandboxRuntimeInfo() : options.runtimes?.[invocation.input.language];
 	const state: CellState = {
 		input: invocation.input,
 		...(runtime === undefined ? {} : { runtime }),

package/src/tool/runtime-label.ts

@@ -11,7 +11,7 @@ const ELLIPSIS = "\u2026";
  */
 export function formatRuntimeBadge(language: EvalLanguage, runtime: EvalRuntimeInfo, home: string = homedir()): string {
 	const base = language === "js" ? `${runtime.name} ${runtime.version}` : runtime.version;
-	const label = runtime.isolation === "process" ? `${base}, process` : base;
+	const label = runtime.isolation === undefined ? base : `${base}, ${runtime.isolation}`;
 	if (runtime.path === undefined || runtime.path.length === 0) return label;
 	return `${label}, ${minifyPath(runtime.path, home)}`;
 }

package/src/tool/types.ts

@@ -279,8 +279,8 @@ export interface EvalRuntimeInfo {
 	readonly name: string;
 	readonly version: string;
 	readonly path?: string;
-	/** JS only: the kernel runs in a child process instead of a worker thread. */
-	readonly isolation?: "process";
+	/** JS only: the kernel runs in a child process (`process`), or the cell ran in an isolated QuickJS VM (`sandbox`). */
+	readonly isolation?: "process" | "sandbox";
 }
 
 export type EvalRuntimes = Readonly<Partial<Record<EvalLanguage, EvalRuntimeInfo>>>;