@code-yeongyu/senpi-codemode 2026.10.10-9 → 2026.10.11

package/src/kernels/shared/subprocess-process.ts

@@ -1,9 +1,13 @@
 import { spawn as nodeSpawn } from "node:child_process";
 import { createInterface, type Interface as ReadlineInterface } from "node:readline";
+import { killWindowsTree } from "../js/windows-tree-kill-host.ts";
 
 export interface SubprocessLike {
 	readonly pid?: number;
-	readonly stdin: { write(chunk: string): unknown };
+	readonly stdin: {
+		write(chunk: string): unknown;
+		on?(event: "error", listener: (error: Error) => void): unknown;
+	};
 	readonly stdout: NodeJS.ReadableStream;
 	readonly stderr: NodeJS.ReadableStream;
 	on(event: "error", listener: (error: Error) => void): this;
@@ -46,11 +50,13 @@ export class SubprocessProcess {
 	private readonly stdoutReader: ReadlineInterface;
 	private readonly stderrListener: (chunk: string | Buffer) => void;
 	private readonly errorListener: (error: Error) => void;
+	private readonly stdinErrorListener: (error: Error) => void;
 	private exited = false;
 	private retiring = false;
 	private outputDetached = false;
 	private errorReported = false;
 	private terminationPromise: Promise<boolean> | null = null;
+	private windowsTreeKill: Promise<void> | undefined;
 
 	constructor(child: SubprocessLike, handlers: SubprocessProcessHandlers) {
 		this.child = child;
@@ -67,8 +73,16 @@ export class SubprocessProcess {
 		this.stdoutReader.on("line", (line) => {
 			if (!this.retiring) this.handlers.onLine(this, `${line}\n`);
 		});
+		// senpi#3016: a frame written while the child is dying fails on the stdin stream (EPIPE), which emits there
+		// and not on the ChildProcess. Unhandled, it is a process-level error that can end the host; once the child is
+		// gone or being retired the write failure carries no news, otherwise it is this process's error.
+		this.stdinErrorListener = (error) => {
+			if (this.exited || this.retiring) return;
+			this.errorListener(error);
+		};
 		child.stderr.on("data", this.stderrListener);
 		child.on("error", this.errorListener);
+		child.stdin.on?.("error", this.stdinErrorListener);
 		child.once("exit", (code, signal) => {
 			this.exited = true;
 			this.detachOutput();
@@ -83,7 +97,7 @@ export class SubprocessProcess {
 	}
 
 	send(frame: string): boolean {
-		if (this.retiring) return false;
+		if (this.retiring || this.exited) return false;
 		this.child.stdin.write(frame);
 		return true;
 	}
@@ -125,6 +139,8 @@ export class SubprocessProcess {
 		this.retire();
 		if (this.exited) return true;
 		this.kill(initialSignal);
+		// On Windows the kill first lists processes (up to 5 s); the exit wait starts once taskkill has run.
+		if (this.windowsTreeKill) await this.windowsTreeKill;
 		if (await this.waitForExit(escalationMs)) return true;
 		this.kill("SIGKILL");
 		return await this.waitForExit(forcedExitWaitMs);
@@ -152,7 +168,8 @@ export class SubprocessProcess {
 
 	private kill(signal: NodeJS.Signals): void {
 		if (globalThis.process.platform === "win32") {
-			if (this.child.pid !== undefined) killProcessTree(this.child.pid);
+			// taskkill /F is already forced, so escalation reuses the first kill instead of listing again.
+			if (this.child.pid !== undefined) this.windowsTreeKill ??= killWindowsTree(this.child.pid);
 			else this.child.kill(signal);
 			return;
 		}
@@ -168,15 +185,6 @@ export class SubprocessProcess {
 	}
 }
 
-// Windows has no process-group signal: taskkill /T /F walks the tree rooted at the child.
-function killProcessTree(pid: number): void {
-	try {
-		nodeSpawn("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
-	} catch (error) {
-		if (!(error instanceof Error)) throw error;
-	}
-}
-
 export function spawnSubprocess(spawn: SubprocessSpawn | undefined, request: SubprocessSpawnRequest): SubprocessLike {
 	if (spawn) return spawn(request.command, request.args, { cwd: request.cwd, env: request.env });
 	const child = nodeSpawn(request.command, [...request.args], {

package/src/kernels/shared/subprocess-queue.ts

@@ -120,6 +120,7 @@ export class SubprocessRunQueue {
 				return false;
 			case "webview-connect":
 			case "memory-query-result":
+			case "memory-globals-result":
 			case "kernel-tools-defined":
 				return false;
 			default: {

package/src/tool/eval-tool.ts

@@ -25,6 +25,7 @@ import {
 	type EvalListInput,
 	type EvalResultDetails,
 	type EvalToolDetails,
+	type EvalToolInput,
 	type EvalToolRequest,
 	enabledLanguageList,
 } from "./types.ts";
@@ -34,7 +35,7 @@ export type { CreateEvalToolOptions } from "./eval-tool-options.ts";
 export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./types.ts";
 
 type EvalExecuteArgs<Request extends EvalToolRequest> = Parameters<
-	ToolDefinition<TUnsafe<Request>, EvalToolDetails>["execute"]
+	ToolDefinition<TUnsafe<Request | Partial<EvalToolInput>>, EvalToolDetails>["execute"]
 >;
 
 export function createEvalTool(options: CreateEvalToolOptions) {

package/src/tool/render-agent.ts

@@ -0,0 +1,110 @@
+import {
+	appendLines,
+	assertNever,
+	type RenderEnvironment,
+	renderPrefixed,
+	type StatusPresentation,
+	spinner,
+	style,
+} from "./render-blocks.ts";
+import { eventString } from "./render-status.ts";
+import { formatDuration } from "./tool-widgets.ts";
+import type { EvalStatusEvent } from "./types.ts";
+
+type AgentStatus = "pending" | "running" | "completed" | "failed" | "aborted";
+
+function eventNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function agentStatus(value: unknown): AgentStatus {
+	switch (value) {
+		case "pending":
+		case "running":
+		case "completed":
+		case "failed":
+		case "aborted":
+			return value;
+		default:
+			return "running";
+	}
+}
+
+function coalesceAgentEvents(events: readonly EvalStatusEvent[]): EvalStatusEvent[] {
+	const rows: EvalStatusEvent[] = [];
+	const indexes = new Map<string, number>();
+	for (const event of events) {
+		const id = eventString(event.id);
+		if (id === undefined) {
+			rows.push(event);
+			continue;
+		}
+		const index = indexes.get(id);
+		if (index === undefined) {
+			indexes.set(id, rows.length);
+			rows.push(event);
+		} else rows[index] = event;
+	}
+	return rows;
+}
+
+function agentPresentation(status: AgentStatus, spinnerFrame: number | undefined): StatusPresentation {
+	switch (status) {
+		case "pending":
+			return { label: "pending", icon: "○", color: "muted" };
+		case "running":
+			return { label: "running", icon: spinner(spinnerFrame), color: "warning" };
+		case "completed":
+			return { label: "done", icon: "✓", color: "success" };
+		case "failed":
+			return { label: "failed", icon: "✗", color: "error" };
+		case "aborted":
+			return { label: "aborted", icon: "×", color: "error" };
+		default:
+			return assertNever(status);
+	}
+}
+
+export function renderAgentProgressEvents(
+	events: readonly EvalStatusEvent[],
+	environment: RenderEnvironment,
+): string[] {
+	const rows = coalesceAgentEvents(events);
+	const lines: string[] = [];
+	// Senpi Theme has no tree-token API; fixed ├/└/│ glyphs intentionally mirror omp.
+	for (const [index, event] of rows.entries()) {
+		const isLast = index === rows.length - 1;
+		const status = agentStatus(event.status);
+		const presentation = agentPresentation(status, environment.spinnerFrame);
+		const id = eventString(event.id) ?? "agent";
+		const styledId = environment.theme === undefined ? id : environment.theme.bold(id);
+		let body = `${style(environment.theme, presentation.color, presentation.icon)} ${styledId} ${presentation.label}`;
+		if (status === "completed" || status === "failed" || status === "aborted") {
+			const duration = eventNumber(event.durationMs);
+			if (duration > 0) body += ` · ${style(environment.theme, "dim", formatDuration(duration))}`;
+		}
+		const branch = isLast ? "└ " : "├ ";
+		const continuation = isLast ? "  " : "│ ";
+		appendLines(
+			lines,
+			renderPrefixed(body, environment, { prefix: branch, continuation: continuation, color: "dim" }),
+		);
+		if (status !== "running") continue;
+		const currentTool = eventString(event.currentTool);
+		const lastIntent = eventString(event.lastIntent);
+		if (currentTool === undefined && lastIntent === undefined) continue;
+		const detail =
+			currentTool === undefined
+				? (lastIntent ?? "")
+				: `${currentTool}${lastIntent === undefined ? "" : `: ${lastIntent}`}`;
+		appendLines(
+			lines,
+			renderPrefixed(detail, environment, {
+				prefix: `${continuation}└ `,
+				continuation: `${continuation}  `,
+				color: "dim",
+			}),
+		);
+	}
+	return lines;
+}

package/src/tool/render-blocks.ts

@@ -0,0 +1,252 @@
+import { type Theme, type ThemeColor, type ToolDefinition, truncateToVisualLines } from "@code-yeongyu/senpi";
+import type { TruncationMeta } from "../output/output-meta.ts";
+import { codePointPrefix } from "./tool-widgets.ts";
+import type { EvalInputSchema, EvalResultDetails, EvalToolInput, EvalToolRequest } from "./types.ts";
+
+type EvalToolDefinition = ToolDefinition<EvalInputSchema, EvalResultDetails>;
+export type CallRenderContext = Parameters<NonNullable<EvalToolDefinition["renderCall"]>>[2];
+export type ResultRenderContext = Parameters<NonNullable<EvalToolDefinition["renderResult"]>>[3];
+type CollapsibleKind = "code" | "output";
+
+export interface EvalRenderComponent {
+	render(width: number): string[];
+	invalidate(): void;
+}
+type ToolCallRow = {
+	readonly summary: string;
+	readonly error?: string;
+	readonly color: "success" | "error";
+};
+export type RenderBlock =
+	| { readonly kind: "blank" }
+	| {
+			readonly kind: "text";
+			readonly text: string;
+			readonly maxVisualLines?: number;
+			readonly collapseKind?: CollapsibleKind;
+			readonly theme?: Theme;
+	  }
+	| {
+			readonly kind: "toolCalls";
+			readonly calls: readonly ToolCallRow[];
+			readonly expanded: boolean;
+			readonly theme?: Theme;
+	  }
+	| { readonly kind: "dynamic"; readonly render: (width: number) => readonly string[] };
+
+export const CODE_PREVIEW_LINES = 4;
+export const SUMMARY_PREVIEW_LINES = 3;
+export const OUTPUT_PREVIEW_LINES = 8;
+export const STATUS_PREVIEW_COUNT = 3;
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
+export const TOOL_CALL_PREVIEW_COUNT = 5;
+const TOOL_CALL_COLLAPSED_VISUAL_LINES = 4;
+const TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS = 512;
+const TOOL_ERROR_OMISSION_MARKER = "[tool error omitted]";
+export const LIVE_RENDER_TICK_MS = 100;
+// A live row repaints on every tick, so this many ticks without a render means the row is gone.
+const LIVE_TICKER_MAX_IDLE_TICKS = 600;
+
+export type StatusPresentation = { readonly label: string; readonly icon: string; readonly color: ThemeColor };
+export type RenderEnvironment = {
+	readonly expanded: boolean;
+	readonly theme: Theme | undefined;
+	readonly spinnerFrame: number | undefined;
+	readonly width: number;
+	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;
+};
+export type PrefixStyle = { readonly prefix: string; readonly continuation: string; readonly color: ThemeColor };
+
+class PlainTextComponent implements EvalRenderComponent {
+	#blocks: readonly RenderBlock[] = [];
+	#ticker: ReturnType<typeof setInterval> | undefined;
+	#live = false;
+	#invalidate: (() => void) | undefined;
+	#idleTicks = 0;
+
+	setBlocks(blocks: readonly RenderBlock[]): void {
+		this.#blocks = blocks;
+	}
+
+	/**
+	 * The host only animates tool rows for streaming args, `task`, and results carrying
+	 * `details.progress`; an eval row matches none of them, so nothing repaints it between
+	 * update events. While a cell is non-terminal this drives the repaint itself so the
+	 * header's spinner and elapsed time advance, with no tool updates or RPC traffic. Detached
+	 * and terminal cards never arm it, and a ticker whose row stopped rendering (transcript
+	 * rebuild, session switch) stops itself after LIVE_TICKER_MAX_IDLE_TICKS and rearms on
+	 * the next render, so dropped rows cannot accumulate intervals.
+	 */
+	syncLiveTicker(isLive: boolean, invalidate: () => void): void {
+		this.#live = isLive;
+		this.#invalidate = invalidate;
+		if (!isLive) {
+			this.stopLiveTicker();
+			return;
+		}
+		this.#armTicker();
+	}
+
+	stopLiveTicker(): void {
+		if (this.#ticker === undefined) return;
+		clearInterval(this.#ticker);
+		this.#ticker = undefined;
+	}
+
+	#armTicker(): void {
+		if (this.#ticker !== undefined || this.#invalidate === undefined) return;
+		this.#ticker = setInterval(() => this.#tick(), LIVE_RENDER_TICK_MS);
+		this.#ticker.unref?.();
+	}
+
+	#tick(): void {
+		this.#idleTicks += 1;
+		if (this.#idleTicks >= LIVE_TICKER_MAX_IDLE_TICKS) {
+			this.stopLiveTicker();
+			return;
+		}
+		this.#invalidate?.();
+	}
+
+	render(width: number): string[] {
+		this.#idleTicks = 0;
+		if (this.#live) this.#armTicker();
+		const lines: string[] = [];
+		for (const block of this.#blocks) {
+			switch (block.kind) {
+				case "blank":
+					lines.push("");
+					break;
+				case "toolCalls":
+					appendLines(lines, renderToolCallBlock(block, width));
+					break;
+				case "text":
+					appendLines(lines, renderTextBlock(block, width));
+					break;
+				case "dynamic":
+					appendLines(lines, block.render(width));
+					break;
+				default:
+					assertNever(block);
+			}
+		}
+		return lines;
+	}
+
+	invalidate(): void {}
+}
+
+export function componentFor(context: CallRenderContext | ResultRenderContext): PlainTextComponent {
+	const existing = context.lastComponent;
+	if (existing instanceof PlainTextComponent) return existing;
+	return new PlainTextComponent();
+}
+
+/** Render-time clock; tests inject a fixed value so elapsed output never depends on wall time. */
+export function renderNow(context: CallRenderContext | ResultRenderContext): number {
+	const injected: unknown = Reflect.get(context, "now");
+	return typeof injected === "number" && Number.isFinite(injected) ? injected : Date.now();
+}
+
+export function isEvalRunInput(args: EvalToolRequest | Partial<EvalToolInput>): args is EvalToolInput {
+	return args.action === undefined || args.action === "run";
+}
+
+export function style(theme: Theme | undefined, color: ThemeColor, text: string): string {
+	return theme ? theme.fg(color, text) : text;
+}
+
+export function appendLines(target: string[], source: readonly string[]): void {
+	for (const line of source) target.push(line);
+}
+
+export function renderAllVisualLines(text: string, width: number): string[] {
+	return truncateToVisualLines(text, Number.POSITIVE_INFINITY, width).visualLines.map((line) => line.trimEnd());
+}
+
+function renderTextBlock(block: Extract<RenderBlock, { kind: "text" }>, width: number): string[] {
+	if (block.maxVisualLines === undefined) return renderAllVisualLines(block.text, width);
+	const result = truncateToVisualLines(block.text, block.maxVisualLines, width);
+	const visualLines = result.visualLines.map((line) => line.trimEnd());
+	if (result.skippedCount === 0 || block.collapseKind === undefined) return visualLines;
+	return [
+		...renderAllVisualLines(
+			style(block.theme, "muted", `${result.skippedCount} earlier ${block.collapseKind} lines`),
+			width,
+		),
+		...visualLines,
+	];
+}
+
+export function renderToolCall(
+	call: ToolCallRow,
+	block: Extract<RenderBlock, { kind: "toolCalls" }>,
+	width: number,
+): string[] {
+	if (call.error === undefined) return renderAllVisualLines(style(block.theme, call.color, call.summary), width);
+	if (block.expanded)
+		return renderAllVisualLines(style(block.theme, call.color, `${call.summary} (${call.error})`), width);
+
+	const guardedError = codePointPrefix(call.error, TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS);
+	const guardedLines = renderAllVisualLines(
+		style(block.theme, call.color, `${call.summary} (${guardedError})`),
+		width,
+	);
+	if (guardedError.length === call.error.length && guardedLines.length <= TOOL_CALL_COLLAPSED_VISUAL_LINES)
+		return guardedLines;
+
+	const summaryLines = renderAllVisualLines(style(block.theme, call.color, call.summary), width);
+	const errorLines = renderAllVisualLines(style(block.theme, call.color, `  (${guardedError})`), width);
+	const markerLines = renderAllVisualLines(style(block.theme, "muted", TOOL_ERROR_OMISSION_MARKER), width);
+	const lines: string[] = [];
+	const summaryBudget = Math.max(1, TOOL_CALL_COLLAPSED_VISUAL_LINES - markerLines.length);
+	appendLines(lines, summaryLines.slice(0, summaryBudget));
+	const errorBudget = Math.max(0, TOOL_CALL_COLLAPSED_VISUAL_LINES - lines.length - markerLines.length);
+	appendLines(lines, errorLines.slice(0, errorBudget));
+	appendLines(lines, markerLines.slice(0, TOOL_CALL_COLLAPSED_VISUAL_LINES - lines.length));
+	return lines;
+}
+
+function renderToolCallBlock(block: Extract<RenderBlock, { kind: "toolCalls" }>, width: number): string[] {
+	const retainedCalls = block.expanded ? block.calls : block.calls.slice(-TOOL_CALL_PREVIEW_COUNT);
+	const skippedCount = block.calls.length - retainedCalls.length;
+	const toolCallNoun = skippedCount === 1 ? "call" : "calls";
+	const lines =
+		block.expanded || skippedCount === 0
+			? []
+			: renderAllVisualLines(style(block.theme, "muted", `${skippedCount} earlier tool ${toolCallNoun}`), width);
+	for (const call of retainedCalls) {
+		appendLines(lines, renderToolCall(call, block, width));
+	}
+	return lines;
+}
+
+export function assertNever(value: never): never {
+	throw new TypeError(`Unhandled eval render variant: ${String(value)}`);
+}
+
+export function spinner(frame: number | undefined): string {
+	return SPINNER_FRAMES.at((frame ?? 0) % SPINNER_FRAMES.length) ?? SPINNER_FRAMES[0];
+}
+
+export function renderPrefixed(text: string, environment: RenderEnvironment, prefixStyle: PrefixStyle): string[] {
+	const bodyLines = renderAllVisualLines(text, Math.max(1, environment.width - prefixStyle.prefix.length));
+	if (bodyLines.length === 0) return [style(environment.theme, prefixStyle.color, prefixStyle.prefix.trimEnd())];
+	return bodyLines.map(
+		(line, index) =>
+			`${style(environment.theme, prefixStyle.color, index === 0 ? prefixStyle.prefix : prefixStyle.continuation)}${line}`,
+	);
+}
+
+export function previewText(
+	text: string,
+	maxLines: number,
+	width: number,
+): { readonly lines: string[]; readonly skipped: number } {
+	const preview = truncateToVisualLines(text, maxLines, Math.max(1, width));
+	return { lines: preview.visualLines.map((line) => line.trimEnd()), skipped: preview.skippedCount };
+}

package/src/tool/render-call.ts

@@ -0,0 +1,130 @@
+import { sanitizeTerminalLabel, type Theme } from "@code-yeongyu/senpi";
+import { displayCode } from "./display-code.ts";
+import { normalizeEvalSummary } from "./eval-request.ts";
+import { knownLanguage } from "./live-headline.ts";
+import {
+	type CallRenderContext,
+	CODE_PREVIEW_LINES,
+	componentFor,
+	type EvalRenderComponent,
+	isEvalRunInput,
+	type RenderEnvironment,
+	renderNow,
+	renderPrefixed,
+	spinner,
+	style,
+} from "./render-blocks.ts";
+import { renderCell, summaryBlock } from "./render-cell.ts";
+import { headlined, LIVE_LINE_PREFIX } from "./render-live.ts";
+import type { EvalCellResult, EvalToolInput, EvalToolRequest } from "./types.ts";
+
+// The call renderer reads the assistant message's raw arguments, which keep the provider's
+// original summary (senpi#1472 detached preparation from the message), so it normalizes here,
+// idempotently: an already-normalized value is returned unchanged.
+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 | Partial<EvalToolInput>,
+	theme: Theme | undefined,
+	context: CallRenderContext,
+): EvalRenderComponent {
+	const component = componentFor(context);
+	if (context.hasResult === true) {
+		// The result renderer owns the full pending -> running -> done frame once a result exists.
+		// Rendering the call frame too would stack a duplicate box, so yield to it here.
+		component.syncLiveTicker(false, context.invalidate);
+		component.setBlocks([]);
+		return component;
+	}
+	if (!isEvalRunInput(args)) {
+		// While a peek/stop call streams in, `cell_id` can still be missing; the title is the action alone until it arrives.
+		const cellId = "cell_id" in args ? args.cell_id : undefined;
+		const title = args.action === "list" ? "eval list" : `eval ${args.action}${cellIdSuffix(cellId)}`;
+		component.syncLiveTicker(false, context.invalidate);
+		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);
+	component.syncLiveTicker(theme !== undefined, context.invalidate);
+	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${language === undefined ? "" : ` ${language}`}${reset}${timeout}`),
+			},
+			...(displaySummary(args.summary) === undefined
+				? []
+				: [summaryBlock(displaySummary(args.summary) ?? "", theme, context.expanded)]),
+			{
+				kind: "text",
+				text: style(
+					theme,
+					"mdCodeBlock",
+					code.trim().length === 0
+						? "..."
+						: language === undefined
+							? code
+							: displayCode(code, language, context.argsComplete ? context.invalidate : undefined),
+				),
+				maxVisualLines: context.expanded ? undefined : CODE_PREVIEW_LINES,
+				collapseKind: "code",
+				theme,
+			},
+		]);
+		return component;
+	}
+	component.setBlocks([
+		{
+			kind: "dynamic",
+			render: (width) => {
+				const environment: RenderEnvironment = {
+					expanded: context.expanded,
+					theme,
+					spinnerFrame: context.spinnerFrame,
+					width,
+					meta: undefined,
+					now: renderNow(context),
+					...(context.argsComplete ? { repaint: context.invalidate } : {}),
+				};
+				const summary = displaySummary(args.summary);
+				if (language === undefined) return streamingCallLines(summary, code, environment);
+				// The host never supplies a spinner frame for an eval call, so the state comes from
+				// the call lane itself: run args are present and no result exists yet (review MEDIUM-1).
+				// The ticker (armed in renderEvalCall) repaints the block, so the spinner advances.
+				const streaming = context.hasResult !== true;
+				const cell: EvalCellResult = {
+					index: 0,
+					...(summary === undefined ? {} : { summary }),
+					code,
+					language,
+					output: "",
+					status: streaming ? "running" : "pending",
+				};
+				return renderCell(cell, environment, {
+					reset: args.reset === true,
+					timeout: args.timeout,
+					throughput: undefined,
+					streaming,
+				});
+			},
+		},
+	]);
+	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);
+}