@gajae-code/coding-agent 0.11.11 → 0.12.0

package/src/internal-urls/local-root-gc.ts

@@ -0,0 +1,127 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { isEnoent } from "@gajae-code/utils";
+import type { GcCollectResult, GcContext, GcError, GcRecord, GcStoreAdapter } from "../gjc-runtime/gc-runtime";
+
+/**
+ * GC for `local://` session roots.
+ *
+ * `resolveLocalRoot` gives every session its own `<tmp>/gjc-local/<session-id>`
+ * directory, and the first `local://` resolution seeds it with a migration
+ * marker. Nothing ever removes those directories, so a machine accumulates one
+ * per session indefinitely — and the overwhelming majority only ever hold the
+ * marker, because most sessions never write a `local://` file.
+ *
+ * Only marker-only directories are eligible, and only after a grace period.
+ * That keeps the rule provably safe without needing a session-liveness oracle:
+ * a directory holding real content is never touched, and a session that just
+ * started is still inside its grace window.
+ */
+
+const LOCAL_ROOT_PARENT = "gjc-local";
+const LEGACY_MIGRATION_MARKER = ".gjc-local-legacy-migrated-v1";
+
+/** Directories younger than this are left alone so a live session is never raced. */
+const GRACE_MS = 24 * 60 * 60 * 1000;
+
+/** Bound the scan so a pathological directory cannot stall `gjc gc`. */
+const MAX_ENTRIES = 20_000;
+
+function localRootParent(env: NodeJS.ProcessEnv): string {
+	return path.join(env.TMPDIR?.trim() || os.tmpdir(), LOCAL_ROOT_PARENT);
+}
+
+/** A root is prunable only when the marker is the single thing inside it. */
+async function classify(dir: string, now: number): Promise<{ status: string; stale: boolean; reason: string } | null> {
+	let entries: string[];
+	try {
+		entries = await fs.readdir(dir);
+	} catch (error) {
+		if (isEnoent(error)) return null;
+		throw error;
+	}
+
+	const extra = entries.filter(name => name !== LEGACY_MIGRATION_MARKER);
+	if (extra.length > 0)
+		return {
+			status: "in_use",
+			stale: false,
+			reason: `Holds ${extra.length} entr${extra.length === 1 ? "y" : "ies"} beyond the marker`,
+		};
+
+	const stat = await fs.stat(dir);
+	if (now - stat.mtimeMs < GRACE_MS) return { status: "recent", stale: false, reason: "Inside the grace window" };
+	return { status: "marker_only", stale: true, reason: "Only the migration marker, past the grace window" };
+}
+
+export const localRootsGcAdapter: GcStoreAdapter = {
+	store: "local_roots",
+	async collect(ctx: GcContext): Promise<GcCollectResult> {
+		const records: GcRecord[] = [];
+		const errors: GcError[] = [];
+		const parent = localRootParent(ctx.env);
+		const now = Date.now();
+
+		let dirents: string[];
+		try {
+			dirents = await fs.readdir(parent);
+		} catch (error) {
+			if (isEnoent(error)) return { records, errors };
+			errors.push({ store: "local_roots", scope: parent, message: (error as Error).message });
+			return { records, errors };
+		}
+
+		for (const name of dirents.slice(0, MAX_ENTRIES)) {
+			const dir = path.join(parent, name);
+			try {
+				const classified = await classify(dir, now);
+				if (!classified) continue;
+				records.push({
+					store: "local_roots",
+					id: name,
+					path: dir,
+					status: classified.status,
+					stale: classified.stale,
+					removable: classified.stale,
+					action: classified.stale ? "would_remove" : "none",
+					reason: classified.reason,
+				});
+			} catch (error) {
+				errors.push({ store: "local_roots", scope: dir, message: (error as Error).message });
+			}
+		}
+
+		if (dirents.length > MAX_ENTRIES) {
+			errors.push({
+				store: "local_roots",
+				scope: parent,
+				message: `Scan truncated at ${MAX_ENTRIES} entries`,
+			});
+		}
+
+		return { records, errors };
+	},
+	async prune(record: GcRecord) {
+		const dir = record.path;
+		if (!dir) return { removed: false, error: "Missing local root path" };
+
+		// Re-validate immediately before removing: the session may have written a
+		// file between collect and prune.
+		let classified: Awaited<ReturnType<typeof classify>>;
+		try {
+			classified = await classify(dir, Date.now());
+		} catch (error) {
+			return { removed: false, error: (error as Error).message };
+		}
+		if (!classified) return { removed: false, skipped: "Local root disappeared" };
+		if (!classified.stale) return { removed: false, skipped: `Local root no longer eligible (${classified.status})` };
+
+		try {
+			await fs.rm(dir, { recursive: true, force: true });
+			return { removed: true };
+		} catch (error) {
+			return { removed: false, error: (error as Error).message };
+		}
+	},
+};

