@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/lsp/config.ts

@@ -336,14 +336,21 @@ export function resolveCommand(command: string, cwd: string): string | null {
 	return piUtils.$which(command);
 }
 
-/** Resolve an LSP executable without consulting project-controlled bin directories. */
+/**
+ * Resolve an LSP executable without consulting project-controlled bin directories.
+ *
+ * Trust is evaluated on both the discovered and canonical paths, but the returned
+ * path is the discovered one: multiplexed launchers such as rustup pick the proxied
+ * tool from argv[0], so `~/.cargo/bin/rust-analyzer -> rustup` must be spawned as
+ * `rust-analyzer`, not as the resolved `rustup` binary.
+ */
 function resolveTrustedLspCommand(command: string, cwd: string): string | null {
 	if (!path.isAbsolute(command) && (command.includes("/") || command.includes("\\"))) return null;
 	const discovered = path.isAbsolute(command) ? command : piUtils.$which(command);
 	if (!discovered) return null;
 	if (isProjectControlledPath(discovered, cwd)) return null;
-	const canonical = canonicalExistingPath(discovered);
-	return canonical;
+	if (!canonicalExistingPath(discovered)) return null;
+	return discovered;
 }
 
 interface ConfigSource {

package/src/lsp/index.ts

@@ -1160,7 +1160,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 			const serverStatus =
 				servers.length > 0
-					? `Active language servers: ${servers.join(", ")}`
+					? `Configured language servers: ${servers.join(", ")}`
 					: "No language servers configured for this project";
 
 			const output = lspmuxStatus ? `${serverStatus}\n${lspmuxStatus}` : serverStatus;

package/src/lsp/path-trust.ts

@@ -59,29 +59,84 @@ function findProjectTrustRoot(start: string, stopPaths: ReadonlySet<string>): st
 	}
 }
 
