@sayknow-cli/coding-agent 0.3.7 → 0.3.9

package/src/modes/components/welcome.ts

@@ -22,6 +22,25 @@ export interface WelcomeComponentOptions {
 	collapseChangelog?: boolean;
 }
 
+const WELCOME_STATIC_RIGHT_ROWS_EXCLUDING_DYNAMIC_SECTIONS = 15;
+const DEFAULT_WHATS_NEW_ROWS = 3;
+const MAX_WHATS_NEW_ROWS = 12;
+const NEWLINE_FLOW_KEY =
+	process.platform === "win32" ? { key: "alt+enter", label: "newline" } : { key: "ctrl+j", label: "newline" };
+
+const FLOW_KEY_ITEMS: ReadonlyArray<{ key: string; label: string }> = [
+	{ key: "/", label: "commands" },
+	{ key: "#", label: "actions" },
+	{ key: "!", label: "shell" },
+	{ key: "$", label: "python" },
+	{ key: "?", label: "keymap" },
+	{ key: "ctrl+l", label: "model" },
+	{ key: "shift+tab", label: "reasoning" },
+	{ key: "tab", label: "complete" },
+	NEWLINE_FLOW_KEY,
+	{ key: "ctrl+c", label: "clear" },
+];
+
 /**
  * Sayknow-CLI launch surface: a blue-gradient SAYKNOW wordmark, compact
  * command affordances, and project signals — a distinct identity, not a
@@ -99,7 +118,6 @@ export class WelcomeComponent implements Component {
 		}
 		const targetContentRows = targetRows === undefined ? undefined : Math.max(0, targetRows - 2);
 		const dualContentWidth = boxWidth - 3; // 3 = │ + │ + │
-		const preferredLeftCol = 40;
 		const minLeftCol = 20; // wordmark plus Sayknow identity labels
 		const minRightCol = 24;
 		const modelPill = this.#pill(theme.icon.model || "model", this.modelName, "statusLineModel");
@@ -113,10 +131,12 @@ export class WelcomeComponent implements Component {
 			visibleWidth(modelPill),
 			visibleWidth(providerPill),
 		);
-		const desiredLeftCol = Math.min(preferredLeftCol, Math.max(minLeftCol, Math.floor(dualContentWidth * 0.42)));
+		const evenLeftCol = Math.floor(dualContentWidth / 2);
+		const maxLeftColWithRightMinimum = Math.max(1, dualContentWidth - minRightCol);
+		const desiredLeftCol = Math.max(leftMinContentWidth, evenLeftCol);
 		const dualLeftCol =
 			dualContentWidth >= minRightCol + 1
-				? Math.min(desiredLeftCol, dualContentWidth - minRightCol)
+				? Math.min(desiredLeftCol, maxLeftColWithRightMinimum)
 				: Math.max(1, dualContentWidth - 1);
 		const dualRightCol = Math.max(1, dualContentWidth - dualLeftCol);
 		const showRightColumn = dualLeftCol >= leftMinContentWidth && dualRightCol >= minRightCol;
@@ -152,26 +172,6 @@ export class WelcomeComponent implements Component {
 
 		const rightColumnWidth = showRightColumn ? rightCol : leftCol;
 		const separator = buildSeparator(rightColumnWidth);
-		const changelogBudget = Math.max(1, Math.min(6, Math.floor((targetContentRows ?? 18) * 0.3)));
-
-		const sessionLines: string[] = [];
-		if (this.recentSessions.length === 0) {
-			sessionLines.push(` ${theme.fg("dim", t("welcome.noSessions"))}`);
-		} else {
-			const bulletPrefix = ` ${theme.md.bullet} `;
-			const prefixWidth = visibleWidth(bulletPrefix);
-			for (const session of this.recentSessions.slice(0, 3)) {
-				const timeSuffixRaw = ` (${session.timeAgo})`;
-				const timeWidth = visibleWidth(timeSuffixRaw);
-				const nameBudget = Math.max(1, rightColumnWidth - prefixWidth - timeWidth);
-				const nameVis = visibleWidth(session.name);
-				const name = nameVis > nameBudget ? truncateToWidth(session.name, nameBudget) : session.name;
-				sessionLines.push(
-					`${theme.fg("dim", bulletPrefix)}${theme.fg("muted", name)}${theme.fg("dim", timeSuffixRaw)}`,
-				);
-			}
-		}
-
 		const lspLines: string[] = [];
 		if (this.lspServers.length === 0) {
 			lspLines.push(` ${theme.fg("dim", t("welcome.noLsp"))}`);
@@ -188,6 +188,24 @@ export class WelcomeComponent implements Component {
 			}
 		}
 
+		const flowPreferredRows = this.#flowKeyRows(rightColumnWidth).length;
+		const changelogRowLimit = this.#whatsNewRowLimit(targetContentRows, lspLines.length, flowPreferredRows);
+		const changelogLines = this.#whatsNewLines(rightColumnWidth, changelogRowLimit);
+		const flowRowLimit = this.#flowKeyRowLimit(
+			targetContentRows,
+			changelogLines.length,
+			lspLines.length,
+			rightColumnWidth,
+		);
+		const flowLines = this.#flowKeyLines(rightColumnWidth, flowRowLimit);
+		const sessionLimit = this.#sessionTrailLimit(
+			targetContentRows,
+			changelogLines.length,
+			lspLines.length,
+			flowLines.length,
+		);
+		const sessionLines = this.#sessionTrailLines(rightColumnWidth, sessionLimit);
+
 		// Workflow affordances: pad the command so descriptions align.
 		const wf = (cmd: string, desc: string): string => {
 			const pad = " ".repeat(Math.max(1, 17 - visibleWidth(cmd)));
@@ -197,7 +215,7 @@ export class WelcomeComponent implements Component {
 		const rightLines = [
 			"",
 			` ${theme.bold(theme.fg("accent", "What's New"))}`,
-			...this.#whatsNewLines(rightColumnWidth, changelogBudget),
+			...changelogLines,
 			separator,
 			` ${theme.bold(theme.fg("accent", t("welcome.workflows")))}`,
 			wf("/deep-interview", t("welcome.wf.deepInterview")),
@@ -206,19 +224,7 @@ export class WelcomeComponent implements Component {
 			wf("/team", t("welcome.wf.team")),
 			separator,
 			` ${theme.bold(theme.fg("accent", t("welcome.flowKeys")))}`,
-			` ${theme.fg("dim", "/")}${theme.fg("muted", ` ${t("welcome.commands")}`)} ${theme.fg("dim", "·")} ${theme.fg(
-				"dim",
-				"#",
-			)}${theme.fg("muted", ` ${t("welcome.actions")}`)}`,
-			` ${theme.fg("dim", "!")}${theme.fg("muted", ` ${t("welcome.shell")}`)} ${theme.fg("dim", "·")} ${theme.fg("dim", "$")}${theme.fg(
-				"muted",
-				` ${t("welcome.python")}`,
-			)}`,
-			` ${theme.fg("dim", "?")}${theme.fg("muted", ` ${t("welcome.keymap")}`)} ${theme.fg("dim", "·")} ${theme.fg(
-				"dim",
-				"ctrl+l",
-			)}${theme.fg("muted", ` ${t("welcome.model")}`)}`,
-			` ${theme.fg("dim", "shift+tab")}${theme.fg("muted", ` ${t("welcome.reasoning")}`)}`,
+			...flowLines,
 			separator,
 			` ${theme.bold(theme.fg("accent", t("welcome.projectPulse")))}`,
 			...lspLines,
@@ -337,7 +343,139 @@ export class WelcomeComponent implements Component {
 		return [...Array.from({ length: topPad }, () => ""), ...clipped, ...Array.from({ length: bottomPad }, () => "")];
 	}
 
-	#whatsNewLines(width: number, maxItems: number): string[] {
+	#flowKeyItemText(item: { key: string; label: string }): string {
+		return `${theme.fg("dim", item.key)}${theme.fg("muted", ` ${this.#flowKeyLabel(item.label)}`)}`;
+	}
+
+	#flowKeyLabel(label: string): string {
+		switch (label) {
+			case "commands":
+				return t("welcome.commands");
+			case "actions":
+				return t("welcome.actions");
+			case "shell":
+				return t("welcome.shell");
+			case "python":
+				return t("welcome.python");
+			case "keymap":
+				return t("welcome.keymap");
+			case "model":
+				return t("welcome.model");
+			case "reasoning":
+				return t("welcome.reasoning");
+			default:
+				return label;
+		}
+	}
+
+	#flowKeyRows(width: number): string[] {
+		const contentWidth = Math.max(1, width - 1);
+		const separator = ` ${theme.fg("dim", "·")} `;
+		const rows: string[] = [];
+		let current = "";
+		for (const item of FLOW_KEY_ITEMS) {
+			const segment = this.#flowKeyItemText(item);
+			const next = current ? `${current}${separator}${segment}` : segment;
+			if (current && visibleWidth(next) > contentWidth) {
+				rows.push(` ${current}`);
+				current = segment;
+			} else {
+				current = next;
+			}
+		}
+		if (current) rows.push(` ${current}`);
+		return rows.length > 0 ? rows : [` ${theme.fg("dim", "No flow keys")}`];
+	}
+
+	#flowKeyLines(width: number, maxRows: number): string[] {
+		const rows = this.#flowKeyRows(width);
+		const rowLimit = Math.max(1, Math.floor(maxRows));
+		if (rows.length <= rowLimit) return rows;
+		if (rowLimit === 1) {
+			const firstItem = FLOW_KEY_ITEMS[0];
+			const firstSegment = firstItem ? this.#flowKeyItemText(firstItem) : theme.fg("dim", "keys");
+			return [this.#fitToWidth(` ${firstSegment} ${theme.fg("dim", "· … ")}${theme.bold("/help")}`, width)];
+		}
+		return [...rows.slice(0, rowLimit - 1), ` ${theme.fg("dim", `… ${theme.bold("/help")} for more`)}`];
+	}
+
+	#flowKeyRowLimit(
+		targetContentRows: number | undefined,
+		changelogLineCount: number,
+		lspLineCount: number,
+		rightColumnWidth: number,
+	): number {
+		const preferredRows = this.#flowKeyRows(rightColumnWidth).length;
+		if (targetContentRows === undefined) return preferredRows;
+
+		const sessionBaselineRows = this.recentSessions.length === 0 ? 1 : Math.min(3, this.recentSessions.length);
+		const availableRows =
+			targetContentRows -
+			WELCOME_STATIC_RIGHT_ROWS_EXCLUDING_DYNAMIC_SECTIONS -
+			changelogLineCount -
+			lspLineCount -
+			sessionBaselineRows;
+		return Math.max(1, Math.min(preferredRows, availableRows));
+	}
+
+	#whatsNewRowLimit(targetContentRows: number | undefined, lspLineCount: number, flowLineCount: number): number {
+		if (targetContentRows === undefined) return 5;
+
+		const sessionBaselineRows = this.recentSessions.length === 0 ? 1 : Math.min(3, this.recentSessions.length);
+		const dynamicRows = Math.max(
+			1,
+			targetContentRows - WELCOME_STATIC_RIGHT_ROWS_EXCLUDING_DYNAMIC_SECTIONS - flowLineCount - lspLineCount,
+		);
+		const rowsAfterBaselineSessions = Math.max(1, dynamicRows - sessionBaselineRows);
+		const spareRows = Math.max(0, rowsAfterBaselineSessions - DEFAULT_WHATS_NEW_ROWS);
+		return Math.max(
+			1,
+			Math.min(MAX_WHATS_NEW_ROWS, rowsAfterBaselineSessions, DEFAULT_WHATS_NEW_ROWS + Math.floor(spareRows / 2)),
+		);
+	}
+
+	#sessionTrailLimit(
+		targetContentRows: number | undefined,
+		changelogLineCount: number,
+		lspLineCount: number,
+		flowLineCount: number,
+	): number {
+		if (this.recentSessions.length === 0) return 0;
+
+		const defaultLimit = Math.min(3, this.recentSessions.length);
+		if (targetContentRows === undefined) return defaultLimit;
+
+		const rowsWithDefaultTrail =
+			WELCOME_STATIC_RIGHT_ROWS_EXCLUDING_DYNAMIC_SECTIONS +
+			changelogLineCount +
+			flowLineCount +
+			lspLineCount +
+			defaultLimit;
+		const extraRows = Math.max(0, targetContentRows - rowsWithDefaultTrail);
+		return Math.min(this.recentSessions.length, defaultLimit + extraRows);
+	}
+
+	#sessionTrailLines(rightColumnWidth: number, limit: number): string[] {
+		if (this.recentSessions.length === 0) {
+			return [` ${theme.fg("dim", t("welcome.noSessions"))}`];
+		}
+
+		const bulletPrefix = ` ${theme.md.bullet} `;
+		const prefixWidth = visibleWidth(bulletPrefix);
+		const lines: string[] = [];
+		for (const session of this.recentSessions.slice(0, limit)) {
+			const timeSuffixRaw = ` (${session.timeAgo})`;
+			const timeWidth = visibleWidth(timeSuffixRaw);
+			const nameBudget = Math.max(1, rightColumnWidth - prefixWidth - timeWidth);
+			const nameVis = visibleWidth(session.name);
+			const name = nameVis > nameBudget ? truncateToWidth(session.name, nameBudget) : session.name;
+			lines.push(`${theme.fg("dim", bulletPrefix)}${theme.fg("muted", name)}${theme.fg("dim", timeSuffixRaw)}`);
+		}
+		return lines;
+	}
+
+	#whatsNewLines(width: number, maxRows: number): string[] {
+		const rowLimit = Math.max(1, Math.floor(maxRows));
 		const changelog = this.options.changelogMarkdown?.trim();
 		if (!changelog) {
 			return [` ${theme.fg("dim", "Ready for your next prompt")}`];
@@ -348,25 +486,25 @@ export class WelcomeComponent implements Component {
 			return [
 				` ${theme.fg("muted", `Updated to v${version}`)}`,
 				` ${theme.fg("dim", `Use ${theme.bold("/changelog")} for details`)}`,
-			];
+			].slice(0, rowLimit);
 		}
 
-		const itemLimit = Math.max(1, Math.floor(maxItems));
 		const items = this.#changelogItems(changelog);
 		if (items.length === 0) {
 			return [
 				` ${theme.fg("muted", `Updated to v${version}`)}`,
 				` ${theme.fg("dim", `Use ${theme.bold("/changelog")} for details`)}`,
-			];
+			].slice(0, rowLimit);
 		}
 
 		const prefix = ` ${theme.md.bullet} `;
 		const textWidth = Math.max(1, width - visibleWidth(prefix));
-		const visibleItems = items.slice(0, itemLimit).map(item => {
+		const visibleItemCount = items.length > rowLimit ? Math.max(1, rowLimit - 1) : rowLimit;
+		const visibleItems = items.slice(0, visibleItemCount).map(item => {
 			const text = visibleWidth(item) > textWidth ? truncateToWidth(item, textWidth) : item;
 			return `${theme.fg("dim", prefix)}${theme.fg("muted", text)}`;
 		});
-		if (items.length > visibleItems.length) {
+		if (items.length > visibleItems.length && visibleItems.length < rowLimit) {
 			visibleItems.push(` ${theme.fg("dim", `… ${theme.bold("/changelog")} for full notes`)}`);
 		}
 		return visibleItems;
@@ -469,7 +607,6 @@ interface ShineConfig {
 	/** Center of the shine band along the diagonal, in [0, 1]. */
 	pos: number;
 }
