jeopi-cli 16.4.2 → 16.4.4

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

@@ -3,12 +3,14 @@ import * as path from "node:path";
 import type { AssistantMessage } from "jeopi-ai";
 import { prompt, Snowflake } from "jeopi-utils";
 import backgroundTanDispatchPrompt from "../../prompts/system/background-tan-dispatch.md" with { type: "text" };
+import tanContextSwitchPrompt from "../../prompts/system/tan-context-switch.md" with { type: "text" };
 import { AgentRegistry, MAIN_AGENT_ID } from "../../registry/agent-registry";
 import * as sdk from "../../sdk";
 import type { AgentSession } from "../../session/agent-session";
 import { BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE } from "../../session/messages";
 import { SessionManager } from "../../session/session-manager";
 import { createMCPProxyTools, createSubagentSettings } from "../../task/executor";
+import { USER_TODO_EDIT_CUSTOM_TYPE } from "../../tools/todo";
 import type { InteractiveModeContext } from "../types";
 
 const TAN_LABEL_PREVIEW_LENGTH = 80;
@@ -66,6 +68,11 @@ export class TanCommandController {
 		}
 
 		const parentSessionId = session.sessionId;
+		// Providers route on `promptCacheKey ?? sessionId`, so the parent's live
+		// requests may cache under a pinned key that differs from its session id
+		// (the parent being itself a fork/tan). Mirror exactly what the parent
+		// populated the cache under — same rule as advisor and handoff calls.
+		const parentPromptCacheKey = session.agent.promptCacheKey ?? parentSessionId;
 		const thinkingLevel = session.configuredThinkingLevel();
 		const systemPrompt = [...session.systemPrompt];
 		const toolNames = session.getActiveToolNames();
@@ -111,7 +118,7 @@ export class TanCommandController {
 							systemPrompt,
 							toolNames,
 							providerSessionId: `${parentSessionId}:tan:${Snowflake.next()}`,
-							providerPromptCacheKey: parentSessionId,
+							providerPromptCacheKey: parentPromptCacheKey,
 							modelRegistry,
 							authStorage: modelRegistry.authStorage,
 							settings,
@@ -127,19 +134,51 @@ export class TanCommandController {
 							disableExtensionDiscovery: true,
 						});
 						clone = created.session;
+						clone.sessionManager.appendSessionInit({
+							systemPrompt: clone.systemPrompt.join("\n\n"),
+							task: trimmedWork,
+							tools: clone.getActiveToolNames(),
+						});
 						const abortClone = () => {
 							void clone?.abort();
 						};
 						signal.addEventListener("abort", abortClone, { once: true });
