@oh-my-pi/pi-coding-agent 15.11.6 → 15.11.8

package/src/main.ts

@@ -66,6 +66,7 @@ import {
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
 import { resolveResumableSession, type SessionInfo, SessionManager } from "./session/session-manager";
+import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { discoverTitleSystemPromptFile, resolvePromptInput } from "./system-prompt";
 import { initTelemetryExport, isTelemetryExportEnabled } from "./telemetry-export";
 import { AUTO_THINKING } from "./thinking";
@@ -346,6 +347,7 @@ async function runInteractiveMode(
 	initialMessage?: string,
 	initialImages?: ImageContent[],
 	titleSystemPrompt?: string,
+	joinLink?: string,
 ): Promise<void> {
 	const mode = new InteractiveMode(
 		session,
@@ -414,6 +416,12 @@ async function runInteractiveMode(
 		}
 	}
 
+	// `omp join <link>`: dispatch through the same builtin path as a typed
+	// `/join` so collab guards and error rendering stay in one place.
+	if (joinLink !== undefined) {
+		await executeBuiltinSlashCommand(`/join ${joinLink}`, { ctx: mode });
+	}
+
 	if (initialMessage !== undefined) {
 		try {
 			using _keepalive = new EventLoopKeepalive();
@@ -889,7 +897,7 @@ export async function runRootCommand(
 
 	// Create AuthStorage and ModelRegistry upfront
 	const authStorage = await logger.time("discoverAuthStorage", deps.discoverAuthStorage ?? discoverAuthStorage);
-	const modelRegistry = new ModelRegistry(authStorage);
+	const modelRegistry = logger.time("modelRegistry:init", () => new ModelRegistry(authStorage));
 
 	if (parsedArgs.version) {
 		process.stdout.write(`${VERSION}\n`);
@@ -1138,7 +1146,7 @@ export async function runRootCommand(
 	// Both are no-ops when OTEL_EXPORTER_OTLP_ENDPOINT is unset. An empty config
 	// is enough to enable telemetry — content capture is governed by the
 	// standard OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT env var.
-	await initTelemetryExport();
+	await logger.time("initTelemetryExport", initTelemetryExport);
 	if (isTelemetryExportEnabled()) {
 		sessionOptions.telemetry = {};
 	}
@@ -1298,6 +1306,7 @@ export async function runRootCommand(
 				initialMessage,
 				initialImages,
 				titleSystemPrompt,
+				parsedArgs.join,
 			);
 		} else {
 			// Branch-only single-shot runner: keep print-mode code out of normal interactive startup.

package/src/mcp/transports/stdio.ts

@@ -85,27 +85,99 @@ async function resolveWindowsCommandPath(
 	env: Record<string, string | undefined>,
 ): Promise<string | null> {
 	const extensions = getWindowsPathExt(env);
-	if (hasExecutableExtension(command, extensions)) return command;
+	const hasExt = hasExecutableExtension(command, extensions);
+	const candidates = hasExt ? [command] : extensions.map(ext => `${command}${ext}`);
 
-	const candidates = extensions.map(ext => `${command}${ext}`);
 	if (hasPathSegment(command)) {
 		for (const candidate of candidates) {
 			const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(cwd, candidate);
 			if (await fileExists(resolved)) return resolved;
 		}
-		return null;
+		return hasExt ? command : null;
 	}
 
+	// Match cmd.exe's lookup order for an unqualified name: current directory
+	// first, then PATH. Skipping cwd would launch a global shim instead of a
+	// project-local one with the same name.
+	const searchDirs = [cwd];
 	const pathValue = getCaseInsensitiveEnv(env, "PATH");
-	if (!pathValue) return null;
-	for (const dir of pathValue.split(";")) {
-		if (!dir) continue;
+	if (pathValue) {
+		for (const dir of pathValue.split(";")) {
+			if (dir) searchDirs.push(dir);
+		}
+	}
+	for (const dir of searchDirs) {
 		for (const candidate of candidates) {
 			const resolved = path.join(dir, candidate);
 			if (await fileExists(resolved)) return resolved;
 		}
 	}
-	return null;
+	return hasExt ? command : null;
+}
+
+function resolveWindowsShimPath(value: string, shimDir: string): string | null {
+	const match = /^%dp0%[\\/]*(.*)$/i.exec(value);
+	if (!match) return null;
+	const suffix = match[1];
+	if (!suffix) return shimDir;
+	return path.join(shimDir, ...suffix.split(/[\\/]+/).filter(Boolean));
+}
+
+function extractWindowsNpmShimTarget(content: string): string | null {
+	const match = /"%_prog%"\s+"([^"]+)"\s+%\*/i.exec(content);
+	return match?.[1] ?? null;
+}
+
+/**
+ * Extract the shim's PATH-fallback interpreter (`SET "_prog=node"`). The
+ * `IF EXIST` branch assigns a `%dp0%`-prefixed value, so requiring a
+ * non-`%`-leading value picks the bare program name.
+ */
+function extractWindowsNpmShimProg(content: string): string | null {
+	const match = /SET\s+"_prog=([^%"][^"]*)"/i.exec(content);
+	return match?.[1] ?? null;
+}
+
+async function resolveWindowsNpmShimCommand(
+	command: string,
+	args: readonly string[],
+	cwd: string,
+): Promise<StdioSpawnCommand | null> {
+	if (!isWindowsBatchCommand(command)) return null;
+	if (!hasPathSegment(command)) return null;
+	const commandPath = path.resolve(cwd, command);
+
+	let content: string;
+	try {
+		content = await Bun.file(commandPath).text();
+	} catch {
+		return null;
+	}
+
+	// cmd-shim emits the same invocation line for every interpreter; only
+	// bypass cmd.exe when the shim's fallback interpreter is actually node.
+	const prog = extractWindowsNpmShimProg(content);
+	if (
+		!prog ||
+		path
+			.basename(prog)
+			.replace(/\.exe$/i, "")
+			.toLowerCase() !== "node"
+	)
+		return null;
+
+	const rawTarget = extractWindowsNpmShimTarget(content);
+	if (!rawTarget) return null;
+
+	const target = resolveWindowsShimPath(rawTarget, path.dirname(commandPath));
+	if (!target) return null;
+
+	const siblingNode = path.join(path.dirname(commandPath), "node.exe");
+	const nodeCommand = (await fileExists(siblingNode)) ? siblingNode : "node";
+	return {
+		cmd: [nodeCommand, target, ...args],
+		windowsHide: true,
+	};
 }
 
 function quoteCmdArg(value: string): string {
@@ -150,6 +222,8 @@ export async function resolveStdioSpawnCommand(
 
 	const resolvedCommand =
 		(await resolveWindowsCommandPath(config.command, options.cwd, options.env)) ?? config.command;
+	const npmShimCommand = await resolveWindowsNpmShimCommand(resolvedCommand, args, options.cwd);
+	if (npmShimCommand) return npmShimCommand;
 	if (!isWindowsBatchCommand(resolvedCommand)) return { cmd: [resolvedCommand, ...args] };
 
 	return {

package/src/modes/components/agent-hub.ts

@@ -81,6 +81,15 @@ function statusBadge(status: AgentStatus): string {
 	}
 }
 
+/** Guest-side proxy for hub actions executed on the collab host. */
+export interface AgentHubRemote {
+	chat(id: string, text: string): void;
+	kill(id: string): void;
+	revive(id: string): void;
+	/** Mirrors readFileIncremental: text from fromByte (complete JSONL lines), newSize = next fromByte base; null = unavailable. */
+	readTranscript(id: string, fromByte: number): Promise<{ text: string; newSize: number } | null>;
+}
+
 export interface AgentHubDeps {
 	/** Progress/status snapshot source (task lifecycle + progress channels). */
 	observers: SessionObserverRegistry;
@@ -94,6 +103,8 @@ export interface AgentHubDeps {
 	lifecycle?: AgentLifecycleManager;
 	/** Injectable for tests; defaults to the process-global bus. */
 	irc?: IrcBus;
+	/** Collab guest: route actions/transcripts to the host instead of local sessions. */
+	remote?: AgentHubRemote;
 }
 
 export class AgentHubOverlayComponent extends Container {
@@ -106,6 +117,11 @@ export class AgentHubOverlayComponent extends Container {
 	#hubKeys: KeyId[];
 	#unsubscribers: Array<() => void> = [];
 	#ageTimer: NodeJS.Timeout | undefined;
+	#remote: AgentHubRemote | undefined;
+	#remoteFetchInFlight = false;
+	/** Invalidates stale in-flight fetch callbacks after openChat resets the cache. */
+	#remoteFetchToken = 0;
+	#remoteTranscriptUnavailable = false;
 
 	// Table state
 	#view: "table" | "chat" = "table";
@@ -143,6 +159,7 @@ export class AgentHubOverlayComponent extends Container {
 		this.#onDone = deps.onDone;
 		this.#requestRender = deps.requestRender;
 		this.#hubKeys = deps.hubKeys;
+		this.#remote = deps.remote;
 
 		this.#editor = new Editor(getEditorTheme());
 		this.#editor.setMaxHeight(4);
@@ -196,6 +213,9 @@ export class AgentHubOverlayComponent extends Container {
 		this.#chatAgentId = id;
 		this.#notice = undefined;
 		this.#transcriptCache = undefined;
+		this.#remoteTranscriptUnavailable = false;
+		this.#remoteFetchInFlight = false;
+		this.#remoteFetchToken++;
 		this.#scrollOffset = 0;
 		this.#selectedEntryIndex = 0;
 		this.#expandedEntries.clear();
@@ -238,6 +258,8 @@ export class AgentHubOverlayComponent extends Container {
 
 	/** Subscribe to the chat agent's live session (if any) for transcript refreshes. Idempotent per session. */
 	#attachLiveSession(): void {
+		// Remote refs carry no live session handle; refreshes come from observer onChange.
+		if (this.#remote) return;
 		const session = this.#chatAgentId ? (this.#registry.get(this.#chatAgentId)?.session ?? undefined) : undefined;
 		if (session === this.#attachedSession) return;
 		this.#detachLiveSession();
@@ -391,6 +413,11 @@ export class AgentHubOverlayComponent extends Container {
 			return;
 		}
 		this.#notice = undefined;
+		if (this.#remote) {
+			this.#remote.revive(ref.id);
+			this.#requestRender();
+			return;
+		}
 		// Fire-and-forget; failures surface as an inline notice
 		this.#lifecycle()
 			.ensureLive(ref.id)
@@ -405,6 +432,12 @@ export class AgentHubOverlayComponent extends Container {
 		const ref = this.#rows[this.#selectedRow];
 		if (!ref) return;
 		this.#notice = undefined;
+		if (this.#remote) {
+			this.#remote.kill(ref.id);
+			this.#refreshRows();
+			this.#requestRender();
+			return;
+		}
 		void (async () => {
 			try {
 				if (ref.status === "running" && ref.session) {
@@ -512,7 +545,10 @@ export class AgentHubOverlayComponent extends Container {
 
 		// Load transcript first so model info is available for the header
 		let messageEntries: SessionMessageEntry[] | null = null;
-		if (ref?.sessionFile) {
+		if (this.#remote) {
+			if (id) this.#fetchRemoteTranscript(id);
+			messageEntries = this.#transcriptCache?.entries ?? [];
+		} else if (ref?.sessionFile) {
 			messageEntries = this.#loadTranscript(ref.sessionFile);
 		}
 
@@ -530,12 +566,18 @@ export class AgentHubOverlayComponent extends Container {
 		this.#viewerEntries = [];
 		if (!ref) {
 			contentLines.push(theme.fg("dim", "Agent no longer registered."));
-		} else if (!ref.sessionFile) {
+		} else if (!this.#remote && !ref.sessionFile) {
 			contentLines.push(theme.fg("dim", "No session file available yet."));
 		} else if (!messageEntries) {
 			contentLines.push(theme.fg("dim", "Unable to read session file."));
 		} else if (messageEntries.length === 0) {
-			contentLines.push(theme.fg("dim", "No messages yet."));
+			if (this.#remote && this.#remoteTranscriptUnavailable) {
+				contentLines.push(theme.fg("dim", "Transcript lives on the host — not available."));
+			} else if (this.#remote && !this.#transcriptCache) {
+				contentLines.push(theme.fg("dim", "Loading transcript from host…"));
+			} else {
+				contentLines.push(theme.fg("dim", "No messages yet."));
+			}
 		} else {
 			this.#buildTranscriptLines(messageEntries, contentLines);
 		}
@@ -580,6 +622,12 @@ export class AgentHubOverlayComponent extends Container {
 		if (!id || !trimmed) return;
 		this.#editor.setText("");
 		this.#notice = undefined;
+		if (this.#remote) {
+			this.#remote.chat(id, trimmed);
+			this.#scheduleChatRefresh();
+			this.#requestRender();
+			return;
+		}
 		void (async () => {
 			try {
 				// Revives a parked agent; returns the live session for running/idle.
@@ -1024,31 +1072,80 @@ export class AgentHubOverlayComponent extends Container {
 			return this.#loadTranscript(sessionFile);
 		}
 
+		this.#ingestTranscriptChunk(sessionFile, result.text, fromByte);
+		return this.#transcriptCache?.entries ?? null;
+	}
+
+	/** Parse a complete-line JSONL chunk into the transcript cache and advance bytesRead. Shared by the local file and remote paths. */
+	#ingestTranscriptChunk(cacheKey: string, text: string, fromByte: number): void {
 		if (!this.#transcriptCache) {
-			this.#transcriptCache = { path: sessionFile, bytesRead: 0, entries: [] };
+			this.#transcriptCache = { path: cacheKey, bytesRead: 0, entries: [] };
 		}
+		if (text.length === 0) return;
+		const lastNewline = text.lastIndexOf("\n");
+		if (lastNewline < 0) return;
+		const completeChunk = text.slice(0, lastNewline + 1);
+		const newEntries = parseSessionEntries(completeChunk);
+		for (const entry of newEntries) {
+			if (entry.type === "message") {
+				this.#transcriptCache.entries.push(entry);
+				// Extract model from first assistant message
+				const msg = entry.message;
+				if (!this.#transcriptCache.model && msg.role === "assistant") {
+					this.#transcriptCache.model = msg.model;
+				}
+			} else if (entry.type === "model_change") {
+				this.#transcriptCache.model = entry.model;
+			}
+		}
+		this.#transcriptCache.bytesRead = fromByte + Buffer.byteLength(completeChunk, "utf-8");
+	}
 
-		if (result.text.length > 0) {
-			const lastNewline = result.text.lastIndexOf("\n");
-			if (lastNewline >= 0) {
-				const completeChunk = result.text.slice(0, lastNewline + 1);
-				const newEntries = parseSessionEntries(completeChunk);
-				for (const entry of newEntries) {
-					if (entry.type === "message") {
-						this.#transcriptCache.entries.push(entry);
-						// Extract model from first assistant message
-						const msg = entry.message;
-						if (!this.#transcriptCache.model && msg.role === "assistant") {
-							this.#transcriptCache.model = msg.model;
+	/** Kick an incremental transcript fetch from the collab host (single-flight). */
+	#fetchRemoteTranscript(id: string): void {
+		const remote = this.#remote;
+		if (!remote || this.#remoteFetchInFlight) return;
+		const cacheKey = `remote:${id}`;
+		if (this.#transcriptCache && this.#transcriptCache.path !== cacheKey) {
+			this.#transcriptCache = undefined;
+		}
+		const fromByte = this.#transcriptCache?.bytesRead ?? 0;
+		this.#remoteFetchInFlight = true;
+		const token = ++this.#remoteFetchToken;
+		void remote
+			.readTranscript(id, fromByte)
+			.then(result => {
+				if (token !== this.#remoteFetchToken) return;
+				this.#remoteFetchInFlight = false;
+				if (this.#chatAgentId !== id) return;
+				if (!result) {
+					if (!this.#transcriptCache || this.#transcriptCache.entries.length === 0) {
+						if (!this.#remoteTranscriptUnavailable) {
+							this.#remoteTranscriptUnavailable = true;
+							this.#scheduleChatRefresh();
 						}
-					} else if (entry.type === "model_change") {
-						this.#transcriptCache.model = entry.model;
 					}
+					return;
 				}
-				this.#transcriptCache.bytesRead = fromByte + Buffer.byteLength(completeChunk, "utf-8");
-			}
-		}
-		return this.#transcriptCache.entries;
+				if (result.newSize < fromByte) {
+					// Host transcript truncated/rotated — restart from 0.
+					this.#transcriptCache = undefined;
+					this.#fetchRemoteTranscript(id);
+					return;
+				}
+				this.#remoteTranscriptUnavailable = false;
+				const hadCache = this.#transcriptCache !== undefined;
+				const before = this.#transcriptCache?.entries.length ?? 0;
+				this.#ingestTranscriptChunk(cacheKey, result.text, fromByte);
+				const after = this.#transcriptCache?.entries.length ?? 0;
+				// Only refresh on new content (or first completed fetch) — an
+				// unconditional rebuild would re-kick the fetch in a tight loop.
+				if (after > before || !hadCache) this.#scheduleChatRefresh();
+			})
+			.catch((error: unknown) => {
+				if (token === this.#remoteFetchToken) this.#remoteFetchInFlight = false;
+				logger.warn("Agent hub: remote transcript fetch failed", { id, error: String(error) });
+			});
 	}
 }
 

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

@@ -49,6 +49,11 @@ export class AssistantMessageComponent extends Container {
 	/** Whether the last updateContent carried an in-flight streaming partial; such
 	 *  renders bypass the markdown module LRU (see Markdown.transientRenderCache). */
 	#lastUpdateTransient = false;
+	// Fast-path state: reuse Markdown children when message shape is stable during streaming.
+	#fastPathKey: string | undefined;
+	#fastPathItems:
+		| Array<{ md: Markdown; contentIndex: number; blockType: "text" | "thinking"; lastText: string }>
+		| undefined;
 
 	constructor(
 		message?: AssistantMessage,
@@ -71,6 +76,12 @@ export class AssistantMessageComponent extends Container {
 
 	override invalidate(): void {
 		super.invalidate();
+		// Theme/symbol changes arrive via invalidate(). Fast-path children captured
+		// getMarkdownTheme() at construction, so drop them and force the teardown
+		// path to rebuild with the current theme. Streaming updates call
+		// updateContent() directly and keep the fast path.
+		this.#fastPathKey = undefined;
+		this.#fastPathItems = undefined;
 		if (this.#lastMessage) {
 			this.updateContent(this.#lastMessage, { transient: this.#lastUpdateTransient });
 		}
@@ -228,14 +239,111 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	#computeShapeKey(message: AssistantMessage): string {
+		const parts: string[] = [`htb:${this.hideThinkingBlock ? 1 : 0}`];
+		for (const content of message.content) {
+			if (content.type === "text") {
+				parts.push(content.text.trim() ? "T1" : "T0");
+			} else if (content.type === "thinking") {
+				if (!content.thinking.trim()) parts.push("K0");
+				else if (this.hideThinkingBlock) parts.push("KH");
+				else parts.push("KV");
+			} else {
+				// Non-rendered blocks (toolCall, redactedThinking, …) still occupy a
+				// content index. Encode their position so an inserted/removed one shifts
+				// the key and forces the teardown path instead of mis-indexing children.
+				parts.push(`O:${content.type}`);
+			}
+		}
+		if (settings.get("display.showTokenUsage") && this.#usageInfo) {
+			const u = this.#usageInfo;
+			parts.push(`u:${u.input + u.cacheWrite}:${u.output}:${u.cacheRead}`);
+		} else {
+			parts.push("u:");
+		}
+		return parts.join("|");
+	}
+
+	#canFastPath(message: AssistantMessage): boolean {
+		for (const content of message.content) {
+			if (content.type === "toolCall") return false;
+		}
+		if (this.#toolImagesByCallId.size > 0) return false;
+		if (message.stopReason === "aborted" && shouldRenderAbortReason(message.errorMessage)) return false;
+		if (message.stopReason === "error" && !this.#errorPinned) return false;
+		if (
+			message.errorMessage &&
+			shouldRenderAbortReason(message.errorMessage) &&
+			message.stopReason !== "aborted" &&
+			message.stopReason !== "error"
+		)
+			return false;
+		// Extension stability: if thinking renderers exist and any tracked thinking
+		// block's text changed, extensions may produce a different child count.
+		if (this.thinkingRenderers.length > 0 && this.#fastPathItems) {
+			for (const item of this.#fastPathItems) {
+				if (item.blockType === "thinking") {
+					const content = message.content[item.contentIndex];
+					if (content?.type === "thinking" && content.thinking.trim() !== item.lastText) return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	#tryFastPathUpdate(message: AssistantMessage, opts?: { transient?: boolean }): boolean {
+		if (!this.#fastPathKey || !this.#fastPathItems) return false;
+		if (!this.#canFastPath(message)) {
+			this.#fastPathKey = undefined;
+			this.#fastPathItems = undefined;
+			return false;
+		}
+		if (this.#computeShapeKey(message) !== this.#fastPathKey) {
+			this.#fastPathKey = undefined;
+			this.#fastPathItems = undefined;
+			return false;
+		}
+		const transient = opts?.transient === true;
+		// Shape is identical — setText only on Markdown children whose source changed.
+		for (const item of this.#fastPathItems) {
+			item.md.transientRenderCache = transient;
+			const content = message.content[item.contentIndex];
+			let newText: string;
+			if (item.blockType === "text" && content?.type === "text") {
+				newText = content.text.trim();
+			} else if (item.blockType === "thinking" && content?.type === "thinking") {
+				newText = content.thinking.trim();
+			} else {
+				// Block at this index is gone or changed type (index shift) — fail closed.
+				this.#fastPathKey = undefined;
+				this.#fastPathItems = undefined;
+				return false;
+			}
+			if (newText !== item.lastText) {
+				item.md.setText(newText);
+				item.lastText = newText;
+			}
+		}
+		return true;
+	}
+
 	updateContent(message: AssistantMessage, opts?: { transient?: boolean }): void {
 		this.#blockVersion++;
 		this.#lastMessage = message;
 		this.#lastUpdateTransient = opts?.transient === true;
 
+		// Fast path: reuse Markdown children when shape is stable during streaming
+		if (this.#tryFastPathUpdate(message)) return;
+
 		// Clear content container
 		this.#contentContainer.clear();
 
+		// Determine if we should capture Markdown instances for next fast path
+		const shouldCapture = this.#canFastPath(message);
+		const captureItems:
+			| Array<{ md: Markdown; contentIndex: number; blockType: "text" | "thinking"; lastText: string }>
+			| undefined = shouldCapture ? [] : undefined;
+
 		const hasVisibleContent = message.content.some(
 			c =>
 				(c.type === "text" && c.text.trim()) ||
@@ -249,9 +357,11 @@ export class AssistantMessageComponent extends Container {
 			if (content.type === "text" && content.text.trim()) {
 				// Assistant text messages with no background - trim the text
 				// Set paddingY=0 to avoid extra spacing before tool executions
-				const markdown = new Markdown(content.text.trim(), 1, 0, getMarkdownTheme());
-				markdown.transientRenderCache = this.#lastUpdateTransient;
-				this.#contentContainer.addChild(markdown);
+				const trimmed = content.text.trim();
+				const md = new Markdown(trimmed, 1, 0, getMarkdownTheme());
+				md.transientRenderCache = this.#lastUpdateTransient;
+				this.#contentContainer.addChild(md);
+				captureItems?.push({ md, contentIndex: i, blockType: "text", lastText: trimmed });
 			} else if (content.type === "thinking" && content.thinking.trim()) {
 				if (this.hideThinkingBlock) {
 					thinkingIndex += 1;
@@ -265,12 +375,13 @@ export class AssistantMessageComponent extends Container {
 
 				const thinkingText = content.thinking.trim();
 				// Thinking traces in thinkingText color, italic
-				const thinkingMarkdown = new Markdown(thinkingText, 1, 0, getMarkdownTheme(), {
+				const md = new Markdown(thinkingText, 1, 0, getMarkdownTheme(), {
 					color: (text: string) => theme.fg("thinkingText", text),
 					italic: true,
 				});
-				thinkingMarkdown.transientRenderCache = this.#lastUpdateTransient;
-				this.#contentContainer.addChild(thinkingMarkdown);
+				md.transientRenderCache = this.#lastUpdateTransient;
+				this.#contentContainer.addChild(md);
+				captureItems?.push({ md, contentIndex: i, blockType: "thinking", lastText: thinkingText });
 				this.#appendThinkingExtensions(i, thinkingIndex, thinkingText);
 				thinkingIndex += 1;
 				if (hasVisibleContentAfter) {
@@ -318,5 +429,14 @@ export class AssistantMessageComponent extends Container {
 			this.#contentContainer.addChild(new Spacer(1));
 			this.#contentContainer.addChild(new Text(theme.fg("dim", parts.join("  ")), 1, 0));
 		}
+
+		// Store fast-path state for next call
+		if (shouldCapture) {
+			this.#fastPathItems = captureItems;
+			this.#fastPathKey = this.#computeShapeKey(message);
+		} else {
+			this.#fastPathKey = undefined;
+			this.#fastPathItems = undefined;
+		}
 	}
 }

package/src/modes/components/collab-prompt-message.ts

@@ -0,0 +1,30 @@
+import type { TextContent } from "@oh-my-pi/pi-ai";
+import { Container, Markdown, Text } from "@oh-my-pi/pi-tui";
+import type { CollabPromptDetails } from "../../collab/protocol";
+import type { CustomMessage } from "../../session/messages";
+import { getMarkdownTheme, theme } from "../theme/theme";
+
+/**
+ * Renders a collab guest prompt on every participant's transcript: a
+ * user-message-styled bubble prefixed with the author's name.
+ */
+export class CollabPromptMessageComponent extends Container {
+	constructor(message: CustomMessage<CollabPromptDetails>) {
+		super();
+		const from = message.details?.from?.trim() || "guest";
+		this.addChild(new Text(theme.fg("accent", `\x1b[1m«${from}»\x1b[22m ›`), 1, 0));
+		const text =
+			typeof message.content === "string"
+				? message.content
+				: message.content
+						.filter((content): content is TextContent => content.type === "text")
+						.map(content => content.text)
+						.join("");
+		this.addChild(
+			new Markdown(text, 1, 1, getMarkdownTheme(), {
+				bgColor: (value: string) => theme.bg("userMessageBg", value),
+				color: (value: string) => theme.fg("userMessageText", value),
+			}),
+		);
+	}
+}

package/src/modes/components/hook-selector.ts

@@ -31,13 +31,12 @@ import { CountdownTimer } from "./countdown-timer";
 import { DynamicBorder } from "./dynamic-border";
 import { renderSegmentTrack } from "./segment-track";
 
-/** One segment of a {@link HookSelectorSlider} — a label, its accent color, and
- *  an optional detail line (e.g. the resolved model name) shown beneath the
- *  track while the segment is active. */
+/** One segment of a {@link HookSelectorSlider} — a label and an optional
+ *  detail line (e.g. the resolved model name) shown beneath the track while
+ *  the segment is active. Segment colors come from the track's theme palette,
+ *  assigned by position. */
 export interface HookSelectorSliderSegment {
 	label: string;
-	/** Theme color for the segment label; defaults to `accent`. */
-	color?: ThemeColor;
 	/** Secondary line rendered under the track when this segment is selected. */
 	detail?: string;
 }