package/src/main.ts

@@ -698,7 +698,7 @@ async function promptForkSession(session: SessionInfo): Promise<boolean> {
 	}
 }
 
-async function getChangelogForDisplay(parsed: Args): Promise<string | undefined> {
+export async function getChangelogForDisplay(parsed: Args): Promise<string | undefined> {
 	if (parsed.continue || parsed.resume) {
 		return undefined;
 	}
@@ -710,15 +710,19 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 
 	const lastVersion = settings.get("lastChangelogVersion");
 	if (!lastVersion) {
-		settings.set("lastChangelogVersion", VERSION);
-		await flushChangelogVersion();
+		if (settings.canWriteDurableConfig()) {
+			settings.set("lastChangelogVersion", VERSION);
+			await flushChangelogVersion();
+		}
 		return getInstalledVersionChangelogEntry(entries, VERSION)?.content;
 	}
 
 	if (lastVersion !== VERSION) {
 		const newEntries = getNewEntries(entries, lastVersion);
-		settings.set("lastChangelogVersion", VERSION);
-		await flushChangelogVersion();
+		if (settings.canWriteDurableConfig()) {
+			settings.set("lastChangelogVersion", VERSION);
+			await flushChangelogVersion();
+		}
 		if (newEntries.length > 0) {
 			return newEntries.map(e => e.content).join("\n\n");
 		}

package/src/memories/index.ts

@@ -976,6 +976,11 @@ function redactSecrets(input: string): string {
 		/(?:sk|pk|rk|tok|key|secret|token|password)[-_A-Za-z0-9]{12,}/g,
 		/[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}/g,
 		/(?:AKIA|ASIA)[A-Z0-9]{16}/g,
+		// GitHub tokens carry no keyword the first pattern recognizes, so without
+		// this they reached MEMORY.md and memory_summary.md verbatim — and the
+		// summary is injected into every later session. Same shapes the
+		// contribution-prep scrubber already covers.
+		/\b(?:gh[opsur]_[A-Za-z0-9_]{12,}|github_pat_[A-Za-z0-9_]{12,})\b/g,
 	];
 	for (const pattern of patterns) {
 		out = out.replace(pattern, "[REDACTED]");
@@ -983,6 +988,11 @@ function redactSecrets(input: string): string {
 	return out;
 }
 
+/** Secret scrubbing applied to every phase-2 consolidation output. Test seam. */
+export function redactMemorySecretsForTesting(input: string): string {
+	return redactSecrets(input);
+}
+
 function sanitizeSkillName(name: string): string {
 	return name
 		.toLowerCase()

package/src/modes/DESIGN.md

@@ -261,3 +261,50 @@ record both manifest counts as 108 plus CJK review results.
 
 No raw third-party design corpus, screenshot, or reference asset is stored by
 this workflow.
+
+## Sticky transcript viewport contract
+
+Live mode remains in natural terminal flow. Entering manual history makes the
+application-owned transcript lane scrollable while the status line and every
+later direct composer child are a fixed suffix at the bottom. PageUp/PageDown
+move by the transcript capacity; the wheel remains three rows. A focused editor
+keeps focus, and ordinary editor input or paste follows live before processing
+that input.
+
+Manual output has one bounded boolean indication, exactly **`New output — type
+to follow`**. It is not a count. New visible agent/tool/extension output may set
+it while manual; reflow, transient chrome, reconciliation, and user input may
+not. Following clears it only after a successful live repaint. Manual-era output
+is authoritative in the application transcript but is never retroactively
+replayed into native host scrollback; subsequent ordinary live output follows
+normal host behavior.
+
+The transcript is the only selectable coordinate space. Pinned status/composer
+chrome, notices, blank rows, and overlays never enter selection or copied text;
+CJK selection clamping remains directional and grapheme/cell aware. Under
+constrained height the notice drops first, then decorative pet and low-priority
+hooks. Focused editor/cursor, status, and normal hooks outrank those rows; zero
+transcript capacity is valid and must not corrupt cursor geometry.
+
+At narrow widths use ANSI-aware terminal-cell measurement. ASCII/no-color keeps
+textual state without SGR. Korean, Japanese, Chinese, and mixed CJK/Latin prose
+must wrap at semantic phrase boundaries, never through an action/status label or
+short identifier; a semantic CJK break is a visual-QA failure.
+
+### Sticky viewport deterministic visual QA
+
+`test/fixtures/tui/sticky-viewport-showcase.ts` is a fixed-clock, no-network,
+first-party harness that starts the production `TUI` over a `VirtualTerminal`.
+It constructs transcript, status, hooks, and the real composer as children,
+then drives the live/manual viewport path before capturing the terminal frame.
+Capture with `bun packages/coding-agent/scripts/capture-sticky-viewport-showcase.ts
+--out .gjc/qa/sticky-viewport-<run>` and verify with the paired `--root` script.
+The immutable matrix has exactly 20 keys: `live-overflow`, `manual-history`,
+`manual-new-output`, `multiline-editor-hooks-pet`, `capacity-many`,
+`capacity-one`, `capacity-zero`, and `selection-boundary` at both 80x24 and
+120x36 Unicode/color; plus `manual-new-output/80x24/ascii-no-color`,
+`capacity-zero/48x10/ascii-no-color`,
+`multiline-editor-hooks-pet/48x10/unicode-color`, and
+`narrow-cjk/48x10/unicode-color`. Do not add or replace a manual-follow case.
+
+Each key has only `terminal.txt`, ANSI-preserving `terminal-ansi.txt`, `terminal.html`, and `metadata.json`; the manifest records SHA-256 and byte length. Per-key metadata binds immutable font/render assumptions and the ANSI-aware wrapping/truncation policy. `VirtualTerminal` reconstructs ANSI from visible xterm cells, including cell padding, palette/RGB colors, attributes, and inverse video; plain text is always the stripped reconstruction. The verifier owns an independent literal 20-key oracle and fails closed unless stripped ANSI equals text, `terminal.html` equals the exported canonical `ansiToHtml(terminal-ansi.txt)` byte-for-byte (including its complete document envelope and global CSS), HTML independently preserves the ANSI style-run text, every retained row has the exact `Bun.stringWidth` cell width (including trailing spaces), and `ansi_mode` agrees with required Unicode color SGR or ASCII/no-color output. Every metadata entry has exact CJK phrase-boundary metadata: the narrow-CJK key has only the three canonical boundaries in order and every other key has `[]`. Manual captures prove successful production wheel and PageUp paths and retain observable historical transcript-row evidence. It validates exact payload paths (no duplicates or traversal), immutable source/output revisions, state/status/suffix order, notice cardinality, capacity, actual mouse-copied transcript-only selection, composer, CJK, and provenance invariants. `review-input.json` binds the exact manifest digest, capture author/executor identity, acceptance/design versions, required artifacts, narrow-CJK boundaries, and deterministic host matrix. `--require-independent-review` requires an attestation with an exact root key set; exact per-key result and artifact-check key sets; exact defect `{ description, accepted }` keys with a trimmed, nonblank description; canonical trimmed reviewer identity distinct from both bound identities; the independent-terminal-reviewer role; fixture revision; expected and observed counts of 20; exact checked keys; accepted per-key artifact-check/notes results; accepted artifact/CJK/host decisions; bound digest; and final `accept`. Any malformed, incomplete, or extra attestation content fails closed.

package/src/modes/acp/acp-agent.ts

@@ -25,6 +25,7 @@ import {
 	PROTOCOL_VERSION,
 	type PromptRequest,
 	type PromptResponse,
+	RequestError,
 	type ResumeSessionRequest,
 	type ResumeSessionResponse,
 	type SessionInfo,
@@ -532,6 +533,34 @@ export function acpPromptPayload(blocks: PromptRequest["prompt"]): {
 	return { text: text.join("\n"), images };
 }
 
+/**
+ * `AcpSdkAdapterError.code` is an internal string, but the SDK only derives a
+ * JSON-RPC code from a `RequestError`. Everything else collapses to an opaque
+ * `-32603 Internal error`, which hides the reason and defeats client-side
+ * recovery (an ACP client cannot see that it must authenticate). Map the codes
+ * that have a defined ACP/JSON-RPC counterpart onto a real `RequestError`.
+ */
+export function acpRequestFailure(error: unknown): unknown {
+	const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+	if (typeof code !== "string") return error;
+	const message = error instanceof Error ? error.message : code;
+	switch (code) {
+		case "authentication_failed":
+			return RequestError.authRequired({ code, details: message }, message);
+		case "not_found":
+			return RequestError.resourceNotFound(message);
+		case "invalid_input":
+		case "unsupported":
+		case "unsupported_content":
+			return RequestError.invalidParams({ code, details: message }, message);
+		default:
+			// The remaining internal codes (conflict, unavailable, busy, …) have no ACP
+			// counterpart and stay -32603. Keep the discriminator in `data` so a client can
+			// branch on retry/reconnect instead of parsing an English message.
+			return RequestError.internalError({ code, details: message }, message);
+	}
+}
+
 /** Registers a permission provider only when the ACP client requires prompts. */
 export function acpProviderRegistrations(
 	capabilities: ClientCapabilities | undefined,
@@ -988,6 +1017,16 @@ export class AcpAgent implements Agent {
 	}
 
 	async extMethod(method: string, params: JsonObject): Promise<JsonObject> {
+		// An unrecognized extension method is a protocol failure, not an application
+		// result: it must reach the client as JSON-RPC -32601 rather than a resolved
+		// payload. Recognized `_gjc/*` methods keep their `{ok:false}` result contract.
+		if (
+			method !== "session/set_model" &&
+			method !== "_gjc/sdk/global" &&
+			method !== "_gjc/sdk/control" &&
+			method !== "_gjc/sdk/query"
+		)
+			throw RequestError.methodNotFound(method);
 		try {
 			if (method === "session/set_model") {
 				const sessionId = typeof params.sessionId === "string" ? params.sessionId : undefined;
@@ -1001,13 +1040,10 @@ export class AcpAgent implements Agent {
 				const result = await (await this.#brokerAdapter()).handle(method, params);
 				return object(result) ?? {};
 			}
-			if (method === "_gjc/sdk/control" || method === "_gjc/sdk/query") {
-				const id = typeof params.sessionId === "string" ? params.sessionId : undefined;
-				if (!id) throw new AcpSdkAdapterError("invalid_input", "sessionId is required.");
-				const result = await this.#adapter(id).handle(method, params);
-				return object(result) ?? {};
-			}
-			throw new AcpSdkAdapterError("method_not_found", `Unknown ACP ext method: ${method}`);
+			const id = typeof params.sessionId === "string" ? params.sessionId : undefined;
+			if (!id) throw new AcpSdkAdapterError("invalid_input", "sessionId is required.");
+			const result = await this.#adapter(id).handle(method, params);
+			return object(result) ?? {};
 		} catch (error) {
 			const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "internal";
 			const message = error instanceof Error ? error.message : String(error);

package/src/modes/acp/acp-event-mapper.ts

@@ -198,7 +198,10 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		}
 		case "tool_execution_end": {
 			const args = getToolExecutionEndArgs(event, options);
-			const resultContent = [...extractDiffToolCallContent(event.result), ...extractToolCallContent(event.result)];
+			const resultContent = [
+				...extractDiffToolCallContent(event.result, options.cwd),
+				...extractToolCallContent(event.result),
+			];
 			const content = mergeToolUpdateContent(buildToolStartContent(event.toolName, args), resultContent);
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call_update",
@@ -207,8 +210,9 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 				rawOutput: event.result,
 			};
 			if (event.isError) {
+				// Failure is carried by `status`; `kind` stays the tool's real category so
+				// clients keep the icon/treatment established by the initial `tool_call`.
 				update.title = `Failed: ${buildToolTitle(event.toolName, args, undefined)}`;
-				update.kind = "other";
 			}
 			if (content.length > 0) {
 				update.content = content;
@@ -713,7 +717,7 @@ function extractToolLocationsFromResult(result: unknown, cwd?: string): ToolCall
 }
 
 /** Emit a `diff` ToolCallContent for each per-file edit result that carries oldText/newText. */
-function extractDiffToolCallContent(result: unknown): ToolCallContent[] {
+function extractDiffToolCallContent(result: unknown, cwd?: string): ToolCallContent[] {
 	if (typeof result !== "object" || result === null) return [];
 	const details = (result as { details?: unknown }).details;
 	if (typeof details !== "object" || details === null) return [];
@@ -721,13 +725,13 @@ function extractDiffToolCallContent(result: unknown): ToolCallContent[] {
 	const perFile = (details as { perFileResults?: unknown }).perFileResults;
 	const entries: unknown[] = Array.isArray(perFile) ? perFile : [details];
 	for (const entry of entries) {
-		const block = buildDiffContent(entry);
+		const block = buildDiffContent(entry, cwd);
 		if (block) blocks.push(block);
 	}
 	return blocks;
 }
 
-function buildDiffContent(entry: unknown): ToolCallContent | undefined {
+function buildDiffContent(entry: unknown, cwd?: string): ToolCallContent | undefined {
 	if (typeof entry !== "object" || entry === null) return undefined;
 	const candidate = entry as { path?: unknown; oldText?: unknown; newText?: unknown; isError?: unknown };
 	if (candidate.isError === true) return undefined;
@@ -738,7 +742,8 @@ function buildDiffContent(entry: unknown): ToolCallContent | undefined {
 	if (oldText === undefined && newText === undefined) return undefined;
 	return {
 		type: "diff",
-		path,
+		// `Diff.path` is specified as an absolute path, same as ToolCallLocation.
+		path: toAcpLocationPath(path, cwd),
 		oldText: oldText ?? null,
 		newText: newText ?? "",
 	};
@@ -859,7 +864,9 @@ function toToolCallContent(value: unknown): ToolCallContent | undefined {
 				resourceLinkContent.mimeType = mimeType;
 			}
 			const size = extractNumberProperty<ResourceLinkLikeContent>(value, "size");
-			if (size !== undefined) {
+			// `ResourceLink.size` is a byte count typed as int64; drop fractional, negative,
+			// or non-representable values rather than emitting a block clients must reject.
+			if (size !== undefined && Number.isSafeInteger(size) && size >= 0) {
 				resourceLinkContent.size = size;
 			}
 			return {

package/src/modes/acp/acp-mode.ts

@@ -1,6 +1,6 @@
 import * as stream from "node:stream";
-import { AgentSideConnection, ndJsonStream, type Stream } from "@agentclientprotocol/sdk";
-import { AcpAgent } from "./acp-agent";
+import { type Agent, AgentSideConnection, ndJsonStream, type Stream } from "@agentclientprotocol/sdk";
+import { AcpAgent, acpRequestFailure } from "./acp-agent";
 import type { AcpStartupOptions } from "./startup-options";
 
 export interface AcpModeOptions {
@@ -8,8 +8,44 @@ export interface AcpModeOptions {
 	startupOptions?: AcpStartupOptions;
 }
 
+/**
+ * Every agent method reports failures to the client, and the SDK only derives a
+ * JSON-RPC code from a `RequestError` — anything else collapses to an opaque
+ * `-32603 Internal error` with the reason buried in `data`. Translating once at the
+ * connection boundary keeps that contract in one place instead of asking each method
+ * to remember it.
+ */
+function withAcpRequestFailures(agent: AcpAgent): Agent {
+	const wrapped = new Map<string | symbol, (...args: unknown[]) => unknown>();
+	return new Proxy(agent, {
+		get(target, property) {
+			// Read against the target, not the proxy: `signal`/`closed` are getters that
+			// touch private fields, and the proxy carries no private-field brand.
+			const value = Reflect.get(target, property, target);
+			if (typeof value !== "function") return value;
+			const cached = wrapped.get(property);
+			if (cached) return cached;
+			// Cache per property so repeated reads keep a stable method identity.
+			const wrapper = (...args: unknown[]) => {
+				try {
+					const result = (value as (...a: unknown[]) => unknown).apply(target, args);
+					return result instanceof Promise
+						? result.catch((error: unknown) => {
+								throw acpRequestFailure(error);
+							})
+						: result;
+				} catch (error) {
+					throw acpRequestFailure(error);
+				}
+			};
+			wrapped.set(property, wrapper);
+			return wrapper;
+		},
+	}) as unknown as Agent;
+}
+
 export function createAcpConnection(transport: Stream, options: AcpModeOptions = {}): AgentSideConnection {
-	return new AgentSideConnection(conn => new AcpAgent(conn, options), transport);
+	return new AgentSideConnection(conn => withAcpRequestFailures(new AcpAgent(conn, options)), transport);
 }
 
 export async function runAcpMode(options: AcpModeOptions = {}): Promise<never> {

package/src/modes/components/assistant-message.ts

@@ -84,8 +84,10 @@ export class AssistantMessageComponent extends Container {
 	#lastMessage?: AssistantMessage;
 	#toolImagesByCallId = new Map<string, ImageContent[]>();
 	#usageInfo?: Usage;
-	#convertedKittyImages = new Map<string, ImageContent>();
-	#kittyConversionsInFlight = new Set<string>();
+	#convertedKittyImages = new Map<string, ImageContent & { source: string }>();
+	#kittyConversionsInFlight = new Map<string, string>();
+	#toolImageGenerations = new Map<string, number>();
+
 	#responseHeader = new Text(theme.bold(theme.fg("statusLineModel", "gajae")), 1, 0);
 	#contentBlocksCache = new WeakMap<object, { source: string; component: Component }>();
 	#lastStreaming = false;
@@ -94,11 +96,17 @@ export class AssistantMessageComponent extends Container {
 	#nextContentBlockKey = 0;
 	#reusableChildren = new WeakSet<Component>();
 	#viewportAnchorId?: string;
+	#visibleSignature = "";
+	#visibleSignatureInitialized = false;
+	#toolImagesRevision = 0;
+	#convertedToolImagesRevision = 0;
+	#disposed = false;
 	constructor(
 		message?: AssistantMessage,
 		private hideThinkingBlock = false,
 		private readonly onImageUpdate?: () => void,
 		viewportAnchorId?: string,
+		private readonly onVisibleMutation?: () => void,
 	) {
 		super();
 		this.#viewportAnchorId = viewportAnchorId;
@@ -109,6 +117,56 @@ export class AssistantMessageComponent extends Container {
 		if (message) {
 			this.updateContent(message);
 		}
+		this.#visibleSignature = this.#visibleContentSignature();
+		this.#visibleSignatureInitialized = true;
+	}
+
+	#visibleContentSignature(): string {
+		const message = this.#lastMessage;
+		const content: string[] = [];
+		let hasMarkdownContent = false;
+		for (const block of message?.content ?? []) {
+			if (block.type === "text" && block.text.trim()) {
+				content.push(`text:${block.text.trim()}`);
+				hasMarkdownContent = true;
+			} else if (block.type === "thinking" && block.thinking.trim()) {
+				content.push(
+					this.hideThinkingBlock
+						? "thinking"
+						: `thinking:${elideRunawayThinkingRepetition(block.thinking.trim())}`,
+				);
+				if (!this.hideThinkingBlock) hasMarkdownContent = true;
+			}
+		}
+		if (hasMarkdownContent) {
+			content.unshift(this.#lastStreaming ? "streaming" : "final");
+		}
+		const hasToolCalls = message?.content.some(block => block.type === "toolCall") ?? false;
+		if (!hasToolCalls && message?.stopReason === "aborted" && !isSilentAbort(message.errorMessage)) {
+			content.push(`aborted:${message.errorMessage ?? ""}`);
+		} else if (!hasToolCalls && message?.stopReason === "error") {
+			content.push(`error:${message.errorMessage ?? ""}`);
+		} else if (
+			message?.errorMessage &&
+			!isSilentAbort(message.errorMessage) &&
+			message.stopReason !== "aborted" &&
+			message.stopReason !== "error"
+		) {
+			content.push(`message-error:${message.errorMessage}`);
+		}
+		if (settings.get("display.showTokenUsage") && this.#usageInfo) {
+			const usage = this.#usageInfo;
+			content.push(`usage:${usage.input}:${usage.cacheWrite}:${usage.output}:${usage.cacheRead}`);
+		}
+		content.push(`images:${this.#toolImagesRevision}:${this.#convertedToolImagesRevision}`);
+		return content.join("\u0000");
+	}
+
+	#notifyVisibleMutation(): void {
+		const after = this.#visibleContentSignature();
+		if (after === this.#visibleSignature) return;
+		this.#visibleSignature = after;
+		if (this.#visibleSignatureInitialized) this.onVisibleMutation?.();
 	}
 
 	#contentAnchorSource(
@@ -126,22 +184,36 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	setHideThinkingBlock(hide: boolean): void {
+		if (this.hideThinkingBlock === hide) return;
 		this.hideThinkingBlock = hide;
+		this.#notifyVisibleMutation();
 	}
 
 	setToolResultImages(toolCallId: string, images: ImageContent[]): void {
 		if (!toolCallId) return;
 		const validImages = images.filter(img => img.type === "image" && img.data && img.mimeType);
+		const previousImages = this.#toolImagesByCallId.get(toolCallId);
+		if (
+			(previousImages?.length ?? 0) === validImages.length &&
+			(previousImages?.every(
+				(image, index) =>
+					image.type === validImages[index]?.type &&
+					image.data === validImages[index]?.data &&
+					image.mimeType === validImages[index]?.mimeType,
+			) ??
+				true)
+		) {
+			return;
+		}
 		for (const key of Array.from(this.#convertedKittyImages.keys())) {
-			if (key.startsWith(`${toolCallId}:`)) {
-				this.#convertedKittyImages.delete(key);
-			}
+			if (key.startsWith(`${toolCallId}:`)) this.#convertedKittyImages.delete(key);
 		}
-		for (const key of Array.from(this.#kittyConversionsInFlight)) {
-			if (key.startsWith(`${toolCallId}:`)) {
-				this.#kittyConversionsInFlight.delete(key);
-			}
+		for (const key of Array.from(this.#kittyConversionsInFlight.keys())) {
+			if (key.startsWith(`${toolCallId}:`)) this.#kittyConversionsInFlight.delete(key);
 		}
+		this.#toolImageGenerations.set(toolCallId, (this.#toolImageGenerations.get(toolCallId) ?? 0) + 1);
+
+		this.#toolImagesRevision += 1;
 		if (validImages.length === 0) {
 			this.#toolImagesByCallId.delete(toolCallId);
 		} else {
@@ -153,30 +225,49 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	#toolImageSource(image: ImageContent): string {
+		return `${image.mimeType}\u0000${image.data}`;
+	}
+
 	#convertToolImagesForKitty(toolCallId: string, images: ImageContent[]): void {
 		if (TERMINAL.imageProtocol !== ImageProtocol.Kitty) return;
-		for (let index = 0; index < images.length; index++) {
-			const image = images[index];
-			if (!image || image.mimeType === "image/png") continue;
+		const generation = this.#toolImageGenerations.get(toolCallId) ?? 0;
+		for (const [index, image] of images.entries()) {
+			if (image.mimeType === "image/png") continue;
 			const key = `${toolCallId}:${index}`;
-			if (this.#convertedKittyImages.has(key) || this.#kittyConversionsInFlight.has(key)) continue;
-			this.#kittyConversionsInFlight.add(key);
+			const source = this.#toolImageSource(image);
+			if (
+				this.#convertedKittyImages.get(key)?.source === source ||
+				this.#kittyConversionsInFlight.get(key) === source
+			)
+				continue;
+			this.#kittyConversionsInFlight.set(key, source);
 			new Bun.Image(Buffer.from(image.data, "base64"))
 				.png()
 				.toBase64()
 				.then(data => {
+					const currentImage = this.#toolImagesByCallId.get(toolCallId)?.[index];
+					if (
+						this.#disposed ||
+						this.#toolImageGenerations.get(toolCallId) !== generation ||
+						this.#kittyConversionsInFlight.get(key) !== source ||
+						!currentImage ||
+						this.#toolImageSource(currentImage) !== source
+					)
+						return;
 					this.#kittyConversionsInFlight.delete(key);
-					this.#convertedKittyImages.set(key, {
-						type: "image",
-						data,
-						mimeType: "image/png",
-					});
-					if (this.#lastMessage) {
-						this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
-					}
+					this.#convertedKittyImages.set(key, { type: "image", data, mimeType: "image/png", source });
+					this.#convertedToolImagesRevision += 1;
+					if (this.#lastMessage) this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
 					this.onImageUpdate?.();
 				})
 				.catch(() => {
+					if (
+						this.#disposed ||
+						this.#toolImageGenerations.get(toolCallId) !== generation ||
+						this.#kittyConversionsInFlight.get(key) !== source
+					)
+						return;
 					this.#kittyConversionsInFlight.delete(key);
 				});
 		}
@@ -487,5 +578,15 @@ export class AssistantMessageComponent extends Container {
 		}
 
 		this.#reconcileChildren(descriptors);
+		this.#notifyVisibleMutation();
+	}
+
+	override dispose(): void {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#toolImageGenerations.clear();
+		this.#kittyConversionsInFlight.clear();
+		this.#convertedKittyImages.clear();
+		super.dispose();
 	}
 }