pi-claude-code-ui 1.0.84 → 1.0.85

package/CHANGELOG.md

@@ -39,6 +39,16 @@
 
 - **Hide transient context tags** — hide transient context tags in streaming prose.
 
+## 1.0.85 — 2026-09-07
+
+### Fixed
+
+- Preserve Markdown code literals while formatting inline mathematics.
+- Keep assistant presentation state out of canonical session messages so compacted sessions can replay safely.
+- Respect `bashOutputMode` for completed Bash output.
+- Preserve native prompt metadata in wrapped core tools.
+- Harden spinner cleanup when Pi replaces a stale UI context.
+
 ## Unreleased
 
 ### Fixed

package/README.md

@@ -37,7 +37,7 @@ Claude Code inspired tool rendering for Pi — Shiki-powered diffs, status dots,
 
 ## Configuration
 
-Set in `.pi/settings.json` or `~/.pi/settings.json`:
+Set in `.pi/settings.json` or the active Pi agent settings file (`$PI_CODING_AGENT_DIR/settings.json`, defaulting to `~/.pi/settings.json`):
 
 ```json
 {
@@ -93,7 +93,7 @@ On `/resume`, `/new`, or `/fork`, tool chrome is rebound from the **current** pi
 /cc-theme toggle    # flip the current value
 ```
 
-The selection is persisted to `~/.pi/settings.json` and applied to the next rendered tool row. No restart required.
+The selection is persisted to the active Pi agent settings file and applied to the next rendered tool row. No restart required.
 
 #### Repaint the spinner with `/cc-spinner`
 