+						// The fork inherits the parent's todo list via session entries;
+						// its reminders would drag the tan back onto the parent's task.
+						// Clear runtime state and persist an empty edit so reloads agree.
+						clone.setTodoPhases([]);
+						cloneManager.appendCustomEntry(USER_TODO_EDIT_CUSTOM_TYPE, { phases: [] });
+						const injectContextSwitch = () => {
+							clone?.agent.appendMessage({
+								role: "developer",
+								content: tanContextSwitchPrompt,
+								attribution: "agent",
+								timestamp: Date.now(),
+							});
+						};
+						// Compaction summarizes the fork notice away with the rest of the
+						// history, after which the clone re-adopts the parent's task as its
+						// own (the summary blends both). Re-inject after every successful
+						// compaction so the fork boundary survives summarization.
+						const unsubscribeCompaction = clone.subscribe(event => {
+							if (event.type === "auto_compaction_end" && event.result && !event.aborted) {
+								injectContextSwitch();
+							}
+						});
 						try {
 							if (signal.aborted) {
 								abortClone();
 								throw new Error("Aborted before execution");
 							}
+							// Inject a context-switch developer message so the clone knows
+							// it is a tangential fork — its parent owns the prior conversation;
+							// this agent must focus exclusively on the user's request.
+							injectContextSwitch();
 							await clone.prompt(trimmedWork, { attribution: "user" });
 							await clone.waitForIdle();
 							return extractAssistantText(clone.getLastAssistantMessage()) || "(no output)";
 						} finally {
+							unsubscribeCompaction();
 							signal.removeEventListener("abort", abortClone);
 						}
 					} finally {

package/src/modes/interactive-mode.ts

@@ -118,6 +118,7 @@ import { formatPhaseDisplayName, todoMatchesAnyDescription } from "../tools/todo
 import { ToolError } from "../tools/tool-errors";
 import { vocalizer } from "../tts/vocalizer";
 import { renderTreeList } from "../tui/tree-list";
+import { copyToClipboard } from "../utils/clipboard";
 import type { EventBus } from "../utils/event-bus";
 import { getEditorCommand, openInEditor } from "../utils/external-editor";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../utils/session-color";
@@ -2391,6 +2392,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			{
 				onPick: choice => finish(choice),
 				onCancel: () => finish(undefined),
+				onCopyPlan: content => void this.#copyPlanToClipboard(content),
 				onExternalEditor: dialogOptions?.onExternalEditor,
 				onAnnotationExternalEditor: (draft, commit) => void this.#openPlanAnnotationInExternalEditor(draft, commit),
 				onPlanEdited: dialogOptions?.onPlanEdited,
@@ -2457,6 +2459,17 @@ export class InteractiveMode implements InteractiveModeContext {
 		return contextUsage !== undefined && contextUsage.percent > PLAN_KEEP_CONTEXT_DISABLE_THRESHOLD_PERCENT;
 	}
 
+	async #copyPlanToClipboard(content: string): Promise<void> {
+		try {
+			await copyToClipboard(content);
+			this.showStatus("Copied plan to clipboard");
+		} catch (error) {
+			this.showWarning(
+				`Failed to copy plan to clipboard: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
 	async #openPlanInExternalEditor(planFilePath: string): Promise<void> {
 		const editorCmd = getEditorCommand();
 		if (!editorCmd) {

package/src/modes/magic-keyword-boundary.ts

@@ -0,0 +1,23 @@
+/** Characters that bind a magic keyword into an identifier or path segment. */
+const LEFT_BOUNDARY = String.raw`(?<![\p{L}\p{N}_./\\-])(?<!::)`;
+
+/** Characters that cannot immediately follow a standalone magic keyword. */
+const RIGHT_BOUNDARY = String.raw`(?![\p{L}\p{N}_/\\-])(?!\.[\p{L}\p{N}_-])(?!\()`;
+
+/** Escape a literal string for safe insertion into a RegExp source. */
+function escapeRegExp(value: string): string {
+	return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+/**
+ * Build a case-sensitive magic-keyword matcher for prose punctuation boundaries.
+ *
+ * Sentence punctuation and quotes may touch the keyword, but letters, digits,
+ * underscores, slashes, backslashes, hyphens, file-extension dots, symbol
+ * references (`foo::keyword`), and immediate call parentheses (`keyword()`)
+ * keep the occurrence embedded in code rather than prose.
+ */
+export function magicKeywordRegex(keyword: string, flags = ""): RegExp {
+	const normalizedFlags = flags.includes("u") ? flags : `${flags}u`;
+	return new RegExp(`${LEFT_BOUNDARY}${escapeRegExp(keyword)}${RIGHT_BOUNDARY}`, normalizedFlags);
+}

package/src/modes/orchestrate.ts

@@ -1,5 +1,6 @@
 import orchestrateNotice from "../prompts/system/orchestrate-notice.md" with { type: "text" };
 import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
+import { magicKeywordRegex } from "./magic-keyword-boundary";
 import { keywordInProse } from "./markdown-prose";
 
 /**
@@ -8,21 +9,21 @@ import { keywordInProse } from "./markdown-prose";
  * Typing the standalone word in the input editor paints it with a cool
  * teal→violet gradient ({@link highlightOrchestrate}); submitting a message that
  * mentions it appends a hidden {@link ORCHESTRATE_NOTICE} that switches the model
- * into multi-agent orchestration mode. Matching is whitespace-delimited and
+ * into multi-agent orchestration mode. Matching is prose-delimited and
  * case-sensitive (lowercase only), so "orchestrated", "Orchestrate", or a path
  * like "orchestrate.ts" never trigger either behavior. Replaces the former
  * `/orchestrate` slash command.
  */
 
-// Detection: lowercase keyword flanked by whitespace or a string edge. Non-global so `.test` stays stateless.
-const ORCHESTRATE_WORD = /(?<!\S)orchestrate(?!\S)/;
+// Detection: lowercase keyword flanked by prose punctuation, whitespace, or a string edge.
+const ORCHESTRATE_WORD = magicKeywordRegex("orchestrate");
 
 /** Hidden system notice appended after a user message that mentions "orchestrate". */
 export const ORCHESTRATE_NOTICE: string = orchestrateNotice.trim();
 
 /**
  * Whether `text` contains the standalone keyword "orchestrate" (lowercase,
- * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * prose-delimited) in prose — never inside a code block, inline code span,
  * or XML/HTML section.
  */
 export function containsOrchestrate(text: string): boolean {
@@ -36,7 +37,7 @@ export function containsOrchestrate(text: string): boolean {
  */
 export const highlightOrchestrate: KeywordHighlighter = createGradientHighlighter({
 	probe: /orchestrate/,
-	highlight: /(?<!\S)orchestrate(?!\S)/g,
+	highlight: magicKeywordRegex("orchestrate", "g"),
 	stops: 14,
 	hue: t => 150 + t * 130,
 });

package/src/modes/print-mode.ts

@@ -62,13 +62,22 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 		}
 	});
 
+	let wroteTextWorkingIndicator = false;
+	const writeTextWorkingIndicator = (): void => {
+		if (mode !== "text" || wroteTextWorkingIndicator) return;
+		process.stderr.write("Working...\n");
+		wroteTextWorkingIndicator = true;
+	};
+
 	// Send initial message with attachments
 	if (initialMessage !== undefined) {
+		writeTextWorkingIndicator();
 		await logger.time("print:prompt:initial", () => session.prompt(initialMessage, { images: initialImages }));
 	}
 
 	// Send remaining messages
 	for (const message of messages) {
+		writeTextWorkingIndicator();
 		await logger.time("print:prompt:next", () => session.prompt(message));
 	}
 

package/src/modes/rpc/host-tools.ts

@@ -75,6 +75,7 @@ export class RpcHostToolBridge {
 	#output: RpcHostToolOutput;
 	#definitions = new Map<string, RpcHostToolDefinition>();
 	#pendingCalls = new Map<string, PendingHostToolCall>();
+	#closedError: Error | undefined;
 
 	constructor(output: RpcHostToolOutput) {
 		this.#output = output;
@@ -125,6 +126,9 @@ export class RpcHostToolBridge {
 		if (signal?.aborted) {
 			return Promise.reject(new Error(`Host tool "${definition.name}" was aborted`));
 		}
+		if (this.#closedError) {
+			return Promise.reject(this.#closedError);
+		}
 
 		const id = Snowflake.next() as string;
 		const { promise, resolve, reject } = Promise.withResolvers<AgentToolResult<unknown>>();
@@ -183,4 +187,13 @@ export class RpcHostToolBridge {
 			pending.reject(error);
 		}
 	}
+	/** Reject active and future host tool requests after the RPC client disconnects. */
+	close(message: string): void {
+		if (!this.#closedError) this.#closedError = new Error(message);
+		const pendingCalls = Array.from(this.#pendingCalls.values());
+		this.#pendingCalls.clear();
+		for (const pending of pendingCalls) {
+			pending.reject(this.#closedError);
+		}
+	}
 }

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

@@ -58,6 +58,28 @@ export type PendingExtensionRequest = {
 	resolve: (response: RpcExtensionUIResponse) => void;
 	reject: (error: Error) => void;
 };
+/** Pending extension UI request map that can fail closed when the RPC client disconnects. */
+export class RpcPendingExtensionRequests extends Map<string, PendingExtensionRequest> {
+	#closedError: Error | undefined;
+
+	override set(id: string, request: PendingExtensionRequest): this {
+		if (this.#closedError) {
+			request.reject(this.#closedError);
+			return this;
+		}
+		return super.set(id, request);
+	}
+
+	/** Reject every active and future extension UI request. */
+	rejectAll(message: string): void {
+		if (!this.#closedError) this.#closedError = new Error(message);
+		const requests = Array.from(this.values());
+		this.clear();
+		for (const request of requests) {
+			request.reject(this.#closedError);
+		}
+	}
+}
 
 type RpcOutput = (
 	obj:
@@ -88,6 +110,7 @@ export type RpcSkillCommandResult = { agentInvoked: true };
 export async function tryRunRpcSkillCommand(
 	session: RpcSkillCommandSession,
 	text: string,
+	streamingBehavior: "steer" | "followUp" = "steer",
 ): Promise<RpcSkillCommandResult | false> {
 	if (!session.skillsSettings?.enableSkillCommands) return false;
 	const parsed = parseSkillInvocation(text);
@@ -95,13 +118,16 @@ export async function tryRunRpcSkillCommand(
 	const skill = session.skills.find(candidate => candidate.name === parsed.name);
 	if (!skill) return false;
 	const built = await buildSkillPromptMessage(skill, parsed.args, "user");
-	await session.promptCustomMessage({
-		customType: SKILL_PROMPT_MESSAGE_TYPE,
-		content: built.message,
-		display: true,
-		details: built.details,
-		attribution: "user",
-	});
+	await session.promptCustomMessage(
+		{
+			customType: SKILL_PROMPT_MESSAGE_TYPE,
+			content: built.message,
+			display: true,
+			details: built.details,
+			attribution: "user",
+		},
+		{ streamingBehavior },
+	);
 	return { agentInvoked: true };
 }
 
@@ -242,45 +268,50 @@ function isRpcExtensionUIResponse(value: unknown): value is RpcExtensionUIRespon
 	return value.type === "extension_ui_response" && typeof value.id === "string";
 }
 
-/**
- * Dispatch a single parsed frame from the RPC input stream.
- *
- * Bash commands are dispatched in the background so the caller (the stdin loop
- * in {@link runRpcMode}) can keep reading subsequent frames while a shell
- * command is still running. This lets a client send `abort_bash` (or any other
- * command) while a long-running `bash` is in flight. Response correlation is
- * preserved via each command's `id`; ordering across concurrent commands is
- * not guaranteed and clients MUST match on `id`.
- *
- * @returns `undefined` when the frame was routed to a side-channel handler
- *   (extension UI response, host tool/URI frames) or dispatched in the
- *   background (`bash`). Otherwise a promise that resolves once the response
- *   for the command has been emitted via `output`. Errors from `handleCommand`
- *   on non-`bash` commands propagate; the caller is expected to wrap them.
- */
-export function dispatchRpcInputFrame(parsed: unknown, deps: RpcInputFrameDeps): Promise<void> | undefined {
-	// Side-channel: extension UI responses resolve a pending dialog promise.
+/** Dispatch side-channel frames that must overtake the serialized command queue. */
+export function dispatchRpcControlFrame(parsed: unknown, deps: RpcInputFrameDeps): boolean {
 	if (isRpcExtensionUIResponse(parsed)) {
 		const pending = deps.pendingExtensionRequests.get(parsed.id);
 		if (pending) pending.resolve(parsed);
-		return undefined;
+		return true;
 	}
 
 	if (isRpcHostToolResult(parsed)) {
 		deps.onHostToolResult(parsed);
-		return undefined;
+		return true;
 	}
 
 	if (isRpcHostToolUpdate(parsed)) {
 		deps.onHostToolUpdate(parsed);
-		return undefined;
+		return true;
 	}
 
 	if (isRpcHostUriResult(parsed)) {
 		deps.onHostUriResult(parsed);
-		return undefined;
+		return true;
 	}
 
+	return false;
+}
+
+/**
+ * Dispatch a single parsed frame from the RPC input stream.
+ *
+ * Bash commands are dispatched in the background so the caller can keep reading
+ * subsequent frames while a shell command is still running. This lets a client
+ * send `abort_bash` while a long-running `bash` is in flight. Response
+ * correlation is preserved via each command's `id`; ordering across concurrent
+ * commands is not guaranteed and clients MUST match on `id`.
+ *
+ * @returns `undefined` when the frame was routed to a side-channel handler
+ *   (extension UI response, host tool/URI frames) or dispatched in the
+ *   background (`bash`). Otherwise a promise that resolves once the response
+ *   for the command has been emitted via `output`. Errors from `handleCommand`
+ *   on non-`bash` commands propagate; the caller is expected to wrap them.
+ */
+export function dispatchRpcInputFrame(parsed: unknown, deps: RpcInputFrameDeps): Promise<void> | undefined {
+	if (dispatchRpcControlFrame(parsed, deps)) return undefined;
+
 	// Regular RPC command. The transport contract states each remaining frame
 	// is an {@link RpcCommand}; `handleCommand`'s `default` arm surfaces
 	// unknown discriminants as an error response, so we do not shape-check
@@ -309,6 +340,59 @@ export function dispatchRpcInputFrame(parsed: unknown, deps: RpcInputFrameDeps):
 	})();
 }
 
+/** Serializes ordinary RPC commands while allowing control frames to dispatch immediately. */
+export class RpcInputDispatcher {
+	#tail: Promise<void> = Promise.resolve();
+	#tasks = new Set<Promise<void>>();
+	readonly #deps: RpcInputFrameDeps;
+	readonly #afterSerialCommand: (() => Promise<void>) | undefined;
+
+	constructor(options: { deps: RpcInputFrameDeps; afterSerialCommand?: () => Promise<void> }) {
+		this.#deps = options.deps;
+		this.#afterSerialCommand = options.afterSerialCommand;
+	}
+
+	/** Accept a parsed input frame without blocking the stdin reader. */
+	dispatch(parsed: unknown): void {
+		if (dispatchRpcControlFrame(parsed, this.#deps)) return;
+
+		const command = parsed as RpcCommand;
+		if (command.type === "bash") {
+			dispatchRpcInputFrame(command, this.#deps);
+			return;
+		}
+
+		const task = this.#tail.then(
+			() => this.#dispatchSerialCommand(command),
+			() => this.#dispatchSerialCommand(command),
+		);
+		this.#tail = task.catch(() => {});
+		this.#tasks.add(task);
+		void task.finally(() => {
+			this.#tasks.delete(task);
+		});
+	}
+
+	/** Await every accepted serial command, including commands queued before EOF. */
+	async drain(): Promise<void> {
+		while (this.#tasks.size > 0) {
+			await Promise.allSettled(Array.from(this.#tasks));
+		}
+	}
+
+	async #dispatchSerialCommand(command: RpcCommand): Promise<void> {
+		try {
+			const awaited = dispatchRpcInputFrame(command, this.#deps);
+			if (awaited) await awaited;
+		} catch (err: unknown) {
+			const message = err instanceof Error ? err.message : String(err);
+			this.#deps.output(this.#deps.errorResponse(command.id, command.type, message));
+		} finally {
+			await this.#afterSerialCommand?.();
+		}
+	}
+}
+
 /**
  * Coordinates deferred shutdown with in-flight background input tasks.
  *
@@ -547,7 +631,7 @@ export async function runRpcMode(
 
 	const extensionUserMessageTracker = new RpcExtensionUserMessageTracker();
 
-	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
+	const pendingExtensionRequests = new RpcPendingExtensionRequests();
 	const hostToolBridge = new RpcHostToolBridge(output);
 	const hostUriBridge = new RpcHostUriBridge(output);
 	const subagentRegistry = eventBus ? new RpcSubagentRegistry(eventBus, output) : undefined;
@@ -842,7 +926,7 @@ export async function runRpcMode(
 			// =================================================================
 
 			case "prompt": {
-				const skillResult = await tryRunRpcSkillCommand(session, command.message);
+				const skillResult = await tryRunRpcSkillCommand(session, command.message, command.streamingBehavior);
 				if (skillResult) {
 					return success(id, "prompt", skillResult);
 				}
@@ -1276,35 +1360,25 @@ export async function runRpcMode(
 		onHostUriResult: frame => hostUriBridge.handleResult(frame),
 	};
 
-	// Listen for JSON input using Bun's stdin. Frame dispatch lives in
-	// dispatchRpcInputFrame so it can be exercised directly by tests; see the
-	// helper's docstring for the concurrency contract.
+	const inputDispatcher = new RpcInputDispatcher({
+		deps: dispatchFrameDeps,
+		afterSerialCommand: () => shutdownCoordinator.checkShutdownRequested(),
+	});
+
+	// Keep the stdin reader moving: side-channel frames dispatch immediately,
+	// ordinary commands serialize through inputDispatcher, and bash remains
+	// background-dispatched so abort_bash can overtake it.
 	for await (const parsed of readJsonl(Bun.stdin.stream())) {
-		try {
-			const awaited = dispatchRpcInputFrame(parsed, dispatchFrameDeps);
-			if (awaited) {
-				await awaited;
-				// Check for deferred shutdown request (idle between commands).
-				// Background-dispatched bash frames skip this check so a later
-				// abort_bash can still be read; the coordinator re-checks when
-				// each tracked task settles, so a shutdown requested mid-bash
-				// fires once the response frame is written even if no further
-				// client frames arrive.
-				await shutdownCoordinator.checkShutdownRequested();
-			}
-		} catch (e: unknown) {
-			const message = e instanceof Error ? e.message : String(e);
-			output(error(undefined, "parse", `Failed to parse command: ${message}`));
-		}
+		inputDispatcher.dispatch(parsed);
 	}
 
-	// Background bash tasks may still owe response frames; drain them before
-	// tearing down (stdin EOF ends the frame stream, not in-flight work).
-	await shutdownCoordinator.drain();
-
-	// stdin closed — RPC client is gone, exit cleanly
-	hostToolBridge.rejectAllPending("RPC client disconnected before host tool execution completed");
+	// stdin closed — RPC client is gone. Fail pending side-channel requests
+	// first so active/queued commands can settle, then drain accepted work.
+	pendingExtensionRequests.rejectAll("RPC client disconnected before extension UI response completed");
+	hostToolBridge.close("RPC client disconnected before host tool execution completed");
 	hostUriBridge.clear("RPC client disconnected before host URI request completed");
+	await inputDispatcher.drain();
+	await shutdownCoordinator.drain();
 	subagentRegistry?.dispose();
 	process.exit(0);
 }

package/src/modes/ultrathink.ts

@@ -1,5 +1,6 @@
 import ultrathinkNotice from "../prompts/system/ultrathink-notice.md" with { type: "text" };
 import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
+import { magicKeywordRegex } from "./magic-keyword-boundary";
 import { keywordInProse } from "./markdown-prose";
 
 /**
@@ -8,20 +9,20 @@ import { keywordInProse } from "./markdown-prose";
  * Typing the standalone word in the input editor paints it with a rainbow
  * gradient ({@link highlightUltrathink}); submitting a message that mentions it
  * appends a hidden {@link ULTRATHINK_NOTICE} nudging the model toward careful
- * multi-step reasoning. Matching is whitespace-delimited and case-sensitive
+ * multi-step reasoning. Matching is prose-delimited and case-sensitive
  * (lowercase only), so "ultrathinking", "Ultrathink", or "ultrathink.ts" never
  * trigger either behavior.
  */
 
-// Detection: lowercase keyword flanked by whitespace or a string edge. Non-global so `.test` stays stateless.
-const ULTRATHINK_WORD = /(?<!\S)ultrathink(?!\S)/;
+// Detection: lowercase keyword flanked by prose punctuation, whitespace, or a string edge.
+const ULTRATHINK_WORD = magicKeywordRegex("ultrathink");
 
 /** Hidden system notice appended after a user message that mentions "ultrathink". */
 export const ULTRATHINK_NOTICE: string = ultrathinkNotice.trim();
 
 /**
  * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
- * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * prose-delimited) in prose — never inside a code block, inline code span,
  * or XML/HTML section.
  */
 export function containsUltrathink(text: string): boolean {
@@ -35,7 +36,7 @@ export function containsUltrathink(text: string): boolean {
  */
 export const highlightUltrathink: KeywordHighlighter = createGradientHighlighter({
 	probe: /ultrathink/,
-	highlight: /(?<!\S)ultrathink(?!\S)/g,
+	highlight: magicKeywordRegex("ultrathink", "g"),
 	stops: 14,
 	hue: t => t * 330,
 });

package/src/modes/utils/transcript-render-helpers.ts

@@ -130,6 +130,50 @@ export function assistantHasVisibleContent(message: AssistantAgentMessage): bool
 	);
 }
 
+/**
+ * Split mixed assistant turns into visible text before tool execution and
+ * visible text segments that must render immediately after the preceding tool.
+ */
+export function splitAssistantMessageToolTimeline(message: AssistantAgentMessage): {
+	beforeTools: AssistantAgentMessage;
+	afterToolCalls: ReadonlyMap<string, AssistantAgentMessage>;
+	hasToolCalls: boolean;
+} {
+	const beforeTools: AssistantAgentMessage["content"] = [];
+	const afterToolCalls = new Map<string, AssistantAgentMessage>();
+	let pendingAfterTool: AssistantAgentMessage["content"] = [];
+	let lastToolCallId: string | undefined;
+	let sawToolCall = false;
+
+	const displaySegment = (content: AssistantAgentMessage["content"]): AssistantAgentMessage => ({
+		...message,
+		content,
+		stopReason: "stop",
+		errorMessage: undefined,
+	});
+
+	const flushPendingAfterTool = () => {
+		if (!lastToolCallId || pendingAfterTool.length === 0) return;
+		afterToolCalls.set(lastToolCallId, displaySegment(pendingAfterTool));
+		pendingAfterTool = [];
+	};
+
+	for (const content of message.content) {
+		if (content.type === "toolCall") {
+			flushPendingAfterTool();
+			sawToolCall = true;
+			lastToolCallId = content.id;
+			continue;
+		}
+		if (sawToolCall) pendingAfterTool.push(content);
+		else beforeTools.push(content);
+	}
+	flushPendingAfterTool();
+
+	if (!sawToolCall) return { beforeTools: message, afterToolCalls, hasToolCalls: false };
+	return { beforeTools: displaySegment(beforeTools), afterToolCalls, hasToolCalls: true };
+}
+
 /**
  * Normalize raw tool-call arguments to a plain record, collapsing non-object or
  * array values to an empty object.

package/src/modes/utils/ui-helpers.ts

@@ -56,6 +56,7 @@ import {
 	buildIrcMessageCard,
 	normalizeToolArgs,
 	resolveAssistantErrorMessage,
+	splitAssistantMessageToolTimeline,
 } from "./transcript-render-helpers";
 
 type TextBlock = { type: "text"; text: string };
@@ -350,7 +351,8 @@ export class UiHelpers {
 			if (message.role !== "toolResult") flushPendingUsage();
 			// Assistant messages need special handling for tool calls
 			if (message.role === "assistant") {
-				this.ctx.addMessageToChat(message);
+				const timeline = splitAssistantMessageToolTimeline(message);
+				this.ctx.addMessageToChat(timeline.beforeTools);
 				const lastChild = this.ctx.chatContainer.children[this.ctx.chatContainer.children.length - 1];
 				const assistantComponent = lastChild instanceof AssistantMessageComponent ? lastChild : undefined;
 				if (assistantComponent) {
@@ -384,6 +386,7 @@ export class UiHelpers {
 						continue;
 					}
 					resolveWaitingPoll(content.name);
+					const afterToolSegment = timeline.afterToolCalls.get(content.id);
 
 					if (
 						content.name === "read" &&
@@ -404,6 +407,16 @@ export class UiHelpers {
 								false,
 								content.id,
 							);
+						} else if (afterToolSegment) {
+							if (!readGroup) {
+								readGroup = new ReadToolGroupComponent({
+									showContentPreview: this.ctx.settings.get("read.toolResultPreview"),
+								});
+								readGroup.setExpanded(this.ctx.toolOutputExpanded);
+								this.ctx.chatContainer.addChild(readGroup);
+							}
+							readGroup.updateArgs(content.arguments, content.id);
+							this.ctx.pendingTools.set(content.id, readGroup);
 						} else {
 							const normalizedArgs = normalizeToolArgs(content.arguments);
 							readToolCallArgs.set(content.id, normalizedArgs);
@@ -411,6 +424,7 @@ export class UiHelpers {
 								readToolCallAssistantComponents.set(content.id, assistantComponent);
 							}
 						}
+						if (afterToolSegment) this.ctx.addMessageToChat(afterToolSegment);
 						continue;
 					}
 
@@ -458,6 +472,7 @@ export class UiHelpers {
 					} else {
 						this.ctx.pendingTools.set(content.id, component);
 					}
+					if (afterToolSegment) this.ctx.addMessageToChat(afterToolSegment);
 				}
 				pendingUsage = this.ctx.settings.get("display.showTokenUsage") ? message.usage : undefined;
 				pendingUsageDuration = message.duration;