@code-yeongyu/senpi-codemode 2026.9.24 → 2026.9.25

package/CHANGELOG.md

@@ -12,6 +12,47 @@
 
 ### Removed
 
+## [2026.9.25] - 2026-09-25
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.24-3] - 2026-09-24
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.24-2] - 2026-09-24
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- Dense JavaScript eval cells are previewed with Bun's built-in printer when the TUI runs on Bun: one statement per line with normal spacing, while every string, number, template, name, and comment keeps its exact text. On Node, JavaScript cells are shown as sent. Dense Python cells are formatted by your own Python (ruff or black when installed, otherwise the standard library for comment-free cells), appearing formatted a moment after the cell is shown. Anything that cannot be shown faithfully is shown as sent, and the code that runs is unchanged. ([#2076](https://github.com/code-yeongyu/senpi/issues/2076))
+
+### Fixed
+
+- The `eval` tool's run contract is no longer a trap: the schema descriptions now mark `language` and `code` as required for run, and a run call missing either fails with an error that names the enabled languages or the missing cell body instead of a bare "eval run requires language".
+- An omitted `eval` `language` now names only the kernels enabled in this session (`js` and `py` by default), instead of advertising gated Ruby and Julia.
+
+### Removed
+
 ## [2026.9.24] - 2026-09-24
 
 ### Breaking Changes
@@ -22,6 +63,9 @@
 
 ### Fixed
 