@@ -106,7 +106,7 @@ The spinner glyph itself is still colored by pi's loader using `accent`, while t
 /cc-spinner reset            # restore defaults (verb=borderAccent, status=muted)
 ```
 
-The selection is persisted as `spinnerVerbColor` / `spinnerStatusColor` in `~/.pi/settings.json` and applied on the next spinner tick.
+The selection is persisted as `spinnerVerbColor` / `spinnerStatusColor` in the active Pi agent settings file and applied on the next spinner tick.
 
 ### Tool background modes
 

package/extensions/index.ts

@@ -70,6 +70,7 @@ import {
 	formatBashDuration,
 	getLastBashOutputLine,
 } from "./bash-command";
+import { getUserSettingsPath } from "./settings-path";
 
 const RESET = "\x1b[0m";
 const TRANSPARENT_BG = "\x1b[49m";
@@ -167,7 +168,7 @@ function readSettings(): SettingsFile {
 		return _settingsCache.value;
 	}
 	const cwdPath = `${process.cwd()}/.pi/settings.json`;
-	const homePath = `${process.env.HOME ?? ""}/.pi/settings.json`;
+	const homePath = getUserSettingsPath();
 	const merged: SettingsFile = {};
 	for (const path of [cwdPath, homePath]) {
 		try {
@@ -195,9 +196,9 @@ function bustSpinnerSettingsCache(): void {
 function writeSettingsKey(key: string, value: unknown): void {
 	_settingsCache = null; // invalidate cache on write
 	const home = process.env.HOME ?? "";
-	if (!home) return;
-	const dir = `${home}/.pi`;
-	const path = `${dir}/settings.json`;
+	if (!home && !process.env.PI_CODING_AGENT_DIR) return;
+	const path = getUserSettingsPath();
+	const dir = dirname(path);
 	let settings: Record<string, unknown> = {};
 	try {
 		if (existsSync(path)) settings = JSON.parse(readFileSync(path, "utf8")) ?? {};
@@ -526,8 +527,8 @@ function getThinkingMode(): ThinkingMode {
 
 function isAssistantThinkingComplete(comp: any, message: any): boolean {
 	if (!message || message.role !== "assistant") return false;
-	if (typeof message[THINKING_DURATION_KEY] === "number") return true;
-	if (message[THINKING_ACTIVE_KEY]) return false;
+	if (getThinkingDurationMetadata(message) !== undefined) return true;
+	if (hasThinkingActiveMetadata(message)) return false;
 	// Providers keep stopReason "pending" for the whole stream ("deferred" while
 	// a deferred call is unresolved); both are in-flight sentinels, never
 	// completion signals. Without this, live-thinking detection would depend on
@@ -554,7 +555,7 @@ function isAssistantThinkingComplete(comp: any, message: any): boolean {
 function isLiveThinkingMessage(comp: any, message: any): boolean {
 	if (!message || message.role !== "assistant") return false;
 	if (isAssistantThinkingComplete(comp, message)) return false;
-	if ((message as any)[THINKING_ACTIVE_KEY]) return true;
+	if (hasThinkingActiveMetadata(message)) return true;
 	if (Array.isArray(message.content)) {
 		return message.content.some((b: any) => b?.type === "thinking" && typeof b?.thinking === "string" && b.thinking.trim());
 	}
@@ -1199,7 +1200,7 @@ function isThinkingOnlyAssistantComponent(comp: unknown): comp is InstanceType<t
 	if (hasText) return false;
 	const hasToolCalls = msg.content.some((c: any) => c?.type === "toolCall");
 	if (hasToolCalls) return false;
-	if ((comp as any).isStreaming === true || msg[THINKING_ACTIVE_KEY]) return false;
+	if ((comp as any).isStreaming === true || hasThinkingActiveMetadata(msg)) return false;
 	return true;
 }
 
@@ -1227,10 +1228,13 @@ function maybeMergeConsecutiveThinkingMessages(parent: any): void {
 			const mergedDuration = durA + durB;
 
 			const nextThinkingBlocks = nextMsg.content.filter((c: any) => c?.type === "thinking");
-			curMsg.content.push(...nextThinkingBlocks);
-			curMsg[THINKING_DURATION_KEY] = mergedDuration;
+			const mergedMessage = {
+				...curMsg,
+				content: [...curMsg.content, ...nextThinkingBlocks],
+				[THINKING_DURATION_KEY]: mergedDuration,
+			};
 
-			(current as any).updateContent(curMsg);
+			(current as any).updateContent(mergedMessage);
 
 			const removeCount = nextIdx - i;
 			children.splice(i + 1, removeCount);
@@ -1614,6 +1618,46 @@ const THINKING_DURATION_KEY = "_piClaudeStyleThinkingDurationMs";
 const THINKING_ACTIVE_KEY = "_piClaudeStyleThinkingActive";
 const MAX_REASONABLE_THINKING_DURATION_MS = 24 * 60 * 60 * 1000;
 
+// Presentation metadata belongs to the renderer, not the canonical session
+// messages. Weak collections keep live state available to the TUI without
+// changing the objects Pi persists or projects for compaction replay.
+const thinkingDurationByMessage = new WeakMap<object, number>();
+const thinkingActiveMessages = new WeakSet<object>();
+const workedStartByMessage = new WeakMap<object, number>();
+const workedDurationByMessage = new WeakMap<object, { duration: number; sessionTotal?: number; turns?: number }>();
+
+function getThinkingDurationMetadata(message: any): number | undefined {
+	if (!message || typeof message !== "object") return undefined;
+	const stored = thinkingDurationByMessage.get(message) ?? message[THINKING_DURATION_KEY];
+	return typeof stored === "number"
+		&& Number.isFinite(stored)
+		&& stored > 0
+		&& stored <= MAX_REASONABLE_THINKING_DURATION_MS
+		? stored
+		: undefined;
+}
+
+function hasThinkingActiveMetadata(message: any): boolean {
+	return !!message
+		&& typeof message === "object"
+		&& (thinkingActiveMessages.has(message) || message[THINKING_ACTIVE_KEY] === true);
+}
+
+function workedMetadataForMessage(message: any): { duration: number; sessionTotal?: number; turns?: number } | undefined {
+	if (!message || typeof message !== "object") return undefined;
+	const metadata = workedDurationByMessage.get(message);
+	if (metadata) return metadata;
+	const duration = message[WORKED_DURATION_KEY];
+	if (typeof duration !== "number" || !Number.isFinite(duration) || duration < 0) return undefined;
+	const sessionTotal = message[WORKED_SESSION_TOTAL_KEY];
+	const turns = message[WORKED_TURNS_KEY];
+	return {
+		duration,
+		sessionTotal: typeof sessionTotal === "number" ? sessionTotal : undefined,
+		turns: typeof turns === "number" ? turns : undefined,
+	};
+}
+
 let thinkingBlockStartMs = 0;
 /** True from thinking_start until thinking_end on the current assistant stream. */
 let thinkingBlockInFlight = false;
@@ -1757,9 +1801,8 @@ class HiddenThinkingSummary {
 }
 
 function getMessageThinkingDurationMs(message: any): number {
-	const stored = (message as any)?.[THINKING_DURATION_KEY];
-	if (typeof stored === "number" && Number.isFinite(stored) && stored > 0 && stored <= MAX_REASONABLE_THINKING_DURATION_MS) return stored;
-	if (message && typeof message === "object" && stored !== undefined) delete (message as any)[THINKING_DURATION_KEY];
+	const stored = getThinkingDurationMetadata(message);
+	if (stored !== undefined) return stored;
 	let totalChars = 0;
 	if (Array.isArray(message?.content)) {
 		for (const block of message.content) {
@@ -1780,9 +1823,6 @@ function hiddenThinkingSummaryForMessage(message: any, comp?: any): string {
 		return thinkingActiveSummaryText();
 	}
 	const durationMs = getMessageThinkingDurationMs(message);
-	if (message && typeof message === "object") {
-		(message as any)[THINKING_DURATION_KEY] = durationMs;
-	}
 	return thoughtDurationSummaryText(durationMs);
 }
 
@@ -1963,13 +2003,20 @@ function patchTerminalWriteTagScrubber(): void {
 
 function replaceInlineMath(text: string): string {
 	if (!hasInlineMathMarkers(text)) return text;
-	const withParens = text.replace(/\\\(([\s\S]*?)\\\)/g, (_match, body: string) => {
-		return codeSpan(formatMathForDisplay(body, false));
-	});
-	return withParens.replace(/(^|[^\\])\$([^\n$]{1,200})\$/g, (match, prefix: string, body: string) => {
-		if (!looksLikeInlineMath(body)) return match;
-		return `${prefix}${codeSpan(formatMathForDisplay(body, false))}`;
-	});
+	const transform = (segment: string): string => {
+		const withParens = segment.replace(/\\\(([\s\S]*?)\\\)/g, (_match, body: string) => {
+			return codeSpan(formatMathForDisplay(body, false));
+		});
+		return withParens.replace(/(^|[^\\])\$([^\n$]{1,200})\$/g, (match, prefix: string, body: string) => {
+			if (!looksLikeInlineMath(body)) return match;
+			return `${prefix}${codeSpan(formatMathForDisplay(body, false))}`;
+		});
+	};
+	// Markdown code spans and fenced blocks are literal source. Apply math
+	// formatting only to prose segments so shell variables such as `$base` and
+	// `$scope` remain byte-for-byte unchanged in displayed/copied commands.
+	const parts = text.split(/(`{3,}[\s\S]*?`{3,}|`[^`\n]*`)/g);
+	return parts.map((part, index) => index % 2 === 1 ? part : transform(part)).join("");
 }
 
 interface MathBlock {
@@ -2058,16 +2105,30 @@ function shouldFormatStandaloneMath(text: string): boolean {
 	return !/[.!?]\s/.test(plain) && plain.length <= 240;
 }
 
-function appendMarkdownSegment(segments: ParagraphSegment[], text: string, theme: MarkdownThemeLike): void {
+// Options Pi hands to the Markdown components it builds, including the markdown
+// transformers (Pi's own Mermaid renderer, extension transformers, ...). Paragraph
+// wrappers rebuild those components, so they have to forward the options.
+type MarkdownOptions = ConstructorParameters<typeof Markdown>[5]
+
+function appendMarkdownSegment(
+	segments: ParagraphSegment[],
+	text: string,
+	theme: MarkdownThemeLike,
+	options?: MarkdownOptions,
+): void {
 	if (!text.trim()) return;
 	const normalized = shouldFormatStandaloneMath(text) ? formatMathForDisplay(text, false) : replaceInlineMath(text);
-	segments.push({ kind: "markdown", md: new Markdown(normalized, 0, 0, theme) });
+	segments.push({ kind: "markdown", md: new Markdown(normalized, 0, 0, theme, undefined, options) });
 }
 
-function buildParagraphSegments(text: string, theme: MarkdownThemeLike): ParagraphSegment[] {
+function buildParagraphSegments(
+	text: string,
+	theme: MarkdownThemeLike,
+	options?: MarkdownOptions,
+): ParagraphSegment[] {
 	const segments: ParagraphSegment[] = [];
 	if (!hasDisplayMathMarkers(text)) {
-		appendMarkdownSegment(segments, text, theme);
+		appendMarkdownSegment(segments, text, theme, options);
 		return segments;
 	}
 	const scanLoose = shouldScanLooseBracketMath(text);
@@ -2075,12 +2136,12 @@ function buildParagraphSegments(text: string, theme: MarkdownThemeLike): Paragra
 	while (cursor < text.length) {
 		const next = findNextDisplayMathBlock(text, cursor, scanLoose);
 		if (!next) break;
-		appendMarkdownSegment(segments, text.slice(cursor, next.index), theme);
+		appendMarkdownSegment(segments, text.slice(cursor, next.index), theme, options);
 		const raw = text.slice(next.contentStart, next.contentEnd).trim();
 		if (raw) segments.push({ kind: "math", raw });
 		cursor = next.endIndex;
 	}
-	appendMarkdownSegment(segments, text.slice(cursor), theme);
+	appendMarkdownSegment(segments, text.slice(cursor), theme, options);
 	return segments;
 }
 
@@ -2167,9 +2228,9 @@ class DottedParagraph {
 	private cachedWidth?: number;
 	private cachedLines?: string[];
 
-	constructor(text: string, markdownTheme: MarkdownThemeLike) {
+	constructor(text: string, markdownTheme: MarkdownThemeLike, options?: MarkdownOptions) {
 		this.markdownTheme = copySafeMarkdownTheme(markdownTheme);
-		this.segments = buildParagraphSegments(stripTransientMagicContextTags(text), this.markdownTheme);
+		this.segments = buildParagraphSegments(stripTransientMagicContextTags(text), this.markdownTheme, options);
 	}
 
 	invalidate(): void {
@@ -2263,6 +2324,7 @@ class ThinkingParagraph {
 	private cachedLines?: string[];
 	private cachedHovered = false;
 	private chromeEpoch = -1;
+	private options?: MarkdownOptions;
 
 	setHovered(hovered: boolean): void {
 		if (this.hovered === hovered) return;
@@ -2274,8 +2336,12 @@ class ThinkingParagraph {
 		text: string,
 		_markdownTheme: ConstructorParameters<typeof Markdown>[3],
 		_defaultTextStyle?: ConstructorParameters<typeof Markdown>[4],
+		options?: MarkdownOptions,
 	) {
-		this.text = stripTransientMagicContextTags(text);
+		// Prefix only the renderer's private copy. The assistant message itself is
+		// canonical session data and must remain untouched for compaction replay.
+		this.text = prefixThinkingLine(stripTransientMagicContextTags(text), undefined);
+		this.options = options;
 	}
 
 	private thinkingMarkdown(): InstanceType<typeof Markdown> {
@@ -2303,7 +2369,7 @@ class ThinkingParagraph {
 			italic: false,
 			color: (s: string) => `${DIM_FG}${s}`,
 		};
-		return new Markdown(this.text, 0, 0, plainTheme, plainStyle);
+		return new Markdown(this.text, 0, 0, plainTheme, plainStyle, this.options);
 	}
 
 	invalidate(): void {
@@ -2667,17 +2733,18 @@ function patchAssistantMessages(): void {
 			if (isMarkdownComponent(inner)) {
 				const text = (inner as any).text;
 				if (!text) continue;
+				const options = (inner as any).options as MarkdownOptions;
 				const isThinking = !!(inner as any).defaultTextStyle?.italic;
 				if (isThinking) {
 					const style = (inner as any).defaultTextStyle;
-					const replacement = new ThinkingParagraph(text, mdTheme, style);
+					const replacement = new ThinkingParagraph(text, mdTheme, style, options);
 					if ((child as any)?.child !== undefined) {
 						(child as any).child = replacement;
 					} else {
 						container.children[i] = replacement;
 					}
 				} else {
-					const replacement = new DottedParagraph(text, mdTheme);
+					const replacement = new DottedParagraph(text, mdTheme, options);
 					if ((child as any)?.child !== undefined) {
 						(child as any).child = replacement;
 					} else {
@@ -2686,9 +2753,10 @@ function patchAssistantMessages(): void {
 				}
 			}
 		}
-		const explicitDuration = (message as any)[WORKED_DURATION_KEY];
-		const explicitSessionTotal = (message as any)[WORKED_SESSION_TOTAL_KEY];
-		const explicitTurns = (message as any)[WORKED_TURNS_KEY];
+		const workedMetadata = workedMetadataForMessage(message);
+		const explicitDuration = workedMetadata?.duration;
+		const explicitSessionTotal = workedMetadata?.sessionTotal;
+		const explicitTurns = workedMetadata?.turns;
 		// The "Turn took" line must only appear once the stream has truly closed.
 		// `message.stopReason === "stop"` is not a safe "finished" signal here because
 		// providers may initialize a live message with that value. The `message_end`
@@ -3775,6 +3843,10 @@ function bashCollapsedLimit(): number {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 10;
 }
 
+function bashOutputMode(): "opencode" | "summary" | "preview" {
+	return getMode(readSettings().bashOutputMode, ["opencode", "summary", "preview"] as const, "opencode");
+}
+
 function bashCommandPreviewLimit(): number {
 	const value = readSettings().bashCommandPreviewLines;
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 8;
@@ -5585,8 +5657,8 @@ function trackThinkingBlockEvents(event: any, ctx?: any): void {
 		thinkingBlockInFlight = true;
 		thinkingBlockStartMs = Date.now();
 		if (message?.role === "assistant") {
-			(message as any)[THINKING_ACTIVE_KEY] = true;
-			delete (message as any)[THINKING_DURATION_KEY];
+			thinkingActiveMessages.add(message);
+			thinkingDurationByMessage.delete(message);
 		}
 		refreshThinkingChrome();
 		return;
@@ -5596,9 +5668,9 @@ function trackThinkingBlockEvents(event: any, ctx?: any): void {
 		const duration = thinkingBlockStartMs > 0
 			? Math.max(0, Date.now() - thinkingBlockStartMs)
 			: undefined;
-		if (message?.role === "assistant") delete (message as any)[THINKING_ACTIVE_KEY];
-		if (typeof duration === "number" && duration <= MAX_REASONABLE_THINKING_DURATION_MS) {
-			if (message?.role === "assistant") (message as any)[THINKING_DURATION_KEY] = duration;
+		if (message?.role === "assistant") thinkingActiveMessages.delete(message);
+		if (typeof duration === "number" && duration <= MAX_REASONABLE_THINKING_DURATION_MS && message?.role === "assistant") {
+			thinkingDurationByMessage.set(message, duration);
 		}
 		thinkingBlockStartMs = 0;
 		refreshThinkingChrome();
@@ -5610,13 +5682,13 @@ function trackThinkingBlockEvents(event: any, ctx?: any): void {
 	// run normally. Any non-thinking stream event on the same assistant message
 	// means thinking is no longer the live activity: freeze the elapsed time into
 	// a "Thought for Xs" duration so the row always resolves.
-	if ((message as any)?.[THINKING_ACTIVE_KEY] || thinkingBlockInFlight) {
+	if (hasThinkingActiveMetadata(message) || thinkingBlockInFlight) {
 		if (evt.type === "text_start" || evt.type === "text_delta" || evt.type === "toolcall_start" || evt.type === "toolcall_end") {
 			thinkingBlockInFlight = false;
 			const duration = thinkingBlockStartMs > 0 ? Math.max(0, Date.now() - thinkingBlockStartMs) : undefined;
-			if (message?.role === "assistant") delete (message as any)[THINKING_ACTIVE_KEY];
-			if (typeof duration === "number" && duration <= MAX_REASONABLE_THINKING_DURATION_MS) {
-				if (message?.role === "assistant") (message as any)[THINKING_DURATION_KEY] = duration;
+			if (message?.role === "assistant") thinkingActiveMessages.delete(message);
+			if (typeof duration === "number" && duration <= MAX_REASONABLE_THINKING_DURATION_MS && message?.role === "assistant") {
+				thinkingDurationByMessage.set(message, duration);
 			}
 			thinkingBlockStartMs = 0;
 			refreshThinkingChrome();
@@ -5631,11 +5703,9 @@ function registerThinkingLabels(pi: ExtensionAPI): void {
 		if (theme) applyThemePaletteIfNeeded(theme);
 		const message = event?.message;
 		if (!message || message.role !== "assistant" || !Array.isArray(message.content)) return;
-		for (const block of message.content) {
-			if (block && block.type === "thinking" && typeof block.thinking === "string") {
-				block.thinking = prefixThinkingLine(block.thinking, theme);
-			}
-		}
+		// Thinking labels are applied by ThinkingParagraph while rendering. Never
+		// rewrite the assistant message object: context/compaction consumers need
+		// its canonical thinking content unchanged.
 	};
 	pi.on("before_agent_start", async () => {
 		// Start once per top-level request. Steering/follow-up messages can be
@@ -5661,14 +5731,14 @@ function registerThinkingLabels(pi: ExtensionAPI): void {
 		}
 		if (message?.role === "assistant") {
 			currentAssistantMessageStartMs = Date.now();
-			(message as any)[WORKED_START_KEY] = currentAssistantMessageStartMs;
+			workedStartByMessage.set(message, currentAssistantMessageStartMs);
 			// A new assistant message starts a fresh thinking lifecycle. Without
 			// this, a missing thinking_end on the previous message leaves the
 			// global in-flight flag set and the next message renders a stale
 			// "Thinking..." row until its own thinking events arrive.
 			thinkingBlockInFlight = false;
 			thinkingBlockStartMs = 0;
-			delete (message as any)[THINKING_ACTIVE_KEY];
+			thinkingActiveMessages.delete(message);
 		}
 	});
 	pi.on("message_update", async (event, ctx) => {
@@ -5683,27 +5753,22 @@ function registerThinkingLabels(pi: ExtensionAPI): void {
 			// into its "Thought for Xs" duration here so the row always resolves
 			// at the end of the message instead of sticking into later calls.
 			thinkingBlockInFlight = false;
-			delete (message as any)[THINKING_ACTIVE_KEY];
-			if (typeof (message as any)[THINKING_DURATION_KEY] !== "number" && thinkingBlockStartMs > 0) {
+			thinkingActiveMessages.delete(message);
+			if (getThinkingDurationMetadata(message) === undefined && thinkingBlockStartMs > 0) {
 				const duration = Math.max(0, Date.now() - thinkingBlockStartMs);
-				if (duration <= MAX_REASONABLE_THINKING_DURATION_MS) {
-					(message as any)[THINKING_DURATION_KEY] = duration;
-				}
+				if (duration <= MAX_REASONABLE_THINKING_DURATION_MS) thinkingDurationByMessage.set(message, duration);
 			}
 			thinkingBlockStartMs = 0;
 			const started = typeof currentAgentWorkStartMs === "number"
 				? currentAgentWorkStartMs
-				: typeof (message as any)[WORKED_START_KEY] === "number"
-					? (message as any)[WORKED_START_KEY]
-					: currentAssistantMessageStartMs;
+				: workedStartByMessage.get(message)
+					?? (typeof (message as any)[WORKED_START_KEY] === "number" ? (message as any)[WORKED_START_KEY] : currentAssistantMessageStartMs);
 			const isFinalAssistantMessage = message.stopReason === "stop";
 			if (started !== undefined && isFinalAssistantMessage) {
 				const durationMs = Date.now() - started;
 				const sessionTotalMs = typeof sessionStartMs === "number" ? Date.now() - sessionStartMs : undefined;
 				const turns = userTurnCount > 0 ? userTurnCount : undefined;
-				(message as any)[WORKED_DURATION_KEY] = durationMs;
-				if (typeof sessionTotalMs === "number") (message as any)[WORKED_SESSION_TOTAL_KEY] = sessionTotalMs;
-				if (typeof turns === "number") (message as any)[WORKED_TURNS_KEY] = turns;
+				workedDurationByMessage.set(message, { duration: durationMs, sessionTotal: sessionTotalMs, turns });
 				// Duration metadata drives the assistant component's TUI-only status line.
 				// Message content stays presentation-neutral for persistence and consumers.
 			}
@@ -5751,17 +5816,10 @@ function registerThinkingLabels(pi: ExtensionAPI): void {
 			sessionStartMs = sessionStartMs === undefined ? earliest : Math.min(sessionStartMs, earliest);
 		}
 		if (userCount > userTurnCount) userTurnCount = userCount;
-		for (const msg of messages) {
-			if (!msg || msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-			for (const block of msg.content) {
-				if (block && block.type === "thinking" && typeof block.thinking === "string") {
-					block.thinking = stripThinkingPresentationArtifacts(block.thinking);
-				}
-				if (block && block.type === "text" && typeof block.text === "string") {
-					block.text = stripWorkedDurationLine(block.text);
-				}
-			}
-		}
+		// Do not normalize or strip message content here. The context event is also
+		// consumed by compaction/replay integrations that compare these objects
+		// against the persisted session projection. Presentation cleanup belongs in
+		// the renderer and must not mutate canonical history.
 	});
 }
 
@@ -7184,6 +7242,8 @@ export default function (pi: ExtensionAPI) {
 		name: "read",
 		label: "read",
 		description: readTool.description,
+		promptSnippet: (readTool as any).promptSnippet,
+		promptGuidelines: (readTool as any).promptGuidelines,
 		parameters: readTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return readTool.execute(toolCallId, params, signal, onUpdate);
@@ -7239,6 +7299,8 @@ export default function (pi: ExtensionAPI) {
 		name: "bash",
 		label: "bash",
 		description: bashTool.description,
+		promptSnippet: (bashTool as any).promptSnippet,
+		promptGuidelines: (bashTool as any).promptGuidelines,
 		parameters: bashTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return bashTool.execute(toolCallId, params, signal, onUpdate);
@@ -7296,9 +7358,18 @@ export default function (pi: ExtensionAPI) {
 			let text = exitCode === null || exitCode === 0 ? theme.fg("success", "Done") : theme.fg("error", `Exit ${exitCode}`);
 			text += theme.fg("muted", ` (${nonEmpty.total} lines)`);
 			if (details?.truncation?.truncated) text += theme.fg("warning", " [truncated]");
+			const mode = bashOutputMode();
+			if (mode === "summary") return makeText(ctx.lastComponent, withBranch(text, theme));
 			const persistentPreview = shouldPreserveBashPreview(ctx) ? buildPersistentBashPreview(nonEmpty.lines, theme) : "";
-			if (!expanded && persistentPreview) return makeText(ctx.lastComponent, withBranch(`${text}${toolOutputDetailHint(theme, expanded)}\n${persistentPreview}`, theme));
-			if (!expanded && nonEmpty.total > 0) return makeText(ctx.lastComponent, withBranch(`${text}${toolOutputDetailHint(theme, expanded)}`, theme));
+			if (!expanded && mode === "preview") {
+				const previewLines = nonEmpty.lines.slice(0, bashCollapsedLimit());
+				const preview = previewLines.length > 0
+					? buildPreviewText(previewLines, false, theme, bashCollapsedLimit(), nonEmpty.total, (line) => theme.fg("dim", line || " "))
+					: "";
+				const suffix = toolOutputDetailHint(theme, expanded);
+				return makeText(ctx.lastComponent, withBranch(`${text}${suffix}${preview ? `\n${preview}` : ""}`, theme));
+			}
+			if (!expanded && mode === "opencode" && nonEmpty.total > 0) return makeText(ctx.lastComponent, withBranch(`${text}${toolOutputDetailHint(theme, expanded)}`, theme));
 			if (!expanded) return makeText(ctx.lastComponent, withBranch(text, theme));
 			const collapsed = bashCollapsedLimit();
 			if (rewrite) text += `\n${formatRtkRewriteDetails(rewrite, theme)}`;
@@ -7312,6 +7383,8 @@ export default function (pi: ExtensionAPI) {
 		name: "grep",
 		label: "grep",
 		description: grepTool.description,
+		promptSnippet: (grepTool as any).promptSnippet,
+		promptGuidelines: (grepTool as any).promptGuidelines,
 		parameters: grepTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return grepTool.execute(toolCallId, params, signal, onUpdate);
@@ -7352,6 +7425,8 @@ export default function (pi: ExtensionAPI) {
 		name: "find",
 		label: "find",
 		description: findTool.description,
+		promptSnippet: (findTool as any).promptSnippet,
+		promptGuidelines: (findTool as any).promptGuidelines,
 		parameters: findTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return findTool.execute(toolCallId, params, signal, onUpdate);
@@ -7403,6 +7478,8 @@ export default function (pi: ExtensionAPI) {
 		name: "ls",
 		label: "ls",
 		description: lsTool.description,
+		promptSnippet: (lsTool as any).promptSnippet,
+		promptGuidelines: (lsTool as any).promptGuidelines,
 		parameters: lsTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate) {
 			return lsTool.execute(toolCallId, params, signal, onUpdate);
@@ -7454,6 +7531,8 @@ export default function (pi: ExtensionAPI) {
 		name: "write",
 		label: "write",
 		description: writeTool.description,
+		promptSnippet: (writeTool as any).promptSnippet,
+		promptGuidelines: (writeTool as any).promptGuidelines,
 		parameters: writeTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate, _ctx) {
 			const fp = params.path ?? (params as any).file_path ?? "";
@@ -7569,6 +7648,8 @@ export default function (pi: ExtensionAPI) {
 		name: "edit",
 		label: "edit",
 		description: editTool.description,
+		promptSnippet: (editTool as any).promptSnippet,
+		promptGuidelines: (editTool as any).promptGuidelines,
 		parameters: editTool.parameters,
 		async execute(toolCallId, params, signal, onUpdate, _ctx) {
 			const fp = params.path ?? (params as any).file_path ?? "";

package/extensions/settings-path.ts

@@ -0,0 +1,4 @@
+export function getUserSettingsPath(): string {
+	const agentDir = process.env.PI_CODING_AGENT_DIR || `${process.env.HOME ?? ""}/.pi`;
+	return `${agentDir}/settings.json`;
+}

package/extensions/spinner.ts

@@ -1,9 +1,13 @@
 import { existsSync, readFileSync } from "node:fs";
 import net from "node:net";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Loader } from "@earendil-works/pi-tui";
 
+import { getUserSettingsPath } from "./settings-path";
+
 // ---------------------------------------------------------------------------
 // Patch built-in Loader with Claude/OpenBrawd-style glyphs.
 // Keep animation cadence constant so the spinner doesn't appear to slow down
@@ -44,7 +48,7 @@ function readSpinnerSettings(): { adaptive: boolean; verbColor: string; statusCo
 	// orange as the glyph on themes like openAntigravity-dark.
 	let verbColor = "borderAccent";
 	let statusColor = "muted";
-	const paths = [`${process.cwd()}/.pi/settings.json`, `${process.env.HOME ?? ""}/.pi/settings.json`];
+	const paths = [`${process.cwd()}/.pi/settings.json`, getUserSettingsPath()];
 	for (const p of paths) {
 		try {
 			if (!p || !existsSync(p)) continue;
@@ -517,7 +521,9 @@ function statusText(text: string): string {
 // This extension replaces that text with themed spinner verbs (Cooking…,
 // Syncing…, …), so herdr sidebars go idle/stale while pi is actually busy.
 // When running inside herdr (HERDR_ENV=1), report working/idle over the
-// socket the same way herdr's official pi integration does. UI is unchanged.
+// socket only when herdr's official pi integration is not installed. The
+// official integration owns the same lifecycle authority and must remain the
+// sole reporter when present. UI is unchanged.
 // ---------------------------------------------------------------------------
 
 type HerdrAgentState = "working" | "idle";
@@ -532,9 +538,33 @@ const HERDR_PANE_ID = process.env.HERDR_PANE_ID;
 // Must be exactly "herdr:pi" — herdr only grants full lifecycle authority
 // (skip screen-manifest fallback) to that official source pair with agent "pi".
 const HERDR_SOURCE = "herdr:pi";
+const HERDR_INTEGRATION_MARKER = "HERDR_INTEGRATION_ID=pi";
+let officialHerdrIntegrationInstalled: boolean | undefined;
+
+function hasOfficialHerdrIntegration(): boolean {
+	if (officialHerdrIntegrationInstalled !== undefined) {
+		return officialHerdrIntegrationInstalled;
+	}
+
+	const agentDir = process.env.PI_CODING_AGENT_DIR
+		|| join(homedir(), ".pi", "agent");
+
+	try {
+		const integrationPath = join(agentDir, "extensions", "herdr-agent-state.ts");
+		officialHerdrIntegrationInstalled =
+			existsSync(integrationPath)
+			&& readFileSync(integrationPath, "utf8").includes(HERDR_INTEGRATION_MARKER);
+	} catch {
+		officialHerdrIntegrationInstalled = false;
+	}
+	return officialHerdrIntegrationInstalled;
+}
 
 function herdrEnabled(): boolean {
-	return HERDR_ENV === "1" && !!HERDR_SOCKET_PATH && !!HERDR_PANE_ID;
+	return HERDR_ENV === "1"
+		&& !!HERDR_SOCKET_PATH
+		&& !!HERDR_PANE_ID
+		&& !hasOfficialHerdrIntegration();
 }
 
 function herdrSendAttempt(request: unknown, timeoutMs: number): Promise<boolean> {
@@ -754,7 +784,12 @@ export default function (pi: ExtensionAPI) {
 	}
 
 	function syncWorkingMessage(force = false): void {
-		if (!activeCtx?.hasUI) return;
+		try {
+			if (!activeCtx?.hasUI) return;
+		} catch {
+			// Session replacement/reload invalidated the captured context.
+			return;
+		}
 		// Re-derive colors on every tick so /cc-spinner verb/status changes
 		// take effect within ~250 ms without waiting for the next pi event.
 		// applyThemeColors is identity-cached on (theme, verbKey, statusKey) so
@@ -770,7 +805,12 @@ export default function (pi: ExtensionAPI) {
 
 	function restoreDefaultWorkingMessage(): void {
 		lastWorkingMessage = null;
-		if (!activeCtx?.hasUI) return;
+		try {
+			if (!activeCtx?.hasUI) return;
+		} catch {
+			// Session replacement/reload invalidated the captured context.
+			return;
+		}
 		try {
 			activeCtx.ui.setWorkingMessage();
 		} catch { /* noop */ }
@@ -1002,20 +1042,25 @@ export default function (pi: ExtensionAPI) {
 			clearThoughtStatusTimer();
 		}
 
-		if (activeCtx?.hasUI) {
-			const message = `${STATUS_DIM}✻ Turn took ${formatDuration(elapsed)}${RESET}`;
-			lastWorkingMessage = message;
-			try {
-				activeCtx.ui.setWorkingMessage(message);
-			} catch { /* noop */ }
-			completionTimer = setTimeout(() => {
-				completionTimer = null;
-				if (activeTurnId !== turnId) return;
+		try {
+			if (activeCtx?.hasUI) {
+				const message = `${STATUS_DIM}✻ Turn took ${formatDuration(elapsed)}${RESET}`;
+				lastWorkingMessage = message;
+				try {
+					activeCtx.ui.setWorkingMessage(message);
+				} catch { /* noop */ }
+				completionTimer = setTimeout(() => {
+					completionTimer = null;
+					if (activeTurnId !== turnId) return;
+					restoreDefaultWorkingMessage();
+				}, TURN_COMPLETION_MS);
+				unrefTimer(completionTimer);
+			} else if (typeof thinkingStatus !== "number") {
 				restoreDefaultWorkingMessage();
-			}, TURN_COMPLETION_MS);
-			unrefTimer(completionTimer);
-		} else if (typeof thinkingStatus !== "number") {
-			restoreDefaultWorkingMessage();
+			}
+		} catch {
+			// Session replacement/reload invalidated the captured context.
+			return;
 		}
 
 		responseLength = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-claude-code-ui",
-  "version": "1.0.84",
+  "version": "1.0.85",
   "description": "Claude Code-style grouped tool rows for pi with Ctrl+O/Ctrl+Shift+O previews, math rendering, and consistent built-in, MCP, and custom tool rendering",
   "keywords": [
     "pi-package",
@@ -30,13 +30,14 @@
   "files": [
     "extensions/index.ts",
     "extensions/spinner.ts",
+    "extensions/settings-path.ts",
     "extensions/bash-command.ts",
     "config/config.example.json",
     "README.md",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "node --experimental-strip-types --test scripts/bash-command.test.ts",
+    "test": "node --experimental-strip-types --test scripts/*.test.ts",
     "test:fullscreen": "node scripts/fullscreen-mouse.test.mjs",
     "typecheck": "tsc --noEmit --target ES2022 --module NodeNext --moduleResolution NodeNext --skipLibCheck extensions/index.ts extensions/spinner.ts",
     "pack:dry-run": "npm pack --dry-run",