@code-yeongyu/senpi-codemode 2026.10.10-10 → 2026.10.10-12

package/src/kernels/shared/bun-ffi.ts

@@ -0,0 +1,24 @@
+/**
+ * The one read of `bun:ffi` behind a guard: `process.getBuiltinModule` returns the module on Bun and
+ * `undefined` on Node, so this module loads on either runtime, and only a result carrying the callable
+ * surface the CPU readers bind is treated as FFI - the same boundary `display-js.ts` uses for `Bun`.
+ */
+export type BunFfi = {
+	readonly dlopen: <S>(path: string, definitions: Record<string, unknown>) => { readonly symbols: S };
+	readonly FFIType: Record<string, number>;
+	readonly ptr: (buffer: ArrayBufferView) => number;
+};
+
+/** True when `value` carries the `bun:ffi` surface the kernel CPU readers use (`dlopen`, `FFIType`, `ptr`). */
+export function isBunFfi(value: unknown): value is BunFfi {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("dlopen" in value) || typeof value.dlopen !== "function") return false;
+	if (!("ptr" in value) || typeof value.ptr !== "function") return false;
+	return "FFIType" in value && typeof value.FFIType === "object" && value.FFIType !== null;
+}
+
+/** The runtime's `bun:ffi` module, or `undefined` on Node and on any runtime whose builtin is not one. */
+export function loadBunFfi(): BunFfi | undefined {
+	const ffi: unknown = process.getBuiltinModule("bun:ffi");
+	return isBunFfi(ffi) ? ffi : undefined;
+}

package/src/kernels/shared/kernel-memory-host.ts

