@code-yeongyu/senpi-codemode 2026.9.13-2 → 2026.9.15-2

package/src/tool/render.ts

@@ -71,10 +71,15 @@ const TOOL_CALL_COLLAPSED_VISUAL_LINES = 4;
 const TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS = 512;
 const TOOL_ERROR_OMISSION_MARKER = "[tool error omitted]";
 const LIVE_ELAPSED_TICK_MS = 1_000;
+// 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 = 60;
 
 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;
@@ -84,16 +89,19 @@ class PlainTextComponent implements EvalRenderComponent {
 	 * 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 elapsed time advances, and it emits no tool updates or RPC traffic.
+	 * header's elapsed time advances, and it emits 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;
 		}
-		if (this.#ticker !== undefined) return;
-		this.#ticker = setInterval(invalidate, LIVE_ELAPSED_TICK_MS);
-		this.#ticker.unref?.();
+		this.#armTicker();
 	}
 
 	stopLiveTicker(): void {
@@ -102,7 +110,24 @@ class PlainTextComponent implements EvalRenderComponent {
 		this.#ticker = undefined;
 	}
 
+	#armTicker(): void {
+		if (this.#ticker !== undefined || this.#invalidate === undefined) return;
+		this.#ticker = setInterval(() => this.#tick(), LIVE_ELAPSED_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) {
@@ -269,7 +294,7 @@ function spinner(frame: number | undefined): string {
 }
 
 function isLiveCellStatus(status: CellStatus): boolean {
-	return status === "pending" || status === "running" || status === "detached";
+	return status === "pending" || status === "running";
 }
 
 function cellPresentation(status: CellStatus, spinnerFrame: number | undefined): StatusPresentation {

package/src/tool/terminal-snapshot-store.ts

@@ -0,0 +1,35 @@
+import type { EvalDetachedCellSnapshot } from "./detached-cell-contract.ts";
+
+export const TERMINAL_SNAPSHOT_CAP = 32;
+
+/** Bounded LRU of settled-cell snapshots; without it every settled cell pins its result and closures for the session lifetime (#1695). */
+export class TerminalSnapshotStore {
+	readonly #snapshots = new Map<string, EvalDetachedCellSnapshot>();
+	readonly #cap: number;
+
+	constructor(cap = TERMINAL_SNAPSHOT_CAP) {
+		this.#cap = cap;
+	}
+
+	remember(snapshot: EvalDetachedCellSnapshot): void {
+		this.#snapshots.delete(snapshot.cellId);
+		this.#snapshots.set(snapshot.cellId, snapshot);
+		while (this.#snapshots.size > this.#cap) {
+			const oldest = this.#snapshots.keys().next();
+			if (oldest.done === true) break;
+			this.#snapshots.delete(oldest.value);
+		}
+	}
+
+	get(cellId: string): EvalDetachedCellSnapshot | undefined {
+		return this.#snapshots.get(cellId);
+	}
+
+	delete(cellId: string): void {
+		this.#snapshots.delete(cellId);
+	}
+
+	clear(): void {
+		this.#snapshots.clear();
+	}
+}

package/src/tool/tool-result-marshal.ts

@@ -0,0 +1,23 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+
+export function marshalToolResult(result: AgentToolResult<unknown>) {
+	const texts = result.content.filter((part) => part.type === "text").map((part) => part.text);
+	const images = result.content
+		.filter((part) => part.type === "image")
+		.map((part) => ({ mimeType: part.mimeType, dataBase64: part.data }));
+	const details =
+		typeof result.details === "object" &&
+		result.details !== null &&
+		!Array.isArray(result.details) &&
+		Object.keys(result.details).length === 0
+			? undefined
+			: result.details;
+	const hasError = toolResultIsError(result);
+	const text = texts.join("\n");
+	return images.length === 0 && details === undefined && !hasError ? { text } : { text, details, images, hasError };
+}
+
+export function toolResultIsError(result: AgentToolResult<unknown>): boolean {
+	const details = result.details;
+	return typeof details === "object" && details !== null && "isError" in details && details.isError === true;
+}

package/src/tool/tool-widgets.ts

@@ -139,6 +139,15 @@ function renderWith<TParams extends TSchema, TDetails, TState>(
 	}
 }
 
+function grepDetailsSummary(summary: EvalToolCallSummary): string | undefined {
+	const details = summary.details;
+	if (details === undefined || details === null || typeof details !== "object") return undefined;
+	const record = details as { matchCount?: unknown; fileCount?: unknown; engine?: unknown };
+	if (typeof record.fileCount !== "number" || typeof record.engine !== "string") return undefined;
+	if (record.matchCount !== null && typeof record.matchCount !== "number") return undefined;
+	return `matches=${record.matchCount ?? "n/a"} files=${record.fileCount} (${record.engine})`;
+}
+
 function createCoreWidgets(cwd: string): CoreWidgets {
 	const bashDefinition = createBashToolDefinition(cwd);
 	const readDefinition = createReadToolDefinition(cwd);
@@ -155,7 +164,13 @@ function createCoreWidgets(cwd: string): CoreWidgets {
 			}),
 		read: (summary, options) => renderWith(readDefinition, summary, options, {}),
 		write: (summary, options) => renderWith(writeDefinition, summary, options, {}),
-		grep: (summary, options) => renderWith(grepDefinition, summary, options, {}),
+		grep: (summary, options) => {
+			const lines = renderWith(grepDefinition, summary, options, {});
+			if (lines === undefined) return undefined;
+			const extra = grepDetailsSummary(summary);
+			if (extra !== undefined) lines.push(`  ${style(options.theme, "muted", extra)}`);
+			return lines;
+		},
 		find: (summary, options) => renderWith(findDefinition, summary, options, {}),
 		ls: (summary, options) => renderWith(lsDefinition, summary, options, {}),
 	};

package/src/tool/types.ts

@@ -153,6 +153,7 @@ export interface EvalToolCallSummary {
 	readonly argsTruncated?: boolean;
 	readonly durationMs?: number;
 	readonly resultPreview?: string;
+	readonly details?: unknown;
 }
 
 export type EvalStatusEvent = { readonly op: string } & Readonly<Record<string, unknown>>;