+function isProjectMarkerRoot(root: string): boolean {
+	return fs.existsSync(path.join(root, ".git")) || isDirectory(path.join(root, CONFIG_DIR_NAME));
+}
+
+/**
+ * Spellings of `candidate` that differ only in how HOME is named: the path as
+ * given, plus the same path with any ancestor that is HOME under another name
+ * replaced by canonical HOME. The suffix beneath HOME is kept as spelled, and an
+ * alias that lives inside a project (`repo/home-link -> HOME`) is project
+ * content, not a HOME spelling, so it is never expanded.
+ */
+function candidateSpellings(candidate: string, canonicalHome: string, projectRoot: string | undefined): string[] {
+	const resolved = path.resolve(candidate);
+	const spellings = [resolved];
+	const normalizedHome = normalizePathForComparison(canonicalHome);
+	let current = path.dirname(resolved);
+	for (;;) {
+		if (
+			normalizePathForComparison(current) !== normalizedHome &&
+			(projectRoot === undefined || !pathIsLexicallyWithin(projectRoot, current)) &&
+			normalizePathForComparison(canonicalPath(current)) === normalizedHome
+		) {
+			spellings.push(path.join(canonicalHome, path.relative(current, resolved)));
+		}
+		const parent = path.dirname(current);
+		if (parent === current) return spellings;
+		current = parent;
+	}
+}
+
 export function isProjectControlledPath(candidate: string, cwd: string): boolean {
 	const home = os.homedir();
-	const stopPaths = new Set([path.resolve(home), canonicalPath(home)].map(normalizePathForComparison));
+	const canonicalHome = canonicalPath(home);
+	const stopPaths = new Set([path.resolve(home), canonicalHome].map(normalizePathForComparison));
 	const lexicalTrustRoot = findProjectTrustRoot(cwd, stopPaths);
-	const candidateIsHomeScoped = pathIsLexicallyWithin(home, candidate) || pathIsWithin(home, candidate);
-	if (
-		lexicalTrustRoot !== undefined &&
-		pathIsLexicallyWithin(lexicalTrustRoot, candidate) &&
-		(!candidateIsHomeScoped || pathIsLexicallyWithin(home, lexicalTrustRoot))
-	)
-		return true;
+	// A trust root outside HOME must not claim user executables inside HOME
+	// (e.g. ~/.gjc/bin); a root under HOME still owns what it contains. Each check
+	// judges home scope on the same view of the path it inspects, without
+	// dereferencing the candidate's final component: mixing views let a project
+	// link into HOME, or a HOME link into the project, escape rejection. HOME may
+	// be spelled lexically or canonically on either side, so the lexical check
+	// runs over every HOME-alias spelling of both the candidate and the root.
+	if (lexicalTrustRoot !== undefined) {
+		const trustRootIsHomeScoped = pathIsWithin(canonicalHome, lexicalTrustRoot);
+		// A root under HOME may legitimately be reached through a HOME alias, and a
+		// bare fallback root (no project marker) owns nothing on its own; a real
+		// project root outside HOME owns every alias directory it contains.
+		const aliasBoundary =
+			!trustRootIsHomeScoped && isProjectMarkerRoot(lexicalTrustRoot) ? lexicalTrustRoot : undefined;
+		const rootSpellings = candidateSpellings(lexicalTrustRoot, canonicalHome, undefined);
+		const spellings = candidateSpellings(candidate, canonicalHome, aliasBoundary);
+		// Every spelling names the same location, so home scope is a property of
+		// the location: one spelling under HOME makes all of them HOME-scoped.
+		const candidateIsHomeScoped = spellings.some(
+			spelling => pathIsLexicallyWithin(home, spelling) || pathIsLexicallyWithin(canonicalHome, spelling),
+		);
+		if (
+			(!candidateIsHomeScoped || trustRootIsHomeScoped) &&
+			spellings.some(spelling => rootSpellings.some(root => pathIsLexicallyWithin(root, spelling)))
+		) {
+			return true;
+		}
+	}
 
+	const canonicalCandidate = canonicalPath(candidate);
+	const canonicalCandidateParent = canonicalParentPath(candidate);
+	const parentIsHomeScoped = pathIsLexicallyWithin(canonicalHome, canonicalCandidateParent);
+	const targetIsHomeScoped = pathIsWithin(canonicalHome, canonicalCandidate);
 	const canonicalTrustRoots = new Set<string>();
 	if (lexicalTrustRoot !== undefined) canonicalTrustRoots.add(canonicalPath(lexicalTrustRoot));
 	const canonicalTrustRoot = findProjectTrustRoot(canonicalPath(cwd), stopPaths);
 	if (canonicalTrustRoot !== undefined) canonicalTrustRoots.add(canonicalPath(canonicalTrustRoot));
 	for (const trustRoot of canonicalTrustRoots) {
-		if (
-			(pathIsLexicallyWithin(trustRoot, canonicalParentPath(candidate)) ||
-				pathIsWithin(trustRoot, canonicalPath(candidate))) &&
-			(!candidateIsHomeScoped || pathIsLexicallyWithin(home, trustRoot) || pathIsWithin(home, trustRoot))
-		)
-			return true;
+		const trustRootIsHomeScoped = pathIsLexicallyWithin(canonicalHome, trustRoot);
+		const parentOwned =
+			pathIsLexicallyWithin(trustRoot, canonicalCandidateParent) && (!parentIsHomeScoped || trustRootIsHomeScoped);
+		const targetOwned = pathIsWithin(trustRoot, canonicalCandidate) && (!targetIsHomeScoped || trustRootIsHomeScoped);
+		if (parentOwned || targetOwned) return true;
 	}
 	return false;
 }

package/src/main.ts

@@ -31,7 +31,15 @@ import { selectSession } from "./cli/session-picker";
 import { findConfigFile } from "./config";
 import { activateModelProfile, ModelProfileCredentialError } from "./config/model-profile-activation";
 import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
-import { resolveCliModel, resolveModelRoleValue, resolveModelScope, type ScopedModel } from "./config/model-resolver";
+import {
+	parseModelString,
+	refreshMissingQualifiedModelProviders,
+	resolveCliModel,
+	resolveModelRoleValue,
+	resolveModelScope,
+	resolveStartupModelRefreshSelectors,
+	type ScopedModel,
+} from "./config/model-resolver";
 import { selectorHead } from "./config/model-selector-value";
 import { getDefault, type SettingPath, Settings, settings } from "./config/settings";
 import { resolveMachineLocalUpdateChannel, type UpdateChannel } from "./config/update-channel";
@@ -49,7 +57,7 @@ import type { PrintModeOptions } from "./modes/print-mode";
 import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
 import { applyCliRuntimeApiKeyOverride } from "./runtime-api-key";