@@ -1,4 +1,4 @@
-import type { KernelMemoryThresholds } from "../../bridge/memory-protocol.ts";
+import type { KernelMemoryReport, KernelMemoryThresholds } from "../../bridge/memory-protocol.ts";
 import type { KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { EvalLanguage } from "../../tool/types.ts";
 import { KernelMemoryPolicy } from "./kernel-memory.ts";
@@ -11,7 +11,7 @@ export type FootprintReader = (pid: number) => { readonly bytes: number } | unde
 export interface KernelMemoryHostOptions {
 	/**
 	 * Host-measured kernel (rb, jl): the host reads the interpreter's footprint after each result and
-	 * replaces the runner's live reading with it; the runner still names its largest globals, so the
+	 * replaces the runner's live reading with it; the runner names its largest globals on demand, so the
 	 * notice and the ceiling both apply, with every reading counting (no collection precedes it).
 	 */
 	readonly readFootprint?: FootprintReader;
@@ -36,12 +36,35 @@ export class KernelMemoryHost {
 	}
 
 	annotate(result: ResultMessage, pid?: number): ResultMessage {
+		return this.annotateReport(result, this.readReport(result, pid));
+	}
+
+	readReport(result: ResultMessage, pid?: number): KernelMemoryReport | undefined {
 		const runnerReport = result.memory;
-		const report =
-			this.#readFootprint === undefined
-				? runnerReport
-				: this.#footprintReport(this.#readFootprint, pid, runnerReport);
-		return report === undefined ? result : { ...result, memory: this.#policy.annotate(report) };
+		return this.#readFootprint === undefined
+			? runnerReport
+			: this.#footprintReport(this.#readFootprint, pid, runnerReport);
+	}
+
+	needsGlobals(report: KernelMemoryReport): boolean {
+		const { noticeBytes, ceilingBytes } = this.#policy.thresholds;
+		// Collect at or above the host-read notice threshold or ceiling, regardless of notice hysteresis;
+		// never collect below both thresholds. Zero disables a threshold, not the lazy diagnostic gate.
+		return (
+			(noticeBytes > 0 && report.liveBytes >= noticeBytes) || (ceilingBytes > 0 && report.liveBytes >= ceilingBytes)
+		);
+	}
+
+	annotateReport(result: ResultMessage, report: KernelMemoryReport | undefined): ResultMessage {
+		if (report === undefined) return result;
+		const memory = this.#policy.annotate(report);
+		// Safety accounting still observes every cell, but ordinary host-measured results carry no payload.
+		// A recycle announcement remains visible even when the replacement process is below threshold.
+		if (this.#readFootprint !== undefined && !this.needsGlobals(report) && memory.notice === undefined) {
+			const { memory: _memory, ...ordinary } = result;
+			return ordinary;
+		}
+		return { ...result, memory };
 	}
 
 	/**

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

@@ -8,9 +8,9 @@
  *   Windows has no process groups; this is the interpreter itself when it is launched directly.
  * - anything else, or Windows under Node: `undefined`, and the caller treats the CPU as unknown.
  */
+import { type BunFfi, loadBunFfi } from "./bun-ffi.ts";
 import { readProcessGroupCpuTime } from "./process-group-cpu.ts";
 
-type BunFfi = typeof import("bun:ffi");
 type CpuReader = (pid: number) => bigint | undefined;
 
 const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
@@ -26,7 +26,7 @@ export function readKernelCpuTime(pid: number): bigint | undefined {
 }
 
 function createWindowsReader(): CpuReader | undefined {
-	const ffi = process.getBuiltinModule("bun:ffi") as BunFfi | undefined;
+	const ffi = loadBunFfi();
 	if (ffi === undefined) return undefined;
 	try {
 		return bindGetProcessTimes(ffi);
@@ -37,7 +37,11 @@ function createWindowsReader(): CpuReader | undefined {
 }
 
 function bindGetProcessTimes({ dlopen, FFIType, ptr }: BunFfi): CpuReader {
-	const library = dlopen("kernel32.dll", {
+	const library = dlopen<{
+		OpenProcess: (access: number, inheritHandle: number, pid: number) => number | null;
+		GetProcessTimes: (handle: number, create: number, exit: number, kernel: number, user: number) => number;
+		CloseHandle: (handle: number) => number;
+	}>("kernel32.dll", {
 		OpenProcess: { args: [FFIType.u32, FFIType.i32, FFIType.u32], returns: FFIType.ptr },
 		GetProcessTimes: {
 			args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr],

package/src/kernels/shared/process-group-cpu.ts

@@ -15,8 +15,8 @@
  */
 import { execFileSync } from "node:child_process";
 import { readdirSync, readFileSync } from "node:fs";
+import { type BunFfi, loadBunFfi } from "./bun-ffi.ts";
 
-type BunFfi = typeof import("bun:ffi");
 type GroupCpuReader = (pgid: number) => bigint | undefined;
 
 const RUSAGE_INFO_V2 = 2;
@@ -59,7 +59,7 @@ export function parsePsCpuTime(text: string): bigint | undefined {
 function createGroupReader(): GroupCpuReader | undefined {
 	if (process.platform === "linux") return linuxGroupReader;
 	if (process.platform !== "darwin") return undefined;
-	const ffi = process.getBuiltinModule("bun:ffi") as BunFfi | undefined;
+	const ffi = loadBunFfi();
 	if (ffi === undefined) return darwinPsGroupReader;
 	try {
 		return darwinGroupReader(ffi);
@@ -116,7 +116,10 @@ function linuxGroupReader(pgid: number): bigint | undefined {
 }
 
 function darwinGroupReader({ dlopen, FFIType, ptr }: BunFfi): GroupCpuReader {
-	const library = dlopen("libSystem.B.dylib", {
+	const library = dlopen<{
+		proc_listpgrppids: (pgid: number, buffer: number, byteLength: number) => number;
+		proc_pid_rusage: (pid: number, flavor: number, buffer: number) => number;
+	}>("libSystem.B.dylib", {
 		proc_listpgrppids: { args: [FFIType.i32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
 		proc_pid_rusage: { args: [FFIType.i32, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
 	});

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

@@ -1,3 +1,4 @@
+// allow: SIZE_OK — subprocess protocol, FIFO ownership, retirement, and replacement form one serialized state machine.
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelInterruptHandle, PendingCell } from "../../tool/types.ts";
@@ -7,6 +8,7 @@ import { applySessionEnvironment } from "../session-env.ts";
 import { describeExit } from "./kernel-death.ts";
 import { KernelMemoryHost } from "./kernel-memory-host.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
+import { SubprocessMemoryGlobals } from "./subprocess-memory-globals.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
 import { SubprocessRunQueue } from "./subprocess-queue.ts";
 import {
@@ -39,6 +41,7 @@ export class SubprocessKernel {
 	private readonly onMessage?: (message: KernelToHostMessage) => void;
 	private readonly runs = new SubprocessRunQueue();
 	private readonly memory: KernelMemoryHost | null;
+	private readonly globals = new SubprocessMemoryGlobals();
 	private process: SubprocessProcess | null = null;
 	private processReady = false;
 	private startup: SubprocessStartupWatchdog | null = null;
@@ -90,8 +93,10 @@ export class SubprocessKernel {
 			this.runs.settleAll(new CellInterruptedError(reason));
 			return { stateRetained: Promise.resolve(true) };
 		}
+		if (this.globals.completeWithoutGlobals()) return { stateRetained: Promise.resolve(true) };
 		const process = this.process;
 		process?.retire();
+		this.globals.reset();
 		this.runs.clearToolCalls();
 		const run = this.runs.active;
 		if (!run) return { stateRetained: Promise.resolve(true) };
@@ -126,6 +131,7 @@ export class SubprocessKernel {
 
 	async reset(): Promise<void> {
 		if (this.closed) throw new KernelClosedError();
+		this.globals.reset();
 		this.settleAll(new KernelResetError());
 		this.runs.clearToolCalls();
 		await this.restartProcess(this.process);
@@ -135,6 +141,7 @@ export class SubprocessKernel {
 	async close(): Promise<void> {
 		const wasClosed = this.closed;
 		this.closed = true;
+		this.globals.reset();
 		this.startup?.stop();
 		if (!wasClosed) {
 			this.settleAll(new KernelClosingError());
@@ -175,6 +182,7 @@ export class SubprocessKernel {
 		if (this.runs.active !== run || run.settled) return;
 		const process = this.process;
 		process?.retire();
+		this.globals.reset();
 		this.runs.clearToolCalls();
 		this.runs.releaseActive(run);
 		this.runs.settle(run, timeoutResult(run, timeoutMs));
@@ -199,6 +207,7 @@ export class SubprocessKernel {
 			},
 		});
 		this.process = process;
+		this.globals.reset();
 		this.processReady = false;
 		this.startup?.stop();
 		const startup = this.options.startup;
@@ -237,6 +246,7 @@ export class SubprocessKernel {
 		if (!this.accepts(process)) return;
 		if (!this.processReady) this.startup?.observe(message);
 		if (message.type === "ready") {
+			this.globals.reset(message.memoryGlobals === true);
 			this.startup?.stop();
 			this.processReady = true;
 			this.runs.handleMessage(message, this.onMessage);
@@ -248,9 +258,23 @@ export class SubprocessKernel {
 			this.failClosed(new KernelStartupError(message.error.message));
 			return;
 		}
-		const ownResult = message.type === "result" && this.runs.active?.input.cellId === message.cellId;
-		const settled = ownResult && this.memory ? this.memory.annotate(message, process.child.pid) : message;
-		if (!this.runs.handleMessage(settled, this.onMessage)) return;
+		const run = this.runs.active;
+		if (message.type === "memory-globals-result") {
+			if (this.memory) this.globals.reply({ process, run }, message, this.memory);
+			return;
+		}
+		if (message.type === "result" && run?.input.cellId === message.cellId && this.memory) {
+			this.globals.request({ process, run, result: message }, this.memory, (result) => {
+				if (!this.accepts(process) || this.runs.active !== run || run.settled) return;
+				this.settleMessage(result);
+			});
+			return;
+		}
+		this.settleMessage(message);
+	}
+
+	private settleMessage(message: KernelToHostMessage): void {
+		if (!this.runs.handleMessage(message, this.onMessage)) return;
 		this.pumpRuns();
 		this.recycleOverCeilingWhenIdle();
 	}
@@ -270,6 +294,7 @@ export class SubprocessKernel {
 			return;
 		}
 		this.process = null;
+		this.globals.reset();
 		this.processReady = false;
 		const error = new KernelExitedError(signal ?? code ?? "unknown");
 		if (this.options.onDeath) this.die(error, describeExit(code, signal), this.options.onDeath);
@@ -362,6 +387,7 @@ export class SubprocessKernel {
 
 	private failClosed(error: Error): void {
 		this.startup?.stop();
+		this.globals.reset();
 		const process = this.process;
 		this.failure = error;
 		this.closed = true;

package/src/kernels/shared/subprocess-memory-globals.ts

@@ -0,0 +1,101 @@
+import type { KernelMemoryReport } from "../../bridge/memory-protocol.ts";
+import { encodeBridgeFrame, type KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelMemoryHost } from "./kernel-memory-host.ts";
+import type { KernelResult } from "./subprocess-contract.ts";
+import type { SubprocessProcess } from "./subprocess-process.ts";
+import type { PendingRun } from "./subprocess-run.ts";
+
+const GLOBALS_TIMEOUT_MS = 5_000;
+type GlobalsProcess = Pick<SubprocessProcess, "send"> & {
+	readonly child: { readonly pid?: number };
+};
+
+interface PendingGlobals {
+	readonly process: GlobalsProcess;
+	readonly run: PendingRun;
+	readonly result: KernelResult;
+	readonly report: KernelMemoryReport;
+	readonly memory: KernelMemoryHost;
+	readonly finish: (result: KernelResult) => void;
+	readonly timer: ReturnType<typeof setTimeout>;
+}
+
+/** Holds FIFO cell ownership until its bounded diagnostic is returned or its deadline expires. */
+export class SubprocessMemoryGlobals {
+	#pending: PendingGlobals | null = null;
+	#available = false;
+
+	reset(available = false): void {
+		if (this.#pending !== null) clearTimeout(this.#pending.timer);
+		this.#pending = null;
+		this.#available = available;
+	}
+
+	request(
+		owner: {
+			readonly process: GlobalsProcess;
+			readonly run: PendingRun;
+			readonly result: KernelResult;
+		},
+		memory: KernelMemoryHost,
+		finish: (result: KernelResult) => void,
+	): void {
+		if (this.#pending !== null) return;
+		const report = memory.readReport(owner.result, owner.process.child.pid);
+		if (!this.#available || report === undefined || !memory.needsGlobals(report)) {
+			finish(memory.annotateReport(owner.result, report));
+			return;
+		}
+		const pending: PendingGlobals = {
+			...owner,
+			report,
+			memory,
+			finish,
+			timer: setTimeout(() => {
+				if (this.#pending !== pending) return;
+				this.#pending = null;
+				pending.finish(memory.annotateReport(pending.result, report));
+			}, GLOBALS_TIMEOUT_MS),
+		};
+		this.#pending = pending;
+		owner.process.send(
+			encodeBridgeFrame({
+				type: "memory-globals",
+				cellId: owner.result.cellId,
+			}),
+		);
+	}
+
+	/** Settles an already-finished cell immediately when stop arrives during its optional diagnostic. */
+	completeWithoutGlobals(): boolean {
+		const pending = this.#pending;
+		if (pending === null) return false;
+		clearTimeout(pending.timer);
+		this.#pending = null;
+		pending.finish(pending.memory.annotateReport(pending.result, pending.report));
+		return true;
+	}
+
+	reply(
+		owner: {
+			readonly process: GlobalsProcess;
+			readonly run: PendingRun | null;
+		},
+		message: Extract<KernelToHostMessage, { type: "memory-globals-result" }>,
+		memory: KernelMemoryHost,
+	): void {
+		const pending = this.#pending;
+		if (
+			pending === null ||
+			pending.process !== owner.process ||
+			pending.run !== owner.run ||
+			pending.result.cellId !== message.cellId
+		)
+			return;
+		clearTimeout(pending.timer);
+		this.#pending = null;
+		const report = message.globals.length === 0 ? pending.report : { ...pending.report, globals: message.globals };
+		const result = memory.annotateReport(pending.result, report);
+		pending.finish(result);
+	}
+}

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