+- Eval code previews no longer show code that means something different from the cell: breaking a long JavaScript array keeps the parentheses around each element, and a Python formatter result that changes string or docstring text (or is not valid Python) is discarded so the cell is shown as sent. ([#2076](https://github.com/code-yeongyu/senpi/issues/2076))
+- Python eval previews give your ruff most of the 5-second formatting budget instead of a fixed 4 seconds, so a slow first ruff start still formats the cell. ([#2076](https://github.com/code-yeongyu/senpi/issues/2076))
+
 ### Removed
 
 ## [2026.9.23-5] - 2026-09-23

package/README.md

@@ -207,15 +207,19 @@ that implements it. Reset only removes kernel variables: save `pool_id` and use
 arguments in other languages). An open pool's adapter can be recreated with the
 same name/spec/mode; no worker state is reconstructed in the prelude.
 
-## Required summary
+## Required run fields
 
-Every `eval` run call MUST include a `summary` — one line in the language the
+Every `eval` run call MUST include a `language` (the kernel that runs the
+cell, one of the enabled languages), the `code` cell body, and a `summary` —
+one line in the language the
 user writes in: a progress update saying what the agent is doing and why, not
 a label for the code. The
 summary is shown in the TUI while the cell runs and in the finished result, so
 you can always tell what is running and why. It has no length limit; a
-collapsed block shows its first three lines. A run request without a
-`summary` fails with a teaching error.
+collapsed block shows its first three lines. The schema marks all three
+optional only because the control actions (`peek`, `stop`, `list`) share it; a
+run request missing any of them fails with a teaching error that names what to
+add.
 
 ## Detached cells
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.24",
+	"version": "2026.9.25",
 	"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.9.24",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.25",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.24"
+		"@code-yeongyu/senpi": "2026.9.25"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.24"
+		"@code-yeongyu/senpi": "2026.9.25"
 	},
 	"keywords": [
 		"senpi",

package/src/tool/AGENTS.md

@@ -14,6 +14,7 @@ anchor most suites).
 | Cell execution, settlement | `cell-handler.ts`, `cell-execution.ts`, `cell-runtime.ts` |
 | Detached cells | `detached-cell-manager.ts` + `detached-cell-{state,snapshot,notification}.ts`, `detached-notification-queue.ts`, `detached-eval-result.ts` |
 | Call/result rendering | `render.ts`, `runtime-label.ts`, `json-tree.ts`, `image.ts`, `tool-widgets.ts` |
+| Code preview layout | `code-preview.ts` -> `display-code.ts` (JS: `display-js*.ts` Bun-only masked `Bun.Transpiler`; Python: `display-python*.ts` user interpreter, background + repaint) |
 | Status events, execution events | `status-events.ts`, `eval-execution-event.ts` |
 | Interrupt, capture | `interrupt-note.ts`, `call-capture.ts` |
 

package/src/tool/code-preview.ts

@@ -0,0 +1,31 @@
+import { highlightCode, type Theme } from "@code-yeongyu/senpi";
+import { displayCode } from "./display-code.ts";
+import type { EvalLanguage } from "./types.ts";
+
+function languageForHighlighter(language: EvalLanguage): "python" | "javascript" | "ruby" | "julia" {
+	switch (language) {
+		case "py":
+			return "python";
+		case "js":
+			return "javascript";
+		case "rb":
+			return "ruby";
+		case "jl":
+			return "julia";
+		default: {
+			const unreachable: never = language;
+			throw new TypeError(`Unhandled eval language: ${String(unreachable)}`);
+		}
+	}
+}
+
+export function highlightedCode(
+	code: string,
+	language: EvalLanguage,
+	theme: Theme | undefined,
+	onFormatted?: () => void,
+): string {
+	const normalizedCode = code.trim().length > 0 ? code : "...";
+	const lines = highlightCode(displayCode(normalizedCode, language, onFormatted), languageForHighlighter(language));
+	return (theme === undefined ? lines.map((line) => line.replace(/\u001b\[[0-9;]*m/gu, "")) : lines).join("\n");
+}

package/src/tool/display-code.ts

@@ -1,145 +1,48 @@
-import { parse } from "@babel/parser";
+import { bunJsPrinter, prettifyJs } from "./display-js.ts";
+import { pythonDisplay } from "./display-python.ts";
 import type { EvalLanguage } from "./types.ts";
 
-// Display-only: models often send a JS cell as one long line of joined statements. The preview
-// breaks it at statement, block, and long-array boundaries and keeps every source token and
-// comment verbatim. The tool arguments are never touched (senpi#1472).
+// Display-only (senpi#2050, senpi#2076): models often send a cell as one long line of joined
+// statements. The tool arguments are never touched (senpi#1472).
 const DENSE_LINE_LENGTH = 100;
-const ARRAY_BREAK_LENGTH = 60;
-const INDENT = "  ";
 const CACHE_LIMIT = 64;
 
-type SourceNode = { readonly type: string; readonly start: number; readonly end: number };
-
-// A whitespace/comma/comment region between two tokens that becomes a line break.
-type Gap = {
-	readonly start: number;
-	readonly end: number;
-	readonly contentDepth: number;
-	readonly nextDepth: number;
-};
-
-const cache = new Map<string, string>();
-
-function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function sourceNode(value: unknown): SourceNode | undefined {
-	if (!isRecord(value)) return undefined;
-	const { type, start, end } = value;
-	if (typeof type !== "string" || typeof start !== "number" || typeof end !== "number") return undefined;
-	return { type, start, end };
-}
-
-function sourceNodes(value: unknown): SourceNode[] {
-	if (!Array.isArray(value)) return [];
-	return value.flatMap((item) => sourceNode(item) ?? []);
-}
+const jsCache = new Map<string, string>();
 
 function isDense(code: string): boolean {
 	return code.split("\n").some((line) => line.length > DENSE_LINE_LENGTH);
 }
 
-function parseProgram(code: string): unknown {
-	try {
-		return parse(code, {
-			sourceType: "module",
-			allowAwaitOutsideFunction: true,
-			allowReturnOutsideFunction: true,
-			allowImportExportEverywhere: true,
-		}).program;
-	} catch (error) {
-		if (error instanceof SyntaxError) return undefined;
-		throw error;
-	}
-}
-
-function siblingGaps(children: readonly SourceNode[], depth: number): Gap[] {
-	return children.slice(1).map((child, index) => ({
-		start: children[index]?.end ?? child.start,
-		end: child.start,
-		contentDepth: depth,
-		nextDepth: depth,
-	}));
-}
-
-// Gaps for a bracketed container whose children move onto their own indented lines.
-function containerGaps(container: SourceNode, children: readonly SourceNode[], depth: number): Gap[] {
-	const first = children[0];
-	const last = children.at(-1);
-	if (first === undefined || last === undefined) return [];
-	const inner = depth + 1;
-	return [
-		{ start: container.start + 1, end: first.start, contentDepth: inner, nextDepth: inner },
-		...siblingGaps(children, inner),
-		{ start: last.end, end: container.end - 1, contentDepth: inner, nextDepth: depth },
-	];
-}
-
-function breakableChildren(node: SourceNode, record: Readonly<Record<string, unknown>>, code: string) {
-	if (node.type === "BlockStatement" || node.type === "StaticBlock") return sourceNodes(record.body);
-	if (node.type !== "ArrayExpression") return undefined;
-	const elements = sourceNodes(record.elements);
-	const text = code.slice(node.start, node.end);
-	if (elements.length < 2 || text.length <= ARRAY_BREAK_LENGTH || text.includes("\n")) return undefined;
-	return elements;
-}
-
-function collectGaps(value: unknown, depth: number, code: string, gaps: Gap[]): void {
-	if (Array.isArray(value)) {
-		for (const item of value) collectGaps(item, depth, code, gaps);
-		return;
-	}
-	if (!isRecord(value)) return;
-	const node = sourceNode(value);
-	const children = node === undefined ? undefined : breakableChildren(node, value, code);
-	const breaks = node !== undefined && children !== undefined && children.length > 0;
-	if (breaks) gaps.push(...containerGaps(node, children, depth));
-	for (const [key, child] of Object.entries(value)) {
-		if (key === "loc" || key === "extra" || key.endsWith("Comments")) continue;
-		if (child !== null && typeof child === "object") collectGaps(child, breaks ? depth + 1 : depth, code, gaps);
-	}
-}
-
-function renderGap(text: string, gap: Gap): string {
-	let rest = text.trim();
-	let attached = "";
-	if (rest.startsWith(",") || rest.startsWith(";")) {
-		attached = rest.slice(0, 1);
-		rest = rest.slice(1).trim();
-	}
-	const contentIndent = INDENT.repeat(gap.contentDepth);
-	const content = rest
-		.split("\n")
-		.map((line) => line.trim())
-		.filter((line) => line.length > 0)
-		.map((line) => `\n${contentIndent}${line}`)
-		.join("");
-	return `${attached}${content}\n${INDENT.repeat(gap.nextDepth)}`;
+function displayJs(code: string): string {
+	const print = bunJsPrinter();
+	if (print === null) return code;
+	const cached = jsCache.get(code);
+	if (cached !== undefined) return cached;
+	const formatted = prettifyJs(code, print) ?? code;
+	if (jsCache.size >= CACHE_LIMIT) jsCache.delete(jsCache.keys().next().value ?? "");
+	jsCache.set(code, formatted);
+	return formatted;
 }
 
-function reformat(code: string): string {
-	const program = parseProgram(code);
-	if (!isRecord(program)) return code;
-	const gaps = siblingGaps(sourceNodes(program.body), 0);
-	collectGaps(program.body, 0, code, gaps);
-	gaps.sort((left, right) => left.start - right.start);
-	let output = "";
-	let cursor = 0;
-	for (const gap of gaps) {
-		output += code.slice(cursor, gap.start) + renderGap(code.slice(gap.start, gap.end), gap);
-		cursor = gap.end;
+/**
+ * The preview text for a cell. Dense JavaScript is laid out by the built-in Bun printer only when
+ * the renderer runs on Bun; dense Python is formatted by the user's own interpreter in the
+ * background, so the first render shows the cell as sent and `onFormatted` asks for a repaint.
+ * Pass `onFormatted` only for complete code; without it no formatter process starts.
+ */
+export function displayCode(code: string, language: EvalLanguage, onFormatted?: () => void): string {
+	if (!isDense(code)) return code;
+	switch (language) {
+		case "js":
+			return displayJs(code);
+		case "py":
+			return pythonDisplay.display(code, onFormatted);
+		case "rb":
+		case "jl":
+			return code;
+		default: {
+			const unreachable: never = language;
+			return unreachable;
+		}
 	}
-	return (output + code.slice(cursor)).trim();
-}
-
-export function displayCode(code: string, language: EvalLanguage): string {
-	if (language !== "js" || !isDense(code)) return code;
-	const cached = cache.get(code);
-	if (cached !== undefined) return cached;
-	const formatted = reformat(code);
-	if (cache.size >= CACHE_LIMIT) cache.delete(cache.keys().next().value ?? "");
-	cache.set(code, formatted);
-	return formatted;
 }

package/src/tool/display-js-ast.ts

@@ -0,0 +1,65 @@
+import { parse } from "@babel/parser";
+
+export type SourceNode = {
+	readonly type: string;
+	readonly start: number;
+	readonly end: number;
+	readonly record: Readonly<Record<string, unknown>>;
+};
+
+export type Edit = { readonly start: number; readonly end: number; readonly text: string };
+
+export function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function sourceNode(value: unknown): SourceNode | undefined {
+	if (!isRecord(value)) return undefined;
+	const { type, start, end } = value;
+	if (typeof type !== "string" || typeof start !== "number" || typeof end !== "number") return undefined;
+	return { type, start, end, record: value };
+}
+
+export function sourceNodes(value: unknown): SourceNode[] {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => sourceNode(item) ?? []);
+}
+
+export function childNodes(node: SourceNode): SourceNode[] {
+	return Object.entries(node.record).flatMap(([key, value]) => {
+		if (key === "loc" || key === "extra" || key.endsWith("Comments")) return [];
+		return Array.isArray(value) ? sourceNodes(value) : (sourceNode(value) ?? []);
+	});
+}
+
+/** Parses a cell the way the js kernel accepts it: module syntax, top-level `await` and `return`. */
+export function parseFile(code: string): SourceNode | undefined {
+	try {
+		return sourceNode(
+			parse(code, {
+				sourceType: "module",
+				allowAwaitOutsideFunction: true,
+				allowReturnOutsideFunction: true,
+				allowImportExportEverywhere: true,
+			}),
+		);
+	} catch (error) {
+		if (error instanceof SyntaxError) return undefined;
+		throw error;
+	}
+}
+
+export function programOf(file: SourceNode | undefined): SourceNode | undefined {
+	return file === undefined ? undefined : sourceNode(file.record.program);
+}
+
+export function applyEdits(code: string, edits: readonly Edit[]): string {
+	const sorted = [...edits].sort((left, right) => left.start - right.start);
+	let output = "";
+	let cursor = 0;
+	for (const edit of sorted) {
+		output += code.slice(cursor, edit.start) + edit.text;
+		cursor = edit.end;
+	}
+	return output + code.slice(cursor);
+}

package/src/tool/display-js-layout.ts

@@ -0,0 +1,90 @@
+import {
+	applyEdits,
+	childNodes,
+	type Edit,
+	parseFile,
+	programOf,
+	type SourceNode,
+	sourceNode,
+	sourceNodes,
+} from "./display-js-ast.ts";
+
+const ARRAY_BREAK_LENGTH = 60;
+const INDENT = "  ";
+
+function forHeaderEdits(code: string, node: SourceNode, edits: Edit[]): void {
+	if (node.type === "ForStatement") {
+		const body = sourceNode(node.record.body);
+		const open = code.indexOf("(", node.start);
+		const close = body === undefined ? -1 : code.lastIndexOf(")", body.start);
+		if (open >= 0 && close > open) {
+			const parts = ["init", "test", "update"].map((key) => {
+				const part = sourceNode(node.record[key]);
+				return part === undefined ? "" : code.slice(part.start, part.end);
+			});
+			const header = parts.every((part) => part.length === 0) ? ";;" : parts.join("; ");
+			if (code.slice(open + 1, close) !== header) edits.push({ start: open + 1, end: close, text: header });
+		}
+	}
+	for (const child of childNodes(node)) forHeaderEdits(code, child, edits);
+}
+
+function lineIndent(code: string, position: number): string {
+	const line = code.slice(code.lastIndexOf("\n", position - 1) + 1);
+	return line.slice(0, line.length - line.trimStart().length);
+}
+
+// Only whitespace in a gap is rewritten: a gap between babel element nodes can also hold the
+// parentheses of a parenthesized element, and those must stay (senpi#2076).
+function gapTokens(code: string, start: number, end: number): string {
+	return code.slice(start, end).replace(/\s+/gu, "");
+}
+
+// A one-line array longer than ARRAY_BREAK_LENGTH puts each element on its own line (senpi#2050).
+// `forcedIndent` is the indentation of an element line an enclosing break just created.
+function arrayEdits(code: string, node: SourceNode, forcedIndent: string | undefined, edits: Edit[]): void {
+	const rawElements = node.record.elements;
+	const elements = sourceNodes(rawElements);
+	const first = elements[0];
+	const last = elements.at(-1);
+	const text = code.slice(node.start, node.end);
+	const breaks =
+		node.type === "ArrayExpression" &&
+		Array.isArray(rawElements) &&
+		elements.length === rawElements.length &&
+		elements.length >= 2 &&
+		text.length > ARRAY_BREAK_LENGTH &&
+		!text.includes("\n");
+	if (!breaks || first === undefined || last === undefined) {
+		for (const child of childNodes(node)) arrayEdits(code, child, forcedIndent, edits);
+		return;
+	}
+	const base = forcedIndent ?? lineIndent(code, node.start);
+	const inner = `${base}${INDENT}`;
+	edits.push({
+		start: node.start + 1,
+		end: first.start,
+		text: `\n${inner}${gapTokens(code, node.start + 1, first.start)}`,
+	});
+	elements.slice(1).forEach((element, index) => {
+		const start = elements[index]?.end ?? element.start;
+		const [before = "", after = ""] = gapTokens(code, start, element.start).split(",");
+		edits.push({ start, end: element.start, text: `${before},\n${inner}${after}` });
+	});
+	edits.push({ start: last.end, end: node.end - 1, text: `${gapTokens(code, last.end, node.end - 1)}\n${base}` });
+	for (const element of elements) arrayEdits(code, element, inner, edits);
+}
+
+/** Printer fix-ups on the restored cell: `for (a; b; c)` headers, then long-array breaks. */
+export function finishLayout(code: string): string | undefined {
+	const program = programOf(parseFile(code));
+	if (program === undefined) return undefined;
+	const headerEdits: Edit[] = [];
+	forHeaderEdits(code, program, headerEdits);
+	const withHeaders = applyEdits(code, headerEdits);
+	const reparsed = programOf(parseFile(withHeaders));
+	if (reparsed === undefined) return undefined;
+	const breaks: Edit[] = [];
+	arrayEdits(withHeaders, reparsed, undefined, breaks);
+	return applyEdits(withHeaders, breaks);
+}

package/src/tool/display-js-mask.ts

@@ -0,0 +1,178 @@
+import { applyEdits, childNodes, type Edit, type SourceNode, sourceNode } from "./display-js-ast.ts";
+
+const LITERAL_TYPES = new Set([
+	"StringLiteral",
+	"NumericLiteral",
+	"BigIntLiteral",
+	"RegExpLiteral",
+	"BooleanLiteral",
+	"NullLiteral",
+	"TemplateLiteral",
+	"TaggedTemplateExpression",
+	"DirectiveLiteral",
+]);
+// One placeholder per spelling, so `break outer` still resolves against `outer:` for Bun's parser.
+const NAME_TYPES = new Set(["Identifier", "PrivateName"]);
+// The grammar requires a string literal under these parents (module specifiers, attributes, and
+// string export names), so the placeholder stays a string there.
+const STRING_SLOT_PARENTS = new Set([
+	"ImportDeclaration",
+	"ExportAllDeclaration",
+	"ExportNamedDeclaration",
+	"ImportAttribute",
+	"ImportSpecifier",
+	"ExportSpecifier",
+	"ExportNamespaceSpecifier",
+	"ExportDefaultSpecifier",
+]);
+const STATEMENT_LISTS = new Set(["Program", "BlockStatement", "StaticBlock", "ClassBody", "SwitchCase"]);
+
+type SourceComment = { readonly start: number; readonly end: number; readonly line: boolean };
+type MaskedRange = SourceNode & { readonly stringSlot: boolean };
+export type Placeholder = { readonly id: string; readonly raw: string; readonly expected: number };
+export type CommentPlaceholder = Placeholder & { readonly trailing: boolean };
+export type Mask = {
+	readonly prefix: string;
+	readonly masked: string;
+	readonly values: ReadonlyMap<string, Placeholder>;
+	readonly comments: readonly CommentPlaceholder[];
+};
+
+function fileComments(file: SourceNode): SourceComment[] | undefined {
+	const comments = file.record.comments;
+	if (!Array.isArray(comments)) return undefined;
+	const parsed: SourceComment[] = [];
+	for (const comment of comments) {
+		const node = sourceNode(comment);
+		if (node === undefined) return undefined;
+		parsed.push({ start: node.start, end: node.end, line: node.type === "CommentLine" });
+	}
+	return parsed;
+}
+
+function innermostContainer(node: SourceNode, start: number, end: number): SourceNode {
+	for (const child of childNodes(node)) {
+		if (child.start <= start && end <= child.end) return innermostContainer(child, start, end);
+	}
+	return node;
+}
+
+function sitsInStatementList(code: string, program: SourceNode, comment: SourceComment): boolean {
+	const container = innermostContainer(program, comment.start, comment.end);
+	if (!STATEMENT_LISTS.has(container.type)) return false;
+	if (container.type !== "SwitchCase") return true;
+	const test = sourceNode(container.record.test);
+	const colon = code.indexOf(":", test?.end ?? container.start);
+	return colon >= 0 && colon < comment.start;
+}
+
+function followsCodeOnItsLine(code: string, comment: SourceComment, comments: readonly SourceComment[]): boolean {
+	let index = comment.start - 1;
+	while (index >= 0 && code[index] !== "\n") {
+		const position = index;
+		const covering = comments.find((other) => other.start <= position && position < other.end);
+		if (covering !== undefined) {
+			index = covering.start - 1;
+			continue;
+		}
+		if (code[index] !== " " && code[index] !== "\t") return true;
+		index -= 1;
+	}
+	return false;
+}
+
+function placeholderPrefix(code: string): string {
+	let prefix = "$display";
+	while (code.includes(prefix)) prefix = `${prefix}_`;
+	return prefix;
+}
+
+function collectRanges(node: SourceNode, parent: SourceNode | undefined, ranges: Map<string, MaskedRange>): void {
+	if (LITERAL_TYPES.has(node.type) || NAME_TYPES.has(node.type)) {
+		const stringSlot = node.type === "StringLiteral" && parent !== undefined && STRING_SLOT_PARENTS.has(parent.type);
+		const key = `${node.start}:${node.end}`;
+		if (!ranges.has(key)) ranges.set(key, { ...node, stringSlot });
+		return;
+	}
+	for (const child of childNodes(node)) collectRanges(child, node, ranges);
+}
+
+/**
+ * Swaps every literal, name, and statement-level comment for an opaque placeholder so a printer
+ * can only move them. Undefined when a comment sits where a placeholder statement cannot stand.
+ */
+export function maskSource(code: string, file: SourceNode): Mask | undefined {
+	const program = sourceNode(file.record.program);
+	const comments = fileComments(file);
+	if (program === undefined || comments === undefined) return undefined;
+	const ranges = new Map<string, MaskedRange>();
+	collectRanges(program, undefined, ranges);
+	const prefix = placeholderPrefix(code);
+	const edits: Edit[] = [];
+	const values = new Map<string, Placeholder>();
+	const nameIds = new Map<string, string>();
+	let counter = 0;
+	for (const range of ranges.values()) {
+		const raw = code.slice(range.start, range.end);
+		const reused = NAME_TYPES.has(range.type) ? nameIds.get(raw) : undefined;
+		const id = reused ?? `${prefix}${counter++}`;
+		if (NAME_TYPES.has(range.type)) nameIds.set(raw, id);
+		values.set(id, { id, raw, expected: (values.get(id)?.expected ?? 0) + 1 });
+		edits.push({ start: range.start, end: range.end, text: range.stringSlot ? `"${id}"` : id });
+	}
+	const masked: CommentPlaceholder[] = [];
+	for (const comment of comments) {
+		if (!sitsInStatementList(code, program, comment)) return undefined;
+		const id = `${prefix}${counter++}`;
+		const trailing = comment.line && followsCodeOnItsLine(code, comment, comments);
+		masked.push({ id, raw: code.slice(comment.start, comment.end), expected: 1, trailing });
+		edits.push({ start: comment.start, end: comment.end, text: `\n${id};\n` });
+	}
+	return { prefix, masked: applyEdits(code, edits), values, comments: masked };
+}
+
+export function restoreComments(printed: string, comments: readonly CommentPlaceholder[]): string | undefined {
+	const lines = printed.split("\n");
+	for (const comment of comments) {
+		const matches = lines.flatMap((line, index) => (line.trim() === `${comment.id};` ? [index] : []));
+		const index = matches[0];
+		if (matches.length !== 1 || index === undefined) return undefined;
+		const line = lines[index] ?? "";
+		let previous = index - 1;
+		while (previous >= 0 && (lines[previous] ?? "").trim().length === 0) previous -= 1;
+		const target = lines[previous];
+		if (comment.trailing && target !== undefined && !target.includes("//")) {
+			lines[previous] = `${target} ${comment.raw}`;
+			lines.splice(index, 1);
+			continue;
+		}
+		lines[index] = `${line.slice(0, line.length - line.trimStart().length)}${comment.raw}`;
+	}
+	return lines.join("\n");
+}
+
+function escapeRegExp(text: string): string {
+	return text.replace(/[\\^$.*+?()[\]{}|]/gu, "\\$&");
+}
+
+export function restoreValues(printed: string, mask: Mask): string | undefined {
+	const id = `${escapeRegExp(mask.prefix)}\\d+`;
+	const pattern = new RegExp(`"(${id})"|'(${id})'|(?<![\\w$])(${id})(?![\\w$])`, "gu");
+	const counts = new Map<string, number>();
+	let unknown = false;
+	const restored = printed.replace(pattern, (match, double: unknown, single: unknown, bare: unknown) => {
+		const key = [double, single, bare].find((group): group is string => typeof group === "string") ?? "";
+		const value = mask.values.get(key);
+		if (value === undefined) {
+			unknown = true;
+			return match;
+		}
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+		return value.raw;
+	});
+	if (unknown) return undefined;
+	for (const value of mask.values.values()) {
+		if (counts.get(value.id) !== value.expected) return undefined;
+	}
+	return restored;
+}

package/src/tool/display-js.ts

@@ -0,0 +1,100 @@
+import { isRecord, parseFile, type SourceNode } from "./display-js-ast.ts";
+import { finishLayout } from "./display-js-layout.ts";
+import { maskSource, restoreComments, restoreValues } from "./display-js-mask.ts";
+
+// Bun.Transpiler is a transpiler, not a formatter: printed directly it rewrites literals ("a\nb"
+// becomes a multi-line template, 0xff becomes 255, emoji become escapes), folds `typeof
+// undefined`, and drops comments and directives. It only ever lays out a masked cell here, and the
+// original text is substituted back; a cell that cannot be restored exactly is shown as sent.
+const INDENT = "  ";
+
+export type JsPrinter = (code: string) => string;
+
+let bunPrinter: JsPrinter | null | undefined;
+
+function resolveBunPrinter(): JsPrinter | null {
+	if (typeof process.versions.bun !== "string") return null;
+	const bun: unknown = Reflect.get(globalThis, "Bun");
+	if (!isRecord(bun) || typeof bun.Transpiler !== "function") return null;
+	const transpiler: unknown = Reflect.construct(bun.Transpiler, [
+		{ loader: "js", trimUnusedImports: false, deadCodeElimination: false, inline: false },
+	]);
+	if (!isRecord(transpiler) || typeof transpiler.transformSync !== "function") return null;
+	const transformSync = transpiler.transformSync;
+	return (code) => {
+		const output: unknown = Reflect.apply(transformSync, transpiler, [code]);
+		if (typeof output !== "string") throw new TypeError("Bun.Transpiler.transformSync returned a non-string");
+		return output;
+	};
+}
+
+/** The built-in Bun printer when this renderer runs on Bun; null on Node. */
+export function bunJsPrinter(): JsPrinter | null {
+	if (bunPrinter === undefined) bunPrinter = resolveBunPrinter();
+	return bunPrinter;
+}
+
+function layout(masked: string, prefix: string, print: JsPrinter): string | undefined {
+	try {
+		return print(masked).trim();
+	} catch {
+		// Module syntax only parses unwrapped; the kernel's top-level `return` only inside a function.
+	}
+	const header = `async function ${prefix}cell() {`;
+	let lines: string[];
+	try {
+		lines = print(`${header}\n${masked}\n}`).trim().split("\n");
+	} catch {
+		return undefined;
+	}
+	if (lines[0] !== header || lines.at(-1) !== "}") return undefined;
+	return lines
+		.slice(1, -1)
+		.map((line) => (line.startsWith(INDENT) ? line.slice(INDENT.length) : line))
+		.join("\n");
+}
+
+function sameTokens(left: string, right: string): boolean {
+	const strip = (text: string) => text.replace(/[\s;,()]/gu, "");
+	return strip(left) === strip(right);
+}
+
+const POSITION_KEYS = new Set([
+	"start",
+	"end",
+	"loc",
+	"range",
+	"extra",
+	"leadingComments",
+	"trailingComments",
+	"innerComments",
+]);
+
+// Positions, raw spellings, and parenthesization flags aside, the preview must be the same program:
+// the character guard alone cannot see a dropped `(`, which can change how an expression groups.
+function programSignature(file: SourceNode): string {
+	return JSON.stringify({ program: file.record.program, comments: file.record.comments }, (key, value: unknown) => {
+		if (POSITION_KEYS.has(key)) return undefined;
+		if (typeof value === "bigint") return `${value}n`;
+		// A stray `;` in a statement list is a no-op the printer drops.
+		return Array.isArray(value) ? value.filter((item) => !isRecord(item) || item.type !== "EmptyStatement") : value;
+	});
+}
+
+function sameProgram(original: SourceNode, preview: string): boolean {
+	const reparsed = parseFile(preview);
+	return reparsed !== undefined && programSignature(reparsed) === programSignature(original);
+}
+
+/** The printer's layout of `code` with its literal, name, and comment text intact, or undefined. */
+export function prettifyJs(code: string, print: JsPrinter): string | undefined {
+	const file = parseFile(code);
+	if (file === undefined) return undefined;
+	const mask = maskSource(code, file);
+	if (mask === undefined) return undefined;
+	const printed = layout(mask.masked, mask.prefix, print);
+	const withComments = printed === undefined ? undefined : restoreComments(printed, mask.comments);
+	const restored = withComments === undefined ? undefined : restoreValues(withComments, mask);
+	const finished = restored === undefined ? undefined : finishLayout(restored);
+	return finished !== undefined && sameTokens(finished, code) && sameProgram(file, finished) ? finished : undefined;
+}

package/src/tool/display-python-script.ts

@@ -0,0 +1,127 @@
+// Runs in the user's own Python interpreter: `python -c <script> <ruff timeout s> <strategies...>` with the cell on
+// stdin, printing {"via", "code"} as JSON. A strategy's output is kept only when it parses to the same
+// AST as the source and keeps every string, number, and comment token's text (senpi#2076).
+export const PYTHON_FORMATTER_SCRIPT = [
+	"import ast, io, json, re, shutil, subprocess, sys, tokenize",
+	"",
+	"def emit(via, code):",
+	"    sys.stdout.write(json.dumps({'via': via, 'code': code}))",
+	"    sys.exit(0)",
+	"",
+	"RUFF_TIMEOUT = float(sys.argv[1])",
+	"FLAGS = ast.PyCF_ONLY_AST | getattr(ast, 'PyCF_ALLOW_TOP_LEVEL_AWAIT', 0)",
+	"",
+	"def parse(text):",
+	"    return compile(text, '<cell>', 'exec', flags=FLAGS, dont_inherit=True)",
+	"",
+	"def literal_texts(text):",
+	"    kinds = {tokenize.STRING, tokenize.NUMBER, tokenize.COMMENT} | token_kinds('FSTRING_MIDDLE', 'TSTRING_MIDDLE')",
+	"    return [t.string for t in tokenize.generate_tokens(io.StringIO(text).readline) if t.type in kinds]",
+	"",
+	"def equivalent(source, formatted):",
+	"    try:",
+	"        same_tree = ast.dump(parse(source)) == ast.dump(parse(formatted))",
+	"        return same_tree and literal_texts(source) == literal_texts(formatted)",
+	"    except (SyntaxError, ValueError, tokenize.TokenError):",
+	"        return False",
+	"",
+	"def ruff_binary():",
+	"    found = shutil.which('ruff')",
+	"    if found:",
+	"        return found",
+	"    try:",
+	"        from ruff.__main__ import find_ruff_bin",
+	"        return find_ruff_bin()",
+	"    except Exception:",
+	"        return None",
+	"",
+	"def with_ruff(source):",
+	"    binary = ruff_binary()",
+	"    if not binary:",
+	"        return None",
+	"    args = [binary, 'format', '--quiet', '--no-cache', '--config', \"format.quote-style = 'preserve'\",",
+	"            '--stdin-filename', 'cell.py', '-']",
+	"    try:",
+	"        done = subprocess.run(args, input=source, capture_output=True, text=True, timeout=RUFF_TIMEOUT)",
+	"    except Exception:",
+	"        return None",
+	"    return done.stdout if done.returncode == 0 else None",
+	"",
+	"def with_black(source):",
+	"    try:",
+	"        import black",
+	"        return black.format_str(source, mode=black.Mode(string_normalization=False))",
+	"    except Exception:",
+	"        return None",
+	"",
+	"def token_kinds(*names):",
+	"    return {getattr(tokenize, name) for name in names if hasattr(tokenize, name)}",
+	"",
+	"def literal_spans(source):",
+	"    tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))",
+	"    starts = [0]",
+	"    for line in source.splitlines(keepends=True):",
+	"        starts.append(starts[-1] + len(line))",
+	"    offset = lambda position: starts[position[0] - 1] + position[1]",
+	"    opening, closing = token_kinds('FSTRING_START', 'TSTRING_START'), token_kinds('FSTRING_END', 'TSTRING_END')",
+	"    spans, depth = [], 0",
+	"    for token in tokens:",
+	"        if token.type == tokenize.COMMENT:",
+	"            return None",
+	"        if depth:",
+	"            depth += 1 if token.type in opening else -1 if token.type in closing else 0",
+	"            if depth == 0:",
+	"                spans[-1][1] = offset(token.end)",
+	"            continue",
+	"        is_string = token.type == tokenize.STRING or token.type in opening",
+	"        if not is_string and token.type != tokenize.NUMBER:",
+	"            continue",
+	"        start, end = offset(token.start), offset(token.end)",
+	"        joined = spans and spans[-1][2] and is_string and not re.sub(r'[\\s\\\\]', '', source[spans[-1][1]:start])",
+	"        if joined:",
+	"            spans[-1][1] = end",
+	"        else:",
+	"            spans.append([start, end, is_string])",
+	"        if token.type in opening:",
+	"            depth = 1",
+	"    return spans",
+	"",
+	"def with_ast(source):",
+	"    if not hasattr(ast, 'unparse'):",
+	"        return None",
+	"    try:",
+	"        spans = literal_spans(source)",
+	"    except (tokenize.TokenError, SyntaxError):",
+	"        return None",
+	"    if spans is None:",
+	"        return None",
+	"    prefix = '_display'",
+	"    while prefix in source:",
+	"        prefix += '_'",
+	"    raws, masked, cursor = {}, [], 0",
+	"    for index, (start, end, _) in enumerate(spans):",
+	"        name = prefix + str(index)",
+	"        raws[name] = source[start:end]",
+	"        masked.append(source[cursor:start] + name)",
+	"        cursor = end",
+	"    masked.append(source[cursor:])",
+	"    try:",
+	"        tree = parse(''.join(masked))",
+	"    except (SyntaxError, ValueError):",
+	"        return None",
+	"    seen = []",
+	"    def restore(match):",
+	"        seen.append(match.group(0))",
+	"        return raws.get(match.group(0), match.group(0))",
+	"    text = re.sub(r'\\b' + re.escape(prefix) + r'\\d+\\b', restore, ast.unparse(tree))",
+	"    return text if sorted(seen) == sorted(raws) else None",
+	"",
+	"STRATEGIES = {'ruff': with_ruff, 'black': with_black, 'ast': with_ast}",
+	"source = sys.stdin.read()",
+	"for name in sys.argv[2:]:",
+	"    strategy = STRATEGIES.get(name)",
+	"    formatted = strategy(source) if strategy else None",
+	"    if formatted is not None and equivalent(source, formatted):",
+	"        emit(name, formatted.rstrip('\\n'))",
+	"emit('none', source)",
+].join("\n");

package/src/tool/display-python.ts

@@ -0,0 +1,150 @@
+import { spawn } from "node:child_process";
+import { createInterpreterDetector } from "../interpreters/detect.ts";
+import { PYTHON_FORMATTER_SCRIPT } from "./display-python-script.ts";
+
+export type PythonStrategy = "ruff" | "black" | "ast";
+export type PythonInvocation = { readonly command: string; readonly args: readonly string[] };
+
+export interface PythonFormatOptions {
+	readonly strategies: readonly PythonStrategy[];
+	readonly timeoutMs: number;
+	readonly env?: NodeJS.ProcessEnv;
+}
+
+export interface PythonDisplayOptions extends PythonFormatOptions {
+	readonly interpreter: () => Promise<PythonInvocation | null>;
+}
+
+export interface PythonDisplay {
+	/**
+	 * The formatted cell once it is known, otherwise the cell as sent. With `onFormatted`, a missing
+	 * result is formatted in the background and `onFormatted` runs when a formatted cell is ready.
+	 */
+	display(code: string, onFormatted?: () => void): string;
+}
+
+const DEFAULT_STRATEGIES: readonly PythonStrategy[] = ["ruff", "black", "ast"];
+const FORMAT_TIMEOUT_MS = 5_000;
+const MAX_CONCURRENT_FORMATTERS = 2;
+const CACHE_LIMIT = 64;
+
+function formattedCode(stdout: string): string | undefined {
+	try {
+		const parsed: unknown = JSON.parse(stdout);
+		if (parsed === null || typeof parsed !== "object" || !("code" in parsed)) return undefined;
+		return typeof parsed.code === "string" ? parsed.code : undefined;
+	} catch (error) {
+		if (error instanceof SyntaxError) return undefined;
+		throw error;
+	}
+}
+
+// ruff runs inside the formatter process, so it gets most of the caller's budget and never outlives it.
+function ruffTimeoutSeconds(timeoutMs: number): string {
+	return String(Math.max(1, timeoutMs - 1_000) / 1_000);
+}
+
+export function formatPythonCell(
+	code: string,
+	invocation: PythonInvocation,
+	options: PythonFormatOptions,
+): Promise<string | undefined> {
+	return new Promise((resolve) => {
+		const child = spawn(
+			invocation.command,
+			[
+				...invocation.args,
+				"-c",
+				PYTHON_FORMATTER_SCRIPT,
+				ruffTimeoutSeconds(options.timeoutMs),
+				...options.strategies,
+			],
+			{
+				stdio: ["pipe", "pipe", "ignore"],
+				timeout: options.timeoutMs,
+				windowsHide: true,
+				...(options.env === undefined ? {} : { env: options.env }),
+			},
+		);
+		let stdout = "";
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+		child.on("error", () => resolve(undefined));
+		child.on("close", (exitCode) => resolve(exitCode === 0 ? formattedCode(stdout) : undefined));
+		child.stdin.on("error", () => resolve(undefined));
+		child.stdin.end(code);
+	});
+}
+
+export function createPythonDisplay(options: PythonDisplayOptions): PythonDisplay {
+	const settled = new Map<string, string>();
+	const listeners = new Map<string, Set<() => void>>();
+	const queue: string[] = [];
+	let running = 0;
+
+	const remember = (code: string, formatted: string) => {
+		if (settled.size >= CACHE_LIMIT) settled.delete(settled.keys().next().value ?? "");
+		settled.set(code, formatted);
+	};
+
+	const format = async (code: string): Promise<string | undefined> => {
+		const invocation = await options.interpreter();
+		return invocation === null ? undefined : formatPythonCell(code, invocation, options);
+	};
+
+	const pump = () => {
+		while (running < MAX_CONCURRENT_FORMATTERS) {
+			const code = queue.shift();
+			if (code === undefined) return;
+			running += 1;
+			void format(code)
+				.catch(() => undefined)
+				.then((formatted) => {
+					remember(code, formatted ?? code);
+					const waiting = listeners.get(code);
+					listeners.delete(code);
+					if (formatted !== undefined && formatted !== code) for (const listener of waiting ?? []) listener();
+				})
+				.finally(() => {
+					running -= 1;
+					pump();
+				});
+		}
+	};
+
+	return {
+		display(code, onFormatted) {
+			const known = settled.get(code);
+			if (known !== undefined || onFormatted === undefined) return known ?? code;
+			const waiting = listeners.get(code);
+			if (waiting !== undefined) {
+				waiting.add(onFormatted);
+				return code;
+			}
+			listeners.set(code, new Set([onFormatted]));
+			queue.push(code);
+			pump();
+			return code;
+		},
+	};
+}
+
+async function detectedPython(): Promise<PythonInvocation | null> {
+	const detected = await createInterpreterDetector().detect("py");
+	if (!detected.ok) return null;
+	const [command, ...args] = detected.path.split(" ");
+	return command === undefined ? null : { command, args };
+}
+
+let userPython: Promise<PythonInvocation | null> | undefined;
+
+export const pythonDisplay: PythonDisplay = createPythonDisplay({
+	interpreter: () => {
+		userPython ??= detectedPython();
+		return userPython;
+	},
+	strategies: DEFAULT_STRATEGIES,
+	timeoutMs: FORMAT_TIMEOUT_MS,
+});

package/src/tool/eval-request.ts

@@ -1,5 +1,11 @@
 import type { ExtensionContext } from "@code-yeongyu/senpi";
-import type { EvalControlInput, EvalToolInput, EvalToolRequest } from "./types.ts";
+import {
+	type EvalControlInput,
+	type EvalLanguage,
+	type EvalToolInput,
+	type EvalToolRequest,
+	evalLanguageOrder,
+} from "./types.ts";
 
 const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
 
@@ -11,7 +17,10 @@ export function normalizeEvalSummary(value: unknown): string | undefined {
 	return normalized.length === 0 ? undefined : normalized;
 }
 
-export function parseEvalRequest(params: unknown): EvalToolRequest {
+export function parseEvalRequest(
+	params: unknown,
+	enabledLanguages: readonly EvalLanguage[] = evalLanguageOrder,
+): EvalToolRequest {
 	if (!isRecord(params)) throw new TypeError("eval parameters must be an object");
 	if (params.action === "list") return { action: "list" };
 	if (params.action === "peek" || params.action === "stop") {
@@ -21,8 +30,9 @@ export function parseEvalRequest(params: unknown): EvalToolRequest {
 	}
 	if (params.action !== undefined && params.action !== "run")
 		throw new TypeError(`Unknown eval action "${String(params.action)}"`);
-	if (!isEvalLanguage(params.language)) throw new TypeError("eval run requires language");
-	if (typeof params.code !== "string") throw new TypeError("eval run requires code");
+	if (!isEvalLanguage(params.language)) throw new TypeError(evalRunRequiresLanguageMessage(enabledLanguages));
+	if (typeof params.code !== "string")
+		throw new TypeError("eval run requires code — the cell body to execute, verbatim");
 	const summary = normalizeEvalSummary(params.summary);
 	if (summary === undefined)
 		throw new TypeError(
@@ -57,3 +67,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 function isEvalLanguage(value: unknown): value is EvalToolInput["language"] {
 	return value === "py" || value === "js" || value === "rb" || value === "jl";
 }
+
+function evalRunRequiresLanguageMessage(languages: readonly EvalLanguage[]): string {
+	return `eval run requires language — one of ${languages.map((language) => `"${language}"`).join(", ")}`;
+}

package/src/tool/eval-tool.ts

@@ -73,7 +73,7 @@ export function createEvalTool(options: CreateEvalToolOptions) {
 	async function execute(
 		...[toolCallId, params, signal, onUpdate, ctx]: EvalExecuteArgs<EvalToolRequest>
 	): Promise<AgentToolResult<EvalResultDetails>> {
-		const request = parseEvalRequest(params);
+		const request = parseEvalRequest(params, languages);
 		if (isEvalControlRequest(request)) return await executeEvalControl(cellManager, request);
 		if (options.proxyExecutor) return await options.proxyExecutor(request, signal);
 		if (!languages.includes(request.language))

package/src/tool/render.ts

@@ -1,7 +1,6 @@
 // allow: SIZE_OK — one eval render pipeline avoids the runtime/render TDZ that motivated this module boundary.
 import {
 	type AgentToolResult,
-	highlightCode,
 	sanitizeTerminalLabel,
 	type Theme,
 	type ThemeColor,
@@ -10,6 +9,7 @@ import {
 	truncateToVisualLines,
 } from "@code-yeongyu/senpi";
 import type { TruncationMeta } from "../output/output-meta.ts";
+import { highlightedCode } from "./code-preview.ts";
 import { displayCode } from "./display-code.ts";
 import { normalizeEvalSummary } from "./eval-request.ts";
 import {
@@ -26,7 +26,6 @@ import { codePointPrefix, formatDuration, renderToolCallWidget } from "./tool-wi
 import type {
 	EvalCellResult,
 	EvalInputSchema,
-	EvalLanguage,
 	EvalResultDetails,
 	EvalStatusEvent,
 	EvalToolDetails,
@@ -269,6 +268,8 @@ type RenderEnvironment = {
 	readonly meta: TruncationMeta | undefined;
 	/** Render-time clock, injected so elapsed time is deterministic under test. */
 	readonly now: number;
+	/** Repaints the row once a background-formatted code preview is ready; absent while args stream. */
+	readonly repaint?: () => void;
 };
 type CellBadges = {
 	readonly reset: boolean;
@@ -288,27 +289,6 @@ function assertNever(value: never): never {
 	throw new TypeError(`Unhandled eval render variant: ${String(value)}`);
 }
 
-function languageForHighlighter(language: EvalLanguage): "python" | "javascript" | "ruby" | "julia" {
-	switch (language) {
-		case "py":
-			return "python";
-		case "js":
-			return "javascript";
-		case "rb":
-			return "ruby";
-		case "jl":
-			return "julia";
-		default:
-			return assertNever(language);
-	}
-}
-
-function highlightedCode(code: string, language: EvalLanguage, theme: Theme | undefined): string {
-	const normalizedCode = code.trim().length > 0 ? code : "...";
-	const lines = highlightCode(displayCode(normalizedCode, language), languageForHighlighter(language));
-	return (theme === undefined ? lines.map((line) => line.replace(/\u001b\[[0-9;]*m/gu, "")) : lines).join("\n");
-}
-
 function spinner(frame: number | undefined): string {
 	return SPINNER_FRAMES.at((frame ?? 0) % SPINNER_FRAMES.length) ?? SPINNER_FRAMES[0];
 }
@@ -644,7 +624,7 @@ 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),
+		highlightedCode(cell.code, cell.language, environment.theme, environment.repaint),
 		environment.expanded ? Number.POSITIVE_INFINITY : CODE_PREVIEW_LINES,
 		innerWidth,
 	);
@@ -926,7 +906,9 @@ export function renderEvalCall(
 				text: style(
 					theme,
 					"mdCodeBlock",
-					args.code.trim().length > 0 ? displayCode(args.code, args.language) : "...",
+					args.code.trim().length > 0
+						? displayCode(args.code, args.language, context.argsComplete ? context.invalidate : undefined)
+						: "...",
 				),
 				maxVisualLines: context.expanded ? undefined : CODE_PREVIEW_LINES,
 				collapseKind: "code",
@@ -946,6 +928,7 @@ export function renderEvalCall(
 					width,
 					meta: undefined,
 					now: renderNow(context),
+					...(context.argsComplete ? { repaint: context.invalidate } : {}),
 				};
 				const cell: EvalCellResult = {
 					index: 0,
@@ -998,6 +981,7 @@ export function renderEvalResult(
 							width,
 							meta: details.meta,
 							now: renderNow(context),
+							repaint: context.invalidate,
 						},
 						args: context.args,
 						showImageFallback: context.showImages && imageProtocol === null,

package/src/tool/types.ts

@@ -65,6 +65,12 @@ export type EvalControlInput =
 
 export type EvalToolRequest = EvalToolInput | EvalControlInput;
 
+// Like `summary`, `language` and `code` stay optional in the wire schema because control
+// actions share it; the description teaches the requirement and parseEvalRequest enforces it.
+const LANGUAGE_FIELD_DESCRIPTION =
+	"REQUIRED for run. Kernel that runs the cell; each language keeps its own persistent state across eval calls.";
+const CODE_FIELD_DESCRIPTION = "REQUIRED for run. Cell body, verbatim.";
+
 function evalInputProperties<Language extends TSchema>(languageSchema: Language, deadlines: EvalDeadlineSeconds) {
 	return {
 		action: Type.Optional(
@@ -74,7 +80,7 @@ function evalInputProperties<Language extends TSchema>(languageSchema: Language,
 			}),
 		),
 		language: Type.Optional(languageSchema),
-		code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
+		code: Type.Optional(Type.String({ description: CODE_FIELD_DESCRIPTION })),
 		summary: Type.Optional(
 			Type.String({
 				description:
@@ -96,11 +102,15 @@ function evalInputProperties<Language extends TSchema>(languageSchema: Language,
 	};
 }
 
+function evalLanguageUnion(languages: readonly EvalLanguage[]) {
+	return Type.Union(
+		languages.map((item) => Type.Literal(item)),
+		{ description: LANGUAGE_FIELD_DESCRIPTION },
+	);
+}
+
 const fullEvalInputSchema = Type.Object(
-	evalInputProperties(
-		Type.Union([Type.Literal("js"), Type.Literal("py"), Type.Literal("rb"), Type.Literal("jl")]),
-		defaultEvalDeadlineSeconds,
-	),
+	evalInputProperties(evalLanguageUnion(evalLanguageOrder), defaultEvalDeadlineSeconds),
 );
 
 /** Runtime accepts a discriminated run/control union. */
@@ -112,10 +122,7 @@ export function createEvalInputSchema(
 ): EvalInputSchema {
 	const languages = enabledLanguageList(enabled);
 	if (languages.length === 0) throw new Error("eval requires at least one enabled language");
-	const languageSchema =
-		languages.length === 1
-			? Type.Union([Type.Literal(languages[0])])
-			: Type.Union(languages.map((item) => Type.Literal(item)));
+	const languageSchema = evalLanguageUnion(languages);
 	return Type.Unsafe<EvalToolRequest>(
 		Type.Object(evalInputProperties(languageSchema, deadlines), {
 			anyOf: [