@oh-my-pi/pi-coding-agent 15.11.7 → 15.12.0

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,8 @@ 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;
+	#focusedAgentId: string | undefined;
 
 	// Git status caching (1s TTL)
 	#cachedGitStatus: { staged: number; unstaged: number; untracked: number } | null = null;
@@ -187,7 +190,7 @@ export class StatusLineComponent implements Component {
 	#nonMessageInputsKey: string | undefined;
 	#messageTokenTotalsCache: MessageTokenTotalsCache | undefined;
 
-	constructor(private readonly session: AgentSession) {
+	constructor(private session: AgentSession) {
 		this.#settings = {
 			preset: settings.get("statusLine.preset"),
 			leftSegments: settings.get("statusLine.leftSegments"),
@@ -200,6 +203,19 @@ export class StatusLineComponent implements Component {
 		};
 	}
 
+	/**
+	 * Re-point the status line at another session (focus proxy). Invalidate: model/context/usage all derive
+	 * from it. `focusedAgentId` is the focused subagent id while the view is proxied, undefined for main.
+	 */
+	setSession(session: AgentSession, focusedAgentId?: string): void {
+		const sessionChanged = this.session !== session;
+		if (!sessionChanged && this.#focusedAgentId === focusedAgentId) return;
+		this.session = session;
+		this.#focusedAgentId = focusedAgentId;
+		if (sessionChanged) this.#invalidateSessionCaches();
+		this.invalidate();
+	}
+
 	updateSettings(settings: StatusLineSettings): void {
 		this.#settings = settings;
 		this.#effectiveSettings = undefined;
@@ -217,6 +233,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 +254,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);
@@ -281,6 +306,16 @@ export class StatusLineComponent implements Component {
 	invalidate(): void {
 		this.#invalidateGitCaches();
 	}
+	#invalidateSessionCaches(): void {
+		this.#cachedUsage = null;
+		this.#usageFetchedAt = 0;
+		this.#usageInFlight = false;
+		this.#nonMessageTokensCache = undefined;
+		this.#nonMessageInputsKey = undefined;
+		this.#messageTokenTotalsCache = undefined;
+		this.#lastTokensPerSecond = null;
+		this.#lastTokensPerSecondTimestamp = null;
+	}
 
 	#invalidateGitCaches(): void {
 		this.#cachedBranch = undefined;
@@ -441,16 +476,19 @@ export class StatusLineComponent implements Component {
 		const now = Date.now();
 		if (this.#usageInFlight) return;
 		if (this.#usageFetchedAt > 0 && now - this.#usageFetchedAt < 5 * 60_000) return;
-		const fetcher = (this.session as { fetchUsageReports?: () => Promise<unknown> }).fetchUsageReports;
+		const session = this.session;
+		const fetcher = (session as { fetchUsageReports?: () => Promise<unknown> }).fetchUsageReports;
 		if (typeof fetcher !== "function") return;
 		this.#usageInFlight = true;
 		void fetcher
-			.call(this.session)
+			.call(session)
 			.then(reports => {
+				if (this.session !== session) return;
 				this.#cachedUsage = this.#normalizeUsageReports(reports);
 				this.#usageFetchedAt = Date.now();
 			})
 			.catch(() => {
+				if (this.session !== session) return;
 				// Backoff on error: stamp the fetch time so the 5-min TTL guard
 				// also acts as an error budget. Without this, every render
 				// kicks off another fetch (gated only by #usageInFlight),
@@ -458,7 +496,7 @@ export class StatusLineComponent implements Component {
 				this.#usageFetchedAt = Date.now();
 			})
 			.finally(() => {
-				this.#usageInFlight = false;
+				if (this.session === session) this.#usageInFlight = false;
 			});
 	}
 
@@ -642,15 +680,25 @@ 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,
+			focusedAgentId: this.#focusedAgentId,
 			width,
 			options: segmentOptions ?? {},
 			planMode: this.#planModeStatus,
 			loopMode: this.#loopModeStatus,
 			goalMode: this.#goalModeStatus,
+			collab: this.#collabStatus,
 			usageStats,
 			contextPercent,
 			contextWindow,
@@ -858,7 +906,12 @@ export class StatusLineComponent implements Component {
 	}
 
 	getTopBorder(width: number): { content: string; width: number } {
-		const content = this.#buildStatusLine(width);
+		let content = this.#buildStatusLine(width);
+		if (this.#focusedAgentId && content) {
+			// Dim the whole bar while focus-proxied. Group/cap terminators emit full
+			// `\x1b[0m` resets that would cancel faint mid-bar, so re-open it after each.
+			content = `\x1b[2m${content.replaceAll("\x1b[0m", "\x1b[0m\x1b[2m")}\x1b[22m`;
+		}
 		return {
 			content,
 			width: visibleWidth(content),

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: {

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

@@ -65,7 +65,11 @@ function classifyProjectDir(pwd: string): { scratch: boolean; relative: string |
 
 const piSegment: StatusLineSegment = {
 	id: "pi",
-	render(_ctx) {
+	render(ctx) {
+		if (ctx.focusedAgentId) {
+			const icon = theme.icon.ghost ? `${theme.icon.ghost} ` : "";
+			return { content: theme.fg("warning", `${icon}${ctx.focusedAgentId} `), visible: true };
+		}
 		const content = theme.icon.pi ? `${theme.icon.pi} ` : "";
 		return { content: theme.fg("accent", content), visible: true };
 	},
@@ -493,6 +497,18 @@ const sessionNameSegment: StatusLineSegment = {
 	},
 };
 
+const collabSegment: StatusLineSegment = {
+	id: "collab",
+	render(ctx) {
+		if (!ctx.collab) return { content: "", visible: false };
+		const label =
+			ctx.collab.role === "host"
+				? `⇄ collab:${ctx.collab.participantCount}`
+				: `⇄ collab guest:${ctx.collab.participantCount}`;
+		return { content: theme.fg("accent", label), visible: true };
+	},
+};
+
 function pickUsageColor(percent: number): "muted" | "warning" | "error" {
 	if (percent >= 80) return "error";
 	if (percent >= 50) return "warning";
@@ -573,6 +589,7 @@ export const SEGMENTS: Record<StatusLineSegmentId, StatusLineSegment> = {
 	cache_hit: cacheHitSegment,
 	session_name: sessionNameSegment,
 	usage: usageSegment,
+	collab: collabSegment,
 };
 
 export function renderSegment(id: StatusLineSegmentId, ctx: SegmentContext): RenderedSegment {

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

@@ -1,8 +1,17 @@
+import type { CollabSessionState } from "../../../collab/protocol";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../../config/settings-schema";
 import type { AgentSession } from "../../../session/agent-session";
 
 export type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle };
 
+/** Collab session indicator + (guest-only) host-state override for segments. */
+export interface CollabStatus {
+	role: "host" | "guest";
+	participantCount: number;
+	/** Guest only: host footer snapshot that overrides locally computed values. */
+	stateOverride?: CollabSessionState | null;
+}
+
 export interface StatusLineSegmentOptions {
 	model?: { showThinkingLevel?: boolean };
 	path?: { abbreviate?: boolean; maxLength?: number; stripWorkPrefix?: boolean };
@@ -36,6 +45,8 @@ export type RGB = readonly [number, number, number];
 
 export interface SegmentContext {
 	session: AgentSession;
+	/** Focused subagent id while the view is proxied at its session, undefined otherwise. */
+	focusedAgentId?: string | undefined;
 	width: number;
 	options: StatusLineSegmentOptions;
 	planMode: {
@@ -49,6 +60,7 @@ export interface SegmentContext {
 		enabled: boolean;
 		paused: boolean;
 	} | null;
+	collab: CollabStatus | null;
 	// Cached values for performance (computed once per render)
 	usageStats: {
 		input: number;

package/src/modes/components/tips.txt

@@ -16,4 +16,7 @@ Press alt+p (or /switch) to switch provider, and ctrl+p to cycle role models smo
 Press ctrl+r to search your prompt history and reuse a past message
 `/force read` pins the next turn to one specific tool when the model keeps reaching for the wrong one
 `/copy code` grabs the last code block to your clipboard — `/copy cmd` grabs the last shell/python command
-`/shake` rips heavy tool results out of context to reclaim tokens without a full /compact — `/shake images` drops just images
+`/shake` rips heavy tool results out of context to reclaim tokens without a full /compact — `/shake images` drops just images
+Pair up live: `/collab` shares your session through an end-to-end encrypted relay link — a teammate runs `/join <link>` to watch tool calls stream and prompt the agent from their own omp
+Press ← ← to drill into a running or finished agent and inspect its tool calls and transcript
+Hit a Codex rate limit? `/usage reset` spends a saved reset credit to immediately restore your quota