-
 /**
  * Apply a multi-stop diagonal gradient (bottom-left → top-right) plus an
  * optional sliding shine band across multi-line art. `phase` (0..1) shifts the

package/src/modes/controllers/command-controller.ts

@@ -13,6 +13,7 @@ import {
 import { Loader, Markdown, padding, Spacer, Text, visibleWidth } from "@sayknow-cli/tui";
 import { formatDuration, Snowflake, setProjectDir } from "@sayknow-cli/utils";
 import { $ } from "bun";
+import { resolveAppendOnlyMode } from "../../append-only-mode";
 import { jobElapsedMs } from "../../async";
 import { reset as resetCapabilities } from "../../capability";
 import { clearClaudePluginRootsCache } from "../../discovery/helpers";
@@ -400,7 +401,7 @@ export class CommandController {
 		{
 			const setting = this.ctx.settings.get("provider.appendOnlyContext") ?? "auto";
 			const provider = this.ctx.session.model?.provider;
-			const mode = setting === "on" ? true : setting === "off" ? false : provider === "deepseek";
+			const mode = resolveAppendOnlyMode(setting, provider ?? "");
 			const activeLabel = mode ? theme.fg("success", "active") : theme.fg("dim", "inactive");
 			const settingLabel = setting === "auto" ? `${setting} (${provider ?? "?"})` : setting;
 			info += `${theme.fg("dim", "Append-Only:")} ${activeLabel} (setting: ${settingLabel})\n`;
@@ -540,7 +541,7 @@ export class CommandController {
 		const title = showFull ? "Full Changelog" : "Recent Changes";
 		const hint = showFull
 			? ""
-			: `\n\n${theme.fg("dim", "Use")} ${theme.bold("/changelog full")} ${theme.fg("dim", "to view the complete changelog.")}`;
+			: `\n\n${theme.fg("dim", "Use")} ${theme.bold("/changelog --full")} ${theme.fg("dim", "to view the complete changelog.")}`;
 
 		this.ctx.chatContainer.addChild(new Spacer(1));
 		this.ctx.chatContainer.addChild(new DynamicBorder());
@@ -926,8 +927,7 @@ export class CommandController {
 		this.ctx.streamingMessage = undefined;
 		this.ctx.pendingTools.clear();
 
-		this.ctx.chatContainer.addChild(new Spacer(1));
-		this.ctx.chatContainer.addChild(new Text(`${theme.fg("accent", `${theme.status.success} ${label}`)}`, 1, 1));
+		this.ctx.chatContainer.addChild(new Text(`${theme.fg("accent", `${theme.status.success} ${label}`)}`, 1, 0));
 		await this.ctx.reloadTodos();
 		this.ctx.ui.requestRender();
 	}
@@ -936,6 +936,42 @@ export class CommandController {
 		await this.#runNewSessionFlow();
 	}
 
+	async handleContextClearCommand(): Promise<void> {
+		if (this.ctx.loadingAnimation) {
+			this.ctx.loadingAnimation.stop();
+			this.ctx.loadingAnimation = undefined;
+		}
+		this.ctx.statusContainer.clear();
+
+		if (this.ctx.session.isCompacting) {
+			this.ctx.session.abortCompaction();
+			while (this.ctx.session.isCompacting) {
+				await Bun.sleep(10);
+			}
+		}
+		if (!(await this.ctx.session.clearContext())) return;
+		setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
+
+		this.ctx.statusLine.invalidate();
+		this.ctx.statusLine.setSessionStartTime(Date.now());
+		this.ctx.updateEditorTopBorder();
+		this.ctx.updateEditorBorderColor();
+		this.ctx.ui.requestRender();
+
+		this.ctx.chatContainer.clear();
+		this.ctx.pendingMessagesContainer.clear();
+		this.ctx.compactionQueuedMessages = [];
+		this.ctx.streamingComponent = undefined;
+		this.ctx.streamingMessage = undefined;
+		this.ctx.pendingTools.clear();
+
+		this.ctx.chatContainer.addChild(
+			new Text(`${theme.fg("accent", `${theme.status.success} Context cleared`)}`, 1, 0),
+		);
+		await this.ctx.reloadTodos();
+		this.ctx.ui.requestRender();
+	}
+
 	async handleDropCommand(): Promise<void> {
 		if (!this.ctx.sessionManager.getSessionFile()) {
 			this.ctx.showError("Nothing to drop (in-memory session)");

package/src/modes/controllers/event-controller.ts

@@ -16,6 +16,7 @@ import { ToolExecutionComponent } from "../../modes/components/tool-execution";
 import { TtsrNotificationComponent } from "../../modes/components/ttsr-notification";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext, TodoPhase } from "../../modes/types";
+import { completionNotifyDisabledByEnv } from "../../notifications/config";
 import { summaryFromMessage } from "../../notifications/helpers";
 import type { PlanApprovalDetails } from "../../plan-mode/approved-plan";
 import type { AgentSessionEvent } from "../../session/agent-session";
@@ -23,11 +24,22 @@ import { isSilentAbort, readPendingDisplayTag } from "../../session/messages";
 import type { ResolveToolDetails } from "../../tools/resolve";
 import { interruptHint } from "../shared";
 import { buildAbortDisplayMessage } from "../utils/abort-message";
+import { consumeInjectedOptimisticSignature } from "../utils/injected-user-submission";
 import { ringTerminalBell } from "../utils/terminal-bell";
+import { argsWithPartialJson } from "../utils/ui-helpers";
 
 type AgentSessionEventKind = AgentSessionEvent["type"];
 
 const IRC_MESSAGE_VISIBLE_TTL_MS = 10_000;
+
+/** Test-only performance counters for advisory baseline tests. */
+export const __eventControllerPerfCounters = {
+	messageUpdateContentVisits: 0,
+	reset(): void {
+		this.messageUpdateContentVisits = 0;
+	},
+};
+
 const COMPLETION_NOTIFY_COMMAND_TIMEOUT_MS = 10_000;
 
 interface CompletionNotifyPayload {
@@ -100,6 +112,8 @@ export class EventController {
 	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
 	#idleCompactionTimer?: NodeJS.Timeout;
 	#ircExpiryTimers = new Map<string, NodeJS.Timeout>();
+	#toolIntentCache = new Map<string, { args: unknown; intent: string | undefined }>();
+	#thinkingContentIndices = new Set<number>();
 	#handlers: AgentSessionEventHandlers;
 
 	constructor(private ctx: InteractiveModeContext) {
@@ -279,12 +293,17 @@ export class EventController {
 			const signature = `${textContent}\u0000${imageCount}`;
 
 			this.#resetReadGroup();
-			const wasOptimistic = this.ctx.optimisticUserMessageSignature === signature;
+			const wasSingleOptimistic = this.ctx.optimisticUserMessageSignature === signature;
+			const wasInjectedOptimistic = !wasSingleOptimistic && consumeInjectedOptimisticSignature(this.ctx, signature);
+			const wasOptimistic = wasSingleOptimistic || wasInjectedOptimistic;
 			const wasLocallySubmitted = this.ctx.locallySubmittedUserSignatures.delete(signature) || wasOptimistic;
 			if (!wasOptimistic) {
 				this.ctx.addMessageToChat(event.message);
 			}
-			if (wasOptimistic) {
+			// Only clear the single local slot when IT matched; an injected match is
+			// consumed from the counting Map above and must not clobber a coexisting
+			// pending local optimistic signature.
+			if (wasSingleOptimistic) {
 				this.ctx.optimisticUserMessageSignature = undefined;
 			}
 
@@ -307,12 +326,14 @@ export class EventController {
 		} else if (event.message.role === "assistant") {
 			this.#lastThinkingCount = 0;
 			this.#resetReadGroup();
+			this.#toolIntentCache.clear();
+			this.#thinkingContentIndices.clear();
 			this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock, () =>
 				this.ctx.ui.requestRender(),
 			);
 			this.ctx.streamingMessage = event.message;
 			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
-			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage, { streaming: true });
 			this.ctx.ui.requestRender();
 		}
 	}
@@ -375,46 +396,53 @@ export class EventController {
 	async #handleMessageUpdate(event: Extract<AgentSessionEvent, { type: "message_update" }>): Promise<void> {
 		if (this.ctx.streamingComponent && event.message.role === "assistant") {
 			this.ctx.streamingMessage = event.message;
-			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
-
-			const thinkingCount = this.ctx.streamingMessage.content.filter(
-				content => content.type === "thinking" && content.thinking.trim(),
-			).length;
-			if (thinkingCount > this.#lastThinkingCount) {
-				this.#resetReadGroup();
-				this.#lastThinkingCount = thinkingCount;
+			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage, { streaming: true });
+			const contentIndex = event.assistantMessageEvent?.contentIndex;
+			const changedContent =
+				typeof contentIndex === "number" && contentIndex >= 0
+					? this.ctx.streamingMessage.content[contentIndex]
+					: undefined;
+			const contentsToProcess = changedContent ? [changedContent] : this.ctx.streamingMessage.content;
+
+			if (changedContent?.type === "thinking" && changedContent.thinking.trim()) {
+				if (typeof contentIndex === "number") this.#thinkingContentIndices.add(contentIndex);
+				const thinkingCount = this.#thinkingContentIndices.size;
+				if (thinkingCount > this.#lastThinkingCount) {
+					this.#resetReadGroup();
+					this.#lastThinkingCount = thinkingCount;
+				}
+			} else if (!changedContent) {
+				const thinkingCount = this.ctx.streamingMessage.content.filter(
+					content => content.type === "thinking" && content.thinking.trim(),
+				).length;
+				if (thinkingCount > this.#lastThinkingCount) {
+					this.#resetReadGroup();
+					this.#lastThinkingCount = thinkingCount;
+				}
 			}
 
-			for (const content of this.ctx.streamingMessage.content) {
+			for (const content of contentsToProcess) {
+				__eventControllerPerfCounters.messageUpdateContentVisits += 1;
 				if (content.type !== "toolCall") continue;
 				if (content.name === "read") {
-					if (!readArgsHaveTarget(content.arguments)) {
-						// Args still streaming — defer until path is parseable so we can route to the
-						// read group (regular files) vs ToolExecutionComponent (internal URLs).
-						// Creating either component now would lock the read into the wrong shape.
-						continue;
-					}
+					if (!readArgsHaveTarget(content.arguments)) continue;
 					if (!readArgsTargetInternalUrl(content.arguments)) {
 						this.#trackReadToolCall(content.id, content.arguments);
 						const component = this.ctx.pendingTools.get(content.id);
-						if (component) {
-							component.updateArgs(content.arguments, content.id);
-						} else {
+						if (component) component.updateArgs(content.arguments, content.id);
+						else {
 							const group = this.#getReadGroup();
 							group.updateArgs(content.arguments, content.id);
 							this.ctx.pendingTools.set(content.id, group);
 						}
 						continue;
 					}
-					// Internal URL read falls through to ToolExecutionComponent below.
 				}
 
-				// Preserve the raw partial JSON for renderers that need to surface fields before the JSON object closes.
-				// Bash uses this to show inline env assignments during streaming instead of popping them in at completion.
-				const renderArgs =
-					"partialJson" in content
-						? { ...content.arguments, __partialJson: content.partialJson }
-						: content.arguments;
+				const renderArgs = argsWithPartialJson(
+					content.arguments,
+					"partialJson" in content ? content.partialJson : undefined,
+				);
 				if (!this.ctx.pendingTools.has(content.id)) {
 					this.#resetReadGroup();
 					this.ctx.chatContainer.addChild(new Text("", 0, 0));
@@ -437,32 +465,30 @@ export class EventController {
 					this.ctx.chatContainer.addChild(component);
 					this.ctx.pendingTools.set(content.id, component);
 				} else {
-					const component = this.ctx.pendingTools.get(content.id);
-					if (component) {
-						component.updateArgs(renderArgs, content.id);
-					}
+					this.ctx.pendingTools.get(content.id)?.updateArgs(renderArgs, content.id);
 				}
-			}
 
-			// Update working message with intent from streamed tool arguments
-			for (const content of this.ctx.streamingMessage.content) {
-				if (content.type !== "toolCall") continue;
 				const args = content.arguments;
 				if (!args || typeof args !== "object") continue;
+				let intent: string | undefined;
 				if (INTENT_FIELD in args) {
-					this.#updateWorkingMessageFromIntent(args[INTENT_FIELD]);
-					continue;
-				}
-				const tool = this.ctx.session.getToolByName(content.name);
-				if (typeof tool?.intent !== "function") continue;
-				try {
-					const derived = tool.intent(args as never)?.trim();
-					if (derived) {
-						this.#updateWorkingMessageFromIntent(derived);
+					intent = String(args[INTENT_FIELD]);
+				} else {
+					const cached = this.#toolIntentCache.get(content.id);
+					if (cached?.args === args) intent = cached.intent;
+					else {
+						const tool = this.ctx.session.getToolByName(content.name);
+						if (typeof tool?.intent === "function") {
+							try {
+								intent = tool.intent(args as never)?.trim();
+							} catch {
+								// intent function must never break the UI
+							}
+						}
+						this.#toolIntentCache.set(content.id, { args, intent });
 					}
-				} catch {
-					// intent function must never break the UI
 				}
+				if (intent) this.#updateWorkingMessageFromIntent(intent);
 			}
 
 			this.ctx.ui.requestRender();
@@ -495,9 +521,9 @@ export class EventController {
 				// display only — does NOT mutate the persisted message's stopReason
 				// (the marker on errorMessage drives replay-side suppression).
 				const msgWithoutAbort = { ...this.ctx.streamingMessage, stopReason: "stop" as const };
-				this.ctx.streamingComponent.updateContent(msgWithoutAbort);
+				this.ctx.streamingComponent.updateContent(msgWithoutAbort, { streaming: false });
 			} else {
-				this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+				this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage, { streaming: false });
 			}
 
 			if (this.ctx.streamingMessage.stopReason !== "aborted" && this.ctx.streamingMessage.stopReason !== "error") {
@@ -941,6 +967,8 @@ export class EventController {
 	}
 
 	sendCompletionNotification(): void {
+		// Per-run hard opt-out (env, config-untouched, child-inheritable): SKC_NOTIFY=off.
+		if (completionNotifyDisabledByEnv(process.env)) return;
 		const isBackgrounded = this.ctx.isBackgrounded !== false;
 		const notify = settings.get("completion.notify");
 		if (notify === "off") return;