@oh-my-pi/pi-coding-agent 15.11.7 → 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/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;
 }

package/src/modes/components/segment-track.ts

@@ -1,9 +1,9 @@
 /**
  * Shared renderer for a horizontal row of colored "segments" styled after the
- * status line: each segment shows in its own accent, the active one is filled
- * as a powerline chip (its accent as the background, a luminance-matched label,
- * flanked by triangle caps) and the rest are plain colored labels joined by a
- * thin separator.
+ * status line: each segment is colored by its track position from the theme's
+ * own palette, the active one is filled as a powerline chip (its color as the
+ * background, a luminance-matched label, flanked by triangle caps) and the
+ * rest are plain colored labels joined by a thin separator.
  *
  * Used by the plan-mode model-tier slider ({@link HookSelectorComponent}) and
  * the ctrl+p role-cycle status so both surfaces read identically.
@@ -12,13 +12,49 @@ import { type ThemeColor, theme } from "../theme/theme";
 
 export interface TrackSegment {
 	label: string;
-	/** Theme color for the segment; defaults to `accent`. */
-	color?: ThemeColor;
 }
 
 const FG_RESET = "\x1b[39m";
 const BG_RESET = "\x1b[49m";
 
+/** Vivid theme colors for position-based segment coloring, in preference
+ *  order. Themes alias many of these to the same value (titanium maps most of
+ *  the syntax set onto its accent), so {@link resolveSegmentPalette} dedupes
+ *  by resolved escape and hands position i the i-th distinct color. */
+const SEGMENT_COLOR_CANDIDATES: ThemeColor[] = [
+	"accent",
+	"success",
+	"warning",
+	"error",
+	"mdCode",
+	"mdLink",
+	"syntaxString",
+	"syntaxKeyword",
+	"syntaxFunction",
+	"syntaxNumber",
+	"syntaxOperator",
+	"syntaxVariable",
+];
+
+/**
+ * Resolve up to `count` theme colors that render distinctly under the active
+ * theme, in candidate preference order. May return fewer than `count` when the
+ * theme has fewer distinct hues (e.g. monochrome themes) — callers wrap with
+ * modulo. Never returns an empty array: `accent` always resolves.
+ */
+export function resolveSegmentPalette(count: number): ThemeColor[] {
+	const palette: ThemeColor[] = [];
+	const seen = new Set<string>();
+	for (const color of SEGMENT_COLOR_CANDIDATES) {
+		const ansi = theme.getFgAnsi(color);
+		if (seen.has(ansi)) continue;
+		seen.add(ansi);
+		palette.push(color);
+		if (palette.length >= count) break;
+	}
+	return palette;
+}
+
 /**
  * Render `segments` as a colored chip track with `activeIndex` filled. Returns
  * a single line of styled text with no surrounding caption or arrows — callers
@@ -30,6 +66,7 @@ export function renderSegmentTrack(segments: TrackSegment[], activeIndex: number
 	const capLeft = theme.sep.powerlineRight;
 	const capRight = theme.sep.powerlineLeft;
 	const thinSep = theme.fg("statusLineSep", theme.sep.powerlineThin);
+	const palette = resolveSegmentPalette(segments.length);
 
 	let track = "";
 	segments.forEach((segment, i) => {
@@ -38,7 +75,7 @@ export function renderSegmentTrack(segments: TrackSegment[], activeIndex: number
 			// caps already delimit the active segment, so pad around it instead.
 			track += i === activeIndex || i - 1 === activeIndex ? "  " : ` ${thinSep} `;
 		}
-		const color = segment.color ?? "accent";
+		const color = palette[i % palette.length];
 		const fg = theme.getFgAnsi(color);
 		if (i !== activeIndex) {
 			track += `${fg}${segment.label}${FG_RESET}`;

package/src/modes/components/status-line/component.ts

@@ -18,6 +18,7 @@ import { renderSegment, type SegmentContext } from "./segments";
 import { getSeparator } from "./separators";
 import { calculateTokensPerSecond } from "./token-rate";
 import type {
+	CollabStatus,
 	EffectiveStatusLineSettings,
 	StatusLineSegmentId,
 	StatusLineSegmentOptions,
@@ -152,6 +153,7 @@ export class StatusLineComponent implements Component {
 	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#loopModeStatus: { enabled: boolean } | null = null;
 	#goalModeStatus: { enabled: boolean; paused: boolean } | null = null;
+	#collabStatus: CollabStatus | null = null;
 
 	// Git status caching (1s TTL)
 	#cachedGitStatus: { staged: number; unstaged: number; untracked: number } | null = null;
@@ -217,6 +219,11 @@ export class StatusLineComponent implements Component {
 		this.#subagentCount = count;
 	}
 
+	/** Active subagent count as currently displayed (collab state mirroring). */
+	get subagentCount(): number {
+		return this.#subagentCount;
+	}
+
 	setSessionStartTime(time: number): void {
 		this.#sessionStartTime = time;
 	}
@@ -233,6 +240,10 @@ export class StatusLineComponent implements Component {
 		this.#goalModeStatus = status ?? null;
 	}
 
+	setCollabStatus(status: CollabStatus | null): void {
+		this.#collabStatus = status;
+	}
+
 	setHookStatus(key: string, text: string | undefined): void {
 		if (text === undefined) {
 			this.#hookStatuses.delete(key);
@@ -642,7 +653,15 @@ export class StatusLineComponent implements Component {
 			contextTokens = breakdown.usedTokens;
 			contextWindow = breakdown.contextWindow || contextWindow;
 		}
-		const contextPercent = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
+		let contextPercent = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
+
+		// Collab guest: context comes from the host's state frames — the local
+		// replica does no accounting of its own.
+		const collabState = this.#collabStatus?.stateOverride;
+		if (collabState?.contextUsage) {
+			contextWindow = collabState.contextUsage.contextWindow || contextWindow;
+			contextPercent = collabState.contextUsage.percent ?? contextPercent;
+		}
 
 		return {
 			session: this.session,
@@ -651,6 +670,7 @@ export class StatusLineComponent implements Component {
 			planMode: this.#planModeStatus,
 			loopMode: this.#loopModeStatus,
 			goalMode: this.#goalModeStatus,
+			collab: this.#collabStatus,
 			usageStats,
 			contextPercent,
 			contextWindow,

package/src/modes/components/status-line/presets.ts

@@ -2,7 +2,7 @@ import type { PresetDef, StatusLinePreset } from "./types";
 
 export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 	default: {
-		leftSegments: ["pi", "model", "mode", "path", "git", "pr", "context_pct", "cost"],
+		leftSegments: ["pi", "model", "mode", "collab", "path", "git", "pr", "context_pct", "cost"],
 		rightSegments: ["session_name"],
 		separator: "powerline-thin",
 		segmentOptions: {