-import { parseCliCredentialSelector } from "./runtime-credential-selector";
+import { type CliCredentialSelector, parseCliCredentialSelector } from "./runtime-credential-selector";
 import type { MCPManager } from "./runtime-mcp";
 import {
 	type CreateAgentSessionOptions,
@@ -60,6 +68,7 @@ import {
 import { processIncarnation } from "./sdk/broker/process-incarnation";
 import { newMasterAttestationEpoch, resolveSessionLocator, SessionIndex } from "./sdk/broker/session-index";
 import type { AgentSession } from "./session/agent-session";
+import { ManagedAppendIdentityMismatchError } from "./session/internal/managed-session-storage";
 import { SessionMigrationBusyError } from "./session/internal/session-open-errors";
 import {
 	type ResumeSessionIdentity,
@@ -543,7 +552,11 @@ export async function applyStartupModelProfiles(args: StartupModelProfileArgs):
 
 async function exitForStartupModelProfileError(args: StartupModelProfileArgs, error: unknown): Promise<never> {
 	const message = error instanceof Error ? error.message : String(error);
-	process.stderr.write(`${chalk.red(`Error: ${message}`)}\n`);
+	process.stderr.write(
+		error instanceof ManagedAppendIdentityMismatchError
+			? `${error.operatorMessage}\n`
+			: `${chalk.red(`Error: ${message}`)}\n`,
+	);
 	await args.session.dispose();
 	process.exit(1);
 }
@@ -1645,6 +1658,66 @@ export async function runRootCommand(
 			)
 		: undefined;
 
+	if (parsedArgs.apiKey && parsedArgs.credential) {
+		process.stderr.write(`${chalk.red("--api-key and --credential cannot be used together")}\n`);
+		process.exit(1);
+	}
+	if (parsedArgs.credential && parsedArgs.preferCredential) {
+		process.stderr.write(`${chalk.red("--credential and --prefer-credential cannot be used together")}\n`);
+		process.exit(1);
+	}
+	if (parsedArgs.apiKey && parsedArgs.preferCredential) {
+		process.stderr.write(`${chalk.red("--api-key and --prefer-credential cannot be used together")}\n`);
+		process.exit(1);
+	}
+
+	let credentialSelector: CliCredentialSelector | undefined;
+	let preferredCredentialSelector: CliCredentialSelector | undefined;
+	try {
+		credentialSelector = parsedArgs.credential ? parseCliCredentialSelector(parsedArgs.credential) : undefined;
+		preferredCredentialSelector = parsedArgs.preferCredential
+			? parseCliCredentialSelector(parsedArgs.preferCredential)
+			: undefined;
+		if (preferredCredentialSelector) {
+			const provider =
+				preferredCredentialSelector.provider ??
+				authStorage.resolveRuntimePreferredCredentialSelectorProvider(preferredCredentialSelector.selector);
+			authStorage.setRuntimePreferredCredentialSelector(provider, preferredCredentialSelector.selector);
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`${chalk.red(message)}\n`);
+		process.exit(1);
+	}
+
+	const hasRootStartupProfile = Boolean(settingsInstance.get("modelProfile.default") || parsedArgs.mpreset);
+	const startupModelSelectors = resolveStartupModelRefreshSelectors(
+		{
+			model: parsedArgs.model,
+			provider: parsedArgs.provider,
+			credential: parsedArgs.credential,
+			continue: parsedArgs.continue,
+			resume: parsedArgs.resume,
+			hasStartupProfile: hasRootStartupProfile,
+		},
+		settingsInstance,
+	);
+	const explicitStartupModelSelector = parsedArgs.model
+		? typeof startupModelSelectors === "string"
+			? startupModelSelectors
+			: parsedArgs.model
+		: undefined;
+	if (parsedArgs.apiKey && explicitStartupModelSelector) {
+		const parsedModel = parseModelString(explicitStartupModelSelector);
+		if (parsedModel) authStorage.setRuntimeApiKey(parsedModel.provider, parsedArgs.apiKey);
+	}
+	await logger.time(
+		"refreshStartupModelProviders",
+		refreshMissingQualifiedModelProviders,
+		startupModelSelectors,
+		modelRegistry,
+	);
+
 	let scopedModels: ScopedModel[] = [];
 	const modelPatterns = parsedArgs.models ?? settingsInstance.get("enabledModels");
 	const modelMatchPreferences = {
@@ -1779,7 +1852,6 @@ export async function runRootCommand(
 	if (isInteractive && sessionOptions.mcpConfigPath) {
 		sessionOptions.deferMcpConfigStartup = true;
 	}
-	const hasRootStartupProfile = Boolean(settingsInstance.get("modelProfile.default") || parsedArgs.mpreset);
 	// ACP is not carved out: `gjc acp` is broker-backed and never builds a local
 	// session here, and the broker-launched lifecycle child defers memory startup
 	// unconditionally (createLifecycleAgentSession) so readiness never waits on
@@ -1790,37 +1862,8 @@ export async function runRootCommand(
 	const acpStartupOptions = mode === "acp" ? resolveAcpStartupOptions(parsedArgs, sessionOptions) : undefined;
 
 	// Handle CLI credential selection and --api-key as runtime overrides (not persisted).
-	if (parsedArgs.apiKey && parsedArgs.credential) {
-		process.stderr.write(`${chalk.red("--api-key and --credential cannot be used together")}\n`);
-		process.exit(1);
-	}
-	if (parsedArgs.credential && parsedArgs.preferCredential) {
-		process.stderr.write(`${chalk.red("--credential and --prefer-credential cannot be used together")}\n`);
-		process.exit(1);
-	}
-	if (parsedArgs.apiKey && parsedArgs.preferCredential) {
-		process.stderr.write(`${chalk.red("--api-key and --prefer-credential cannot be used together")}\n`);
-		process.exit(1);
-	}
-
-	if (parsedArgs.credential) {
-		try {
-			sessionOptions.credentialSelector = parseCliCredentialSelector(parsedArgs.credential);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			process.stderr.write(`${chalk.red(message)}\n`);
-			process.exit(1);
-		}
-	}
-	if (parsedArgs.preferCredential) {
-		try {
-			sessionOptions.preferredCredentialSelector = parseCliCredentialSelector(parsedArgs.preferCredential);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			process.stderr.write(`${chalk.red(message)}\n`);
-			process.exit(1);
-		}
-	}
+	if (credentialSelector) sessionOptions.credentialSelector = credentialSelector;
+	if (preferredCredentialSelector) sessionOptions.preferredCredentialSelector = preferredCredentialSelector;
 	if (parsedArgs.apiKey) {
 		if (!sessionOptions.model && !sessionOptions.modelPattern) {
 			process.stderr.write(

package/src/modes/DESIGN.md

@@ -347,6 +347,60 @@ CJK/Latin todo, IRC, status, and BTW text break at semantic phrase boundaries,
 not inside a phase/action/status label, short identifier, or grapheme cluster.
 Those defects, width overflow, overlap, hidden focus/cursor, and lost anchors
 are blocking visual-QA failures.
+
+### Status Line Custom Editor simulation
+
+The Appearance tab's Status Line Custom Editor is a spatial editor, not a
+generic setting row list. It renders a simulated statusbar with left/right
+segment areas, a hidden-segment palette, visible Separator and segment-option
+controls, and Confirm/Exit actions. It must not render legacy `Segment`,
+`Move left`, or `Move right` rows.
+
+The editor owns transient state locally: focused statusbar slot, focused palette
+item, focused root control, open visible-choice panel, picked segment, floating
+ghost, empty origin slot, and overflow warning. Durable settings remain only the
+existing `statusLine.leftSegments`, `statusLine.rightSegments`,
+`statusLine.separator`, and `statusLine.segmentOptions` keys; Confirm persists
+through the existing settings guard, while Exit or root-state Escape restores
+the previous preview and closes.
+
+Focus variants are `statusbar`, `palette`, `separator-control`,
+`option-control(path)`, `choice(target, focusedValue, returnFocus)`, `confirm`,
+and `exit`. Left/Right is owned by the editor while active and never switches
+settings tabs. Enter selects/deselects, picks/drops, applies a focused choice,
+or activates Confirm/Exit according to focus. Up/Down traverses palette,
+visible root controls, actions, and choice candidates. Escape inside `choice`
+returns to the opener without mutation; Escape everywhere else cancels and
+restores. Delete only hides a focused visible statusbar segment.
+
+Separator and every segment option are visible-choice controls, never cycle-only
+rows. Descriptor data owns labels, allowed values, visible current-value
+formatting, and typed draft application. Separator choices are Powerline, Thin
+chevron, Slash, Pipe, Block, None, and ASCII. Boolean options show `true` and
+`false`; enum options show their union values; `path.maxLength` shows `16`,
+`24`, `32`, `40`, `50`, `60`, and `80`.
+
+At constrained width the simulated statusbar renders as two rows and emits an
+explicit overflow/wrap warning. ANSI-aware cell measurement remains mandatory;
+ASCII/no-color output must retain textual focus, ghost/origin, selected choice,
+and warning affordances.
+
+Deterministic evidence belongs to
+`test/fixtures/tui/status-line-custom-editor-showcase.ts`, captured by
+`scripts/capture-status-line-custom-editor-showcase.ts --out
+.gjc/qa/status-line-custom-editor-<run>` and verified by
+`scripts/verify-status-line-custom-editor-showcase.ts --root
+.gjc/qa/status-line-custom-editor-<run> --require-independent-review`. The
+canonical states are `root-statusbar`, `picked-origin-slot`,
+`palette-exact-insert`, `separator-control`, `separator-choice-focused`,
+`separator-choice-applied`, `option-boolean-choice-focused`,
+`option-enum-choice-focused`, `option-numeric-choice-focused`,
+`option-choice-applied`, `exit-restored`, `confirm-persisted`,
+`overflow-two-row-warning`, and `narrow-cjk`. Each state records
+`terminal.txt`, `terminal-ansi.txt`, `terminal.html`, and `metadata.json`, plus
+the root manifest. Missing state witnesses, ANSI/plain mismatch, invalid
+metadata, and absent independent review are blocking visual-QA failures.
+
 ### Sticky viewport deterministic visual QA
 
 `test/fixtures/tui/sticky-viewport-showcase.ts` is a fixed-clock, no-network,

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

@@ -101,6 +101,16 @@ const MAX_PROMPT_FRAME_BYTES = 256 * 1024;
  * envelope. A canonical-length UUID keeps the measurement equal to the real frame.
  */
 const PROMPT_FRAME_ID_PLACEHOLDER = "00000000-0000-4000-8000-000000000000";
+/**
+ * Readiness budget every ACP session launch requests, independent of MCP.
+ *
+ * Host cold start costs the same whether or not the client declared MCP servers,
+ * so leaving the MCP-less path on the broker's 10s default made it the only ACP
+ * launch that fails under ordinary concurrency: a second host starting beside the
+ * first measurably crosses that deadline, and the broker then reports the launch
+ * as `terminal_uncertain`, which an external client surfaces as a dead provider.
+ */
+const ACP_SESSION_READINESS_TIMEOUT_MS = ACP_MCP_LIFECYCLE_TIMEOUT_MS;
 
 type JsonObject = Record<string, unknown>;
 interface PromptWaiter {
@@ -1362,7 +1372,8 @@ export class AcpAgent implements Agent {
 				cwd: params.cwd,
 				target: { path: params.cwd },
 				...(this.#startupOptions?.modelPreset ? { modelPreset: this.#startupOptions.modelPreset } : {}),
-				...(mcpServers.length > 0 ? { mcpServers, readinessTimeoutMs: ACP_MCP_LIFECYCLE_TIMEOUT_MS } : {}),
+				readinessTimeoutMs: ACP_SESSION_READINESS_TIMEOUT_MS,
+				...(mcpServers.length > 0 ? { mcpServers } : {}),
 			},
 			randomUUID(),
 			mcpServers,
@@ -1418,7 +1429,8 @@ export class AcpAgent implements Agent {
 				sourceSessionId: params.sessionId,
 				sourceSessionPath: source,
 				target: { path: params.cwd },
-				...(mcpServers.length > 0 ? { mcpServers, readinessTimeoutMs: ACP_MCP_LIFECYCLE_TIMEOUT_MS } : {}),
+				readinessTimeoutMs: ACP_SESSION_READINESS_TIMEOUT_MS,
+				...(mcpServers.length > 0 ? { mcpServers } : {}),
 			},
 			randomUUID(),
 			mcpServers,
@@ -2268,7 +2280,8 @@ export class AcpAgent implements Agent {
 				sessionId: id,
 				sessionPath: saved,
 				target: { path: cwd },
-				...(mcpServers.length > 0 ? { mcpServers, readinessTimeoutMs: ACP_MCP_LIFECYCLE_TIMEOUT_MS } : {}),
+				readinessTimeoutMs: ACP_SESSION_READINESS_TIMEOUT_MS,
+				...(mcpServers.length > 0 ? { mcpServers } : {}),
 			},
 			randomUUID(),
 			mcpServers,

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

@@ -106,16 +106,24 @@ export class AssistantMessageComponent extends Container {
 	#toolImagesRevision = 0;
 	#convertedToolImagesRevision = 0;
 	#disposed = false;
+	// Cached Markdown children can outlive their attachment to this assistant.
+	// Session/live-parent validity belongs to the owner, not the paint lifetime.
+	readonly #requestRepaint?: () => void;
 	constructor(
 		message?: AssistantMessage,
 		private hideThinkingBlock = false,
-		private readonly onImageUpdate?: () => void,
+		onImageUpdate?: () => void,
 		viewportAnchorId?: string,
 		private readonly onVisibleMutation?: () => void,
 		private readonly hintSession?: ProviderSafetyStopHintSession,
 	) {
 		super();
 		this.#viewportAnchorId = viewportAnchorId;
+		if (onImageUpdate) {
+			this.#requestRepaint = () => {
+				if (!this.#disposed) onImageUpdate();
+			};
+		}
 
 		this.#contentContainer = new Container();
 		this.addChild(this.#contentContainer);
@@ -172,6 +180,7 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	#notifyVisibleMutation(): void {
+		if (this.#disposed) return;
 		const after = this.#visibleContentSignature();
 		if (after === this.#visibleSignature) return;
 		this.#visibleSignature = after;
@@ -186,6 +195,7 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	override invalidate(): void {
+		if (this.#disposed) return;
 		super.invalidate();
 		if (this.#lastMessage) {
 			this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
@@ -193,13 +203,14 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	setHideThinkingBlock(hide: boolean): void {
+		if (this.#disposed) return;
 		if (this.hideThinkingBlock === hide) return;
 		this.hideThinkingBlock = hide;
 		this.#notifyVisibleMutation();
 	}
 
 	setToolResultImages(toolCallId: string, images: ImageContent[]): void {
-		if (!toolCallId) return;
+		if (this.#disposed || !toolCallId) return;
 		const validImages = images.filter(img => img.type === "image" && img.data && img.mimeType);
 		const previousImages = this.#toolImagesByCallId.get(toolCallId);
 		if (
@@ -268,7 +279,7 @@ export class AssistantMessageComponent extends Container {
 					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?.();
+					this.#requestRepaint?.();
 				})
 				.catch(() => {
 					if (
@@ -283,6 +294,7 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	setUsageInfo(usage: Usage): void {
+		if (this.#disposed) return;
 		this.#usageInfo = usage;
 		if (this.#lastMessage) {
 			this.updateContent(this.#lastMessage, { streaming: this.#lastStreaming });
@@ -311,7 +323,7 @@ export class AssistantMessageComponent extends Container {
 		const cached = this.#contentBlocksCache.get(content);
 		if (cached?.source === content.text) {
 			if (cached.component instanceof Markdown) {
-				cached.component.setOnStaleThrottle(this.onImageUpdate);
+				cached.component.setOnStaleThrottle(this.#requestRepaint);
 				cached.component.setStreaming(streaming);
 			}
 			return cached.component;
@@ -322,14 +334,14 @@ export class AssistantMessageComponent extends Container {
 		// instead of constructing a new one each chunk; combined with the markdown
 		// per-code-block highlight cache, appends no longer re-highlight the whole prefix.
 		if (!deepInterview && cached && cached.component instanceof Markdown) {
-			cached.component.setOnStaleThrottle(this.onImageUpdate);
+			cached.component.setOnStaleThrottle(this.#requestRepaint);
 			cached.component.setText(trimmed, { streaming });
 			cached.source = content.text;
 			return cached.component;
 		}
 		const component = deepInterview ?? new Markdown(trimmed, 1, 0, getMarkdownTheme());
 		if (component instanceof Markdown) {
-			component.setOnStaleThrottle(this.onImageUpdate);
+			component.setOnStaleThrottle(this.#requestRepaint);
 			component.setStreaming(streaming);
 		}
 		this.#contentBlocksCache.set(content, { source: content.text, component });
@@ -341,14 +353,14 @@ export class AssistantMessageComponent extends Container {
 		const cached = this.#contentBlocksCache.get(content);
 		if (cached?.source === content.thinking) {
 			if (cached.component instanceof Markdown) {
-				cached.component.setOnStaleThrottle(this.onImageUpdate);
+				cached.component.setOnStaleThrottle(this.#requestRepaint);
 				cached.component.setStreaming(streaming);
 			}
 			return cached.component as Markdown;
 		}
 		const trimmed = elideRunawayThinkingRepetition(content.thinking.trim());
 		if (cached?.component instanceof Markdown) {
-			cached.component.setOnStaleThrottle(this.onImageUpdate);
+			cached.component.setOnStaleThrottle(this.#requestRepaint);
 			cached.component.setText(trimmed, { streaming });
 			cached.source = content.thinking;
 			return cached.component;
@@ -357,7 +369,7 @@ export class AssistantMessageComponent extends Container {
 			color: (text: string) => theme.fg("thinkingText", text),
 			italic: true,
 		});
-		component.setOnStaleThrottle(this.onImageUpdate);
+		component.setOnStaleThrottle(this.#requestRepaint);
 		component.setStreaming(streaming);
 		this.#contentBlocksCache.set(content, { source: content.thinking, component });
 		this.#reusableChildren.add(component);
@@ -437,6 +449,7 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	updateContent(message: AssistantMessage, options?: AssistantMessageUpdateOptions): void {
+		if (this.#disposed) return;
 		this.#lastMessage = message;
 		this.#lastStreaming = options?.streaming ?? false;
 

package/src/modes/components/bash-execution.ts

@@ -43,6 +43,7 @@ export class BashExecutionComponent extends Container {
 	#outputLines: string[] = [];
 	#status: ExecutionStatus = "running";
 	#exitCode: number | undefined = undefined;
+	#signal: string | undefined = undefined;
 	#loader: Loader;
 	#truncation?: TruncationMeta;
 	#expanded = false;
@@ -127,9 +128,10 @@ export class BashExecutionComponent extends Container {
 	setComplete(
 		exitCode: number | undefined,
 		cancelled: boolean,
-		options?: { output?: string; truncation?: TruncationMeta },
+		options?: { output?: string; signal?: string; truncation?: TruncationMeta },
 	): void {
 		this.#exitCode = exitCode;
+		this.#signal = options?.signal;
 		this.#status = resolveExecutionStatus(exitCode, cancelled);
 		this.#truncation = options?.truncation;
 		if (options?.output !== undefined) {
@@ -215,6 +217,7 @@ export class BashExecutionComponent extends Container {
 			const footer = buildStatusFooter({
 				status: this.#status,
 				exitCode: this.#exitCode,
+				signal: this.#signal,
 				truncation: this.#truncation,
 				hiddenLineCount,
 				suppressHiddenCount: hasSixelOutput && !fallbackActive,

package/src/modes/components/execution-shared.ts

@@ -68,6 +68,7 @@ export function createCollapsedPreview(previewText: string, previewLines: number
 export function buildStatusFooter(opts: {
 	status: ExecutionStatus;
 	exitCode: number | undefined;
+	signal?: string;
 	truncation: TruncationMeta | undefined;
 	hiddenLineCount: number;
 	/** Suppress the "… N more lines" hint (used when sixel passthrough renders the full output). */
@@ -81,7 +82,9 @@ export function buildStatusFooter(opts: {
 	if (opts.status === "cancelled") {
 		parts.push(theme.fg("warning", "(cancelled)"));
 	} else if (opts.status === "error") {
-		parts.push(theme.fg("error", `(exit ${opts.exitCode})`));
+		parts.push(
+			theme.fg("error", opts.signal ? `(${opts.signal}, exit ${opts.exitCode})` : `(exit ${opts.exitCode})`),
+		);
 	}
 	if (opts.truncation) {
 		parts.push(theme.fg("warning", formatTruncationMetaNotice(opts.truncation)));