@oh-my-pi/pi-coding-agent 16.0.11 → 16.1.0

package/src/session/messages.ts

@@ -204,16 +204,14 @@ function wrapSteeringUserMessage(message: UserMessage): UserMessage {
 }
 
 export function wrapSteeringForModel(messages: AgentMessage[]): AgentMessage[] {
-	const last = messages[messages.length - 1];
-	if (!isSteeringUserMessage(last)) return messages;
-
-	let firstSteer = messages.length - 1;
-	while (firstSteer > 0 && isSteeringUserMessage(messages[firstSteer - 1])) {
-		firstSteer--;
-	}
-
+	// Wrap EVERY steering message, not just a trailing run. The wire bytes of a
+	// steering message must be a pure function of the message itself, independent
+	// of its position in the array. When only the trailing steer was wrapped, the
+	// same persisted message was sent enveloped while it was the tail and raw once
+	// the assistant's reply buried it — rewriting already-cached prefix bytes and
+	// busting the provider prompt cache from that message onward on the next turn.
 	let wrappedMessages: AgentMessage[] | undefined;
-	for (let i = firstSteer; i < messages.length; i++) {
+	for (let i = 0; i < messages.length; i++) {
 		const message = messages[i];
 		if (!isSteeringUserMessage(message)) continue;
 		const wrappedMessage = wrapSteeringUserMessage(message);

package/src/session/session-context.ts

@@ -20,6 +20,13 @@ export interface SessionContext {
 	mode: string;
 	/** Mode-specific data from the last mode_change entry */
 	modeData?: Record<string, unknown>;
+	/**
+	 * Array parallel to messages, indicating which assistant turns should
+	 * have their prompt-cache misses suppressed/explained (because a model,
+	 * compaction, or plan-mode transition directly preceded them).
+	 * Only populated in transcript mode.
+	 */
+	cacheMissExplainedAt?: boolean[];
 }
 
 /** Lists session model strings to try when restoring, in fallback order. */
@@ -191,12 +198,45 @@ export function buildSessionContext(
 	// 2. Emit kept messages (from firstKeptEntryId up to compaction)
 	// 3. Emit messages after compaction
 	const messages: AgentMessage[] = [];
+	const cacheMissExplainedAt: boolean[] = [];
+	let pendingReset = false;
+	let currentMode = "none";
+	let lastAssistantModel: string | undefined;
+
+	const handleEntryResetTracking = (entry: SessionEntry) => {
+		if (entry.type === "compaction") {
+			pendingReset = true;
+		} else if (entry.type === "model_change") {
+			pendingReset = true;
+		} else if (entry.type === "mode_change") {
+			const isPlanTransition = (entry.mode === "plan") !== (currentMode === "plan");
+			if (isPlanTransition) {
+				pendingReset = true;
+			}
+			currentMode = entry.mode;
+		}
+	};
+
+	const pushMessage = (msg: AgentMessage) => {
+		messages.push(msg);
+		if (!options?.transcript) return;
+		if (msg.role === "assistant") {
+			const currentModel = `${msg.provider}/${msg.model}`;
+			const modelChanged = lastAssistantModel !== undefined && lastAssistantModel !== currentModel;
+			lastAssistantModel = currentModel;
+			cacheMissExplainedAt.push(pendingReset || modelChanged);
+			pendingReset = false;
+		} else {
+			cacheMissExplainedAt.push(false);
+		}
+	};
 
 	const appendMessage = (entry: SessionEntry) => {
+		handleEntryResetTracking(entry);
 		if (entry.type === "message") {
-			messages.push(entry.message);
+			pushMessage(entry.message);
 		} else if (entry.type === "custom_message") {
-			messages.push(
+			pushMessage(
 				createCustomMessage(
 					entry.customType,
 					entry.content,
@@ -207,7 +247,7 @@ export function buildSessionContext(
 				),
 			);
 		} else if (entry.type === "branch_summary" && entry.summary) {
-			messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
+			pushMessage(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
 		}
 	};
 
@@ -217,16 +257,18 @@ export function buildSessionContext(
 		// TUI) at the point it fired, with any snapcompact frames re-attached so
 		// the component can report them.
 		for (const entry of path) {
+			handleEntryResetTracking(entry);
 			if (entry.type === "compaction") {
 				const snapcompactArchive = snapcompact.getPreservedArchive(entry.preserveData);
-				messages.push(
+				pushMessage(
 					createCompactionSummaryMessage(
 						entry.summary,
 						entry.tokensBefore,
 						entry.timestamp,
 						entry.shortSummary,
 						undefined,
-						snapcompactArchive ? snapcompact.images(snapcompactArchive) : undefined,
+						undefined,
+						snapcompactArchive ? snapcompact.historyBlocks(snapcompactArchive) : undefined,
 					),
 				);
 			} else {
@@ -251,14 +293,15 @@ export function buildSessionContext(
 		// Emit summary first; re-attach any archived snapcompact frames so the
 		// model can keep reading the archived history after every context rebuild.
 		const snapcompactArchive = snapcompact.getPreservedArchive(compaction.preserveData);
-		messages.push(
+		pushMessage(
 			createCompactionSummaryMessage(
 				compaction.summary,
 				compaction.tokensBefore,
 				compaction.timestamp,
 				compaction.shortSummary,
 				providerPayload,
-				snapcompactArchive ? snapcompact.images(snapcompactArchive) : undefined,
+				undefined,
+				snapcompactArchive ? snapcompact.historyBlocks(snapcompactArchive) : undefined,
 			),
 		);
 
@@ -333,6 +376,9 @@ export function buildSessionContext(
 			);
 		if (normalized.length === 0) {
 			messages.splice(i, 1);
+			if (options?.transcript) {
+				cacheMissExplainedAt.splice(i, 1);
+			}
 		} else {
 			messages[i] = { ...message, content: normalized };
 		}
@@ -340,6 +386,7 @@ export function buildSessionContext(
 
 	return {
 		messages,
+		cacheMissExplainedAt: options?.transcript ? cacheMissExplainedAt : undefined,
 		thinkingLevel,
 		serviceTier,
 		models,

package/src/session/session-dump-format.ts

@@ -38,6 +38,7 @@ export interface FormatSessionDumpTextOptions {
 	model?: Model | null;
 	thinkingLevel?: ThinkingLevel | string | null;
 	tools?: readonly SessionDumpToolInfo[];
+	inlineToolDescriptors?: boolean;
 }
 
 interface InventoryTool {
@@ -78,7 +79,8 @@ function renderDumpHeader(options: FormatSessionDumpTextOptions, inventoryTools:
 	lines.push(`Thinking Level: ${options.thinkingLevel ?? ""}`);
 	lines.push("\n");
 
-	if (inventoryTools.length > 0) {
+	const hasSystemPromptToolInventory = options.inlineToolDescriptors === true;
+	if (inventoryTools.length > 0 && !hasSystemPromptToolInventory) {
 		lines.push("## Available Tools\n");
 		lines.push(renderToolInventory(inventoryTools, model?.id ?? ""));
 		lines.push("\n");

package/src/session/snapcompact-inline.ts

@@ -46,8 +46,8 @@ export type SnapcompactSavingsSink = (
 // Per-provider image-count budgets live in @oh-my-pi/snapcompact
 // (`providerImageBudget`): snapcompact frames are 1568px (<2000px) so
 // dimension/size limits never bind; only COUNT does. Once the budget is
-// spent (e.g. OpenRouter's hard 8-image cap, already consumed by archive
-// frames), tool results ship verbatim as text.
+// spent by already-attached archive/system-prompt images, tool results ship
+// verbatim as text.
 const MAX_SYSTEM_PROMPT_FRAMES = 6;
 /** Tool results under this many tokens are never rasterized — the swap can't
  *  save enough to justify trading crisp text for an image. */

package/src/session/tool-choice-queue.ts

@@ -65,6 +65,20 @@ interface InFlight {
 	invoked: boolean;
 }
 
+/**
+ * A non-forcing pending preview invoker. Registered by `queueResolveHandler`
+ * (resolve previews) so the `resolve` tool can dispatch to a staged action
+ * WITHOUT this queue forcing `tool_choice`. The agent-loop's
+ * SoftToolRequirement lifecycle (remind-then-escalate) owns any forcing.
+ */
+interface PendingInvoker {
+	/** Unique id for this staged preview; never reused (never clobbered by label). */
+	id: string;
+	/** Source tool that staged the preview (e.g. "ast_edit"), for the reminder. */
+	sourceToolName: string;
+	onInvoked: (input: unknown) => Promise<unknown> | unknown;
+}
+
 // ── Queue ───────────────────────────────────────────────────────────────────
 
 export class ToolChoiceQueue {
@@ -75,6 +89,12 @@ export class ToolChoiceQueue {
 	 * Consumers (e.g. todo reminder suppression) read via consumeLastServedLabel().
 	 */
 	#lastResolvedLabel: string | undefined;
+	/**
+	 * Non-forcing pending preview invokers, stacked by UNIQUE id. The `resolve`
+	 * tool dispatches to the head; the agent-loop's soft-tool-requirement
+	 * lifecycle drives resolution without this queue forcing `tool_choice`.
+	 */
+	#pendingInvokers: PendingInvoker[] = [];
 
 	// ── Push ──────────────────────────────────────────────────────────────
 
@@ -190,6 +210,44 @@ export class ToolChoiceQueue {
 		};
 	}
 
+	// ── Non-forcing pending invokers ──────────────────────────────────────
+	// Preview producers (queueResolveHandler) register here so `resolve` can
+	// dispatch to a staged action WITHOUT a forced tool_choice (no messages-cache
+	// bust). Stacked by UNIQUE id: a re-register replaces only the same id, so
+	// concurrent/sequential previews each survive and resolve independently.
+
+	/** Register (or replace by exact id) a non-forcing pending preview invoker. */
+	registerPendingInvoker(
+		id: string,
+		sourceToolName: string,
+		onInvoked: (input: unknown) => Promise<unknown> | unknown,
+	): void {
+		this.removePendingInvoker(id);
+		this.#pendingInvokers.push({ id, sourceToolName, onInvoked });
+	}
+
+	/** Drop the pending invoker with this id (e.g. after it resolves). */
+	removePendingInvoker(id: string): void {
+		this.#pendingInvokers = this.#pendingInvokers.filter(p => p.id !== id);
+	}
+
+	/** True when at least one non-forcing pending preview is registered. */
+	get hasPendingInvoker(): boolean {
+		return this.#pendingInvokers.length > 0;
+	}
+
+	/** The head (most-recently registered) pending invoker's handler, for resolve dispatch. */
+	peekPendingInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
+		return this.#pendingInvokers.at(-1)?.onInvoked;
+	}
+
+	/** The head pending preview's stable id + source tool, for building the agent-level
+	 *  SoftToolRequirement (the id drives reminder re-injection when the head changes). */
+	peekPendingHead(): { id: string; sourceToolName: string } | undefined {
+		const head = this.#pendingInvokers.at(-1);
+		return head ? { id: head.id, sourceToolName: head.sourceToolName } : undefined;
+	}
+
 	// ── Cleanup ───────────────────────────────────────────────────────────
 
 	/** Remove all directives with the given label. Rejects in-flight if it matches. */
@@ -206,6 +264,7 @@ export class ToolChoiceQueue {
 			this.reject("cleared");
 		}
 		this.#queue = [];
+		this.#pendingInvokers = [];
 		this.#lastResolvedLabel = undefined;
 	}
 

package/src/system-prompt.ts

@@ -373,11 +373,11 @@ export interface BuildSystemPromptOptions {
 	toolNames?: string[];
 	/** Text to append to system prompt. */
 	appendSystemPrompt?: string;
-	/** Repeat full tool descriptions in system prompt. Default: false */
-	repeatToolDescriptions?: boolean;
+	/** Inline full tool descriptors in the system prompt. Default: true */
+	inlineToolDescriptors?: boolean;
 	/**
 	 * Whether provider-native tool calling is active (no owned/in-band syntax).
-	 * When true and `repeatToolDescriptions` is false, the inventory renders as a
+	 * When true and `inlineToolDescriptors` is false, the inventory renders as a
 	 * compact tool-name list; otherwise it renders full `# Tool:` sections. Default: true
 	 */
 	nativeTools?: boolean;
@@ -433,7 +433,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		customPrompt,
 		tools,
 		appendSystemPrompt,
-		repeatToolDescriptions = false,
+		inlineToolDescriptors: providedInlineToolDescriptors,
 		nativeTools = true,
 		skillsSettings,
 		toolNames: providedToolNames,
@@ -454,6 +454,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		model,
 		personality = "default",
 	} = options;
+	const inlineToolDescriptors = providedInlineToolDescriptors ?? true;
 	const resolvedCwd = cwd ?? getProjectDir();
 
 	const prepDefaults = {
@@ -599,10 +600,10 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			examples: meta?.examples,
 		};
 	});
-	// List mode shows a compact tool-name list; it only applies when descriptions
-	// are not repeated AND native tool calling is active (the model already has the
-	// schemas). Otherwise render full `# Tool:` sections.
-	const toolListMode = !repeatToolDescriptions && nativeTools;
+	// List mode shows a compact tool-name list; it only applies when descriptors
+	// stay in provider-native tool schemas AND native tool calling is active.
+	// Otherwise render full `# Tool:` sections inline in the system prompt.
+	const toolListMode = !inlineToolDescriptors && nativeTools;
 	const toolInventory = toolListMode ? "" : renderToolInventory(inventoryTools, model ?? "");
 
 	// Filter skills for the rendered system prompt:
@@ -632,7 +633,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		tools: toolNames,
 		toolInfo,
 		toolInventory,
-		repeatToolDescriptions,
+		inlineToolDescriptors,
 		toolListMode,
 		toolRefs,
 		environment,

package/src/tools/bash-interactive.ts

@@ -274,16 +274,16 @@ class BashInteractiveOverlayComponent implements Component {
 				: truncateToWidth(this.uiTheme.fg("dim", "session finished"), innerWidth);
 		const visibleLines = this.#readViewport(innerWidth, maxContentRows);
 		const content = visibleLines.length > 0 ? visibleLines : [padding(innerWidth)];
-		const borderHorizontal = this.uiTheme.fg("border", this.uiTheme.boxSharp.horizontal.repeat(innerWidth));
-		const borderVertical = this.uiTheme.fg("border", this.uiTheme.boxSharp.vertical);
+		const borderHorizontal = this.uiTheme.fg("border", this.uiTheme.boxRound.horizontal.repeat(innerWidth));
+		const borderVertical = this.uiTheme.fg("border", this.uiTheme.boxRound.vertical);
 		const boxLine = (line: string) =>
 			`${borderVertical}${line}${padding(Math.max(0, innerWidth - visibleWidth(line)))}${borderVertical}`;
 		return [
-			`${this.uiTheme.fg("border", this.uiTheme.boxSharp.topLeft)}${borderHorizontal}${this.uiTheme.fg("border", this.uiTheme.boxSharp.topRight)}`,
+			`${this.uiTheme.fg("border", this.uiTheme.boxRound.topLeft)}${borderHorizontal}${this.uiTheme.fg("border", this.uiTheme.boxRound.topRight)}`,
 			boxLine(header),
 			...content.map(boxLine),
 			boxLine(footer),
-			`${this.uiTheme.fg("border", this.uiTheme.boxSharp.bottomLeft)}${borderHorizontal}${this.uiTheme.fg("border", this.uiTheme.boxSharp.bottomRight)}`,
+			`${this.uiTheme.fg("border", this.uiTheme.boxRound.bottomLeft)}${borderHorizontal}${this.uiTheme.fg("border", this.uiTheme.boxRound.bottomRight)}`,
 		];
 	}
 

package/src/tools/index.ts

@@ -312,6 +312,10 @@ export interface ToolSession {
 	steer?(message: { customType: string; content: string; details?: unknown }): void;
 	/** Peek the currently in-flight tool-choice queue directive's invocation handler. Used by the `resolve` tool to dispatch to the pending action. */
 	peekQueueInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+	/** Peek the most-recently registered non-forcing pending preview invoker. The `resolve`
+	 *  tool dispatches to it so a staged preview resolves WITHOUT forcing tool_choice — the
+	 *  agent-loop's SoftToolRequirement lifecycle owns reminder injection and escalation. */
+	peekPendingInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
 	/** Peek the long-lived "standing" resolve handler registered by a mode (e.g. plan mode).
 	 *  Consulted by the `resolve` tool as a fallback when no queue invoker is in flight,
 	 *  letting modes accept `resolve` invocations without forcing the tool choice every turn. */

package/src/tools/resolve.ts

@@ -1,4 +1,10 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type {
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	CustomMessage,
+} from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
@@ -28,11 +34,18 @@ export interface ResolveToolDetails {
 	sourceResultDetails?: unknown;
 }
 
+/** Monotonic suffix making each staged preview's pending-invoker id UNIQUE, so
+ *  stacked previews never clobber one another by label. */
+let pendingPreviewSeq = 0;
+
 /**
- * Queue a resolve-protocol handler on the tool-choice queue. Forces the next
- * LLM call to invoke the hidden `resolve` tool, wraps the caller's apply/reject
- * callbacks into an onInvoked closure that matches the resolve schema, and
- * steers a preview reminder so the model understands why.
+ * Register a non-forcing resolve-protocol handler for a staged preview. Wraps the
+ * caller's apply/reject into an onInvoked closure (matching the resolve schema) and
+ * stores it on the tool-choice queue's pending-invoker registry under a UNIQUE id.
+ * The `resolve` tool dispatches to it; the agent-loop's SoftToolRequirement
+ * lifecycle injects the preview reminder and escalates to a forced `resolve` only
+ * if the model declines — so a compliant turn pays ZERO tool_choice change (no
+ * prompt-cache messages-cache invalidation).
  *
  * This is the canonical entry point for any tool that wants preview/apply
  * semantics. No session-level abstraction is needed: callers pass their
@@ -48,46 +61,55 @@ export function queueResolveHandler(
 	},
 ): void {
 	const queue = session.getToolChoiceQueue?.();
-	const forced = session.buildToolChoice?.("resolve");
-	if (!queue || !forced || typeof forced === "string") return;
+	if (!queue) return;
 
-	const steerReminder = (): void => {
-		session.steer?.({
-			customType: "resolve-reminder",
-			content: [
-				"<system-reminder>",
-				"This is a preview. Call the `resolve` tool to apply or discard these changes.",
-				"</system-reminder>",
-			].join("\n"),
-			details: { toolName: options.sourceToolName },
-		});
-	};
+	// Unique per preview: stacked/sequential previews each get their own entry.
+	const id = `pending-action:${options.sourceToolName}:${pendingPreviewSeq++}`;
 
-	const pushDirective = (): void => {
-		queue.pushOnce(forced, {
-			label: `pending-action:${options.sourceToolName}`,
-			now: true,
-			onRejected: () => "requeue",
-			onInvoked: async (input: unknown) =>
-				runResolveInvocation(input as ResolveParams, {
-					sourceToolName: options.sourceToolName,
-					label: options.label,
-					apply: options.apply,
-					reject: options.reject,
-					onApplyError: () => {
-						// Apply threw (e.g. ast_edit overlapping replacements). Re-push the
-						// same directive so the preview remains pending and the model can
-						// `discard` or fix-and-retry on the next turn instead of being
-						// stranded with no pending action to address.
-						pushDirective();
-						steerReminder();
-					},
-				}),
+	const onInvoked = async (input: unknown): Promise<AgentToolResult<unknown>> => {
+		const result = await runResolveInvocation(input as ResolveParams, {
+			sourceToolName: options.sourceToolName,
+			label: options.label,
+			apply: options.apply,
+			reject: options.reject,
+			onApplyError: () => {
+				// Apply threw (e.g. ast_edit overlapping replacements). Keep the preview
+				// pending under the SAME id so the model can `discard` or fix-and-retry;
+				// runResolveInvocation rethrows, so the success-path removal below is skipped.
+				queue.registerPendingInvoker(id, options.sourceToolName, onInvoked);
+			},
 		});
+		// Resolved (apply succeeded, or discard): consume the staged action exactly once.
+		queue.removePendingInvoker(id);
+		return result;
 	};
 
-	pushDirective();
-	steerReminder();
+	// NON-FORCING: register so `resolve` can dispatch here WITHOUT changing
+	// tool_choice. The agent-loop injects the reminder (from the SoftToolRequirement
+	// the session builds) and forces a resolve turn only on non-compliance.
+	queue.registerPendingInvoker(id, options.sourceToolName, onInvoked);
+}
+
+/**
+ * The canonical preview reminder. The resolve mechanism owns the wording; the
+ * agent-loop delivers it via the session's `SoftToolRequirement.reminder` (injected
+ * once per pending-preview head) instead of a host-side steer, so it lands as a
+ * stable mid-history append and never churns the cached prefix.
+ */
+export function buildResolveReminderMessage(sourceToolName: string): CustomMessage {
+	return {
+		role: "custom",
+		customType: "resolve-reminder",
+		content: [
+			"<system-reminder>",
+			"This is a preview. Call the `resolve` tool to apply or discard these changes.",
+			"</system-reminder>",
+		].join("\n"),
+		display: false,
+		details: { toolName: sourceToolName },
+		attribution: "agent",
+		timestamp: Date.now(),
+	};
 }
 
 /**
@@ -185,7 +207,10 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<ResolveToolDetails>> {
 		return untilAborted(signal, async () => {
-			const invoker = this.session.peekQueueInvoker?.() ?? this.session.peekStandingResolveHandler?.();
+			const invoker =
+				this.session.peekQueueInvoker?.() ??
+				this.session.peekPendingInvoker?.() ??
+				this.session.peekStandingResolveHandler?.();
 			if (!invoker) {
 				// `discard` is a request to cancel/abort a staged action. When nothing is
 				// pending, the desired end-state (no staged change) already holds, so honor

package/src/tui/output-block.ts

@@ -48,8 +48,8 @@ function normalizeContentPaddingLeft(value: number | undefined): number {
 
 export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[] {
 	const { header, headerMeta, state, sections = [], width, applyBg = true } = options;
-	const h = theme.boxSharp.horizontal;
-	const v = theme.boxSharp.vertical;
+	const h = theme.boxRound.horizontal;
+	const v = theme.boxRound.vertical;
 	const cap = h.repeat(3);
 	const lineWidth = Math.max(0, width);
 	// Border colors: running/pending use accent, success uses dim (gray), error/warning keep their colors
@@ -84,8 +84,8 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 	const rows: BlockRow[] = [];
 	rows.push({
 		kind: "bar",
-		leftChar: theme.boxSharp.topLeft,
-		rightChar: theme.boxSharp.topRight,
+		leftChar: theme.boxRound.topLeft,
+		rightChar: theme.boxRound.topRight,
 		label: header,
 		meta: headerMeta,
 	});
@@ -99,15 +99,15 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		if (section.label) {
 			rows.push({
 				kind: "bar",
-				leftChar: theme.boxSharp.teeRight,
-				rightChar: theme.boxSharp.teeLeft,
+				leftChar: theme.boxRound.teeRight,
+				rightChar: theme.boxRound.teeLeft,
 				label: section.label,
 			});
 		} else if (section.separator && sectionIndex > 0) {
 			rows.push({
 				kind: "bar",
-				leftChar: theme.boxSharp.teeRight,
-				rightChar: theme.boxSharp.teeLeft,
+				leftChar: theme.boxRound.teeRight,
+				rightChar: theme.boxRound.teeLeft,
 			});
 		}
 		const allLines = section.lines.flatMap(l => l.split("\n"));
@@ -126,7 +126,7 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		}
 	}
 
-	rows.push({ kind: "bottom", leftChar: theme.boxSharp.bottomLeft, rightChar: theme.boxSharp.bottomRight });
+	rows.push({ kind: "bottom", leftChar: theme.boxRound.bottomLeft, rightChar: theme.boxRound.bottomRight });
 
 	const H = rows.length;
 

package/dist/types/modes/components/branch-summary-message.d.ts

@@ -1,13 +0,0 @@
-import { Box } from "@oh-my-pi/pi-tui";
-import type { BranchSummaryMessage } from "../../session/messages";
-/**
- * Component that renders a branch summary message with collapsed/expanded state.
- * Uses same background color as hook messages for visual consistency.
- */
-export declare class BranchSummaryMessageComponent extends Box {
-    #private;
-    private readonly message;
-    constructor(message: BranchSummaryMessage);
-    setExpanded(expanded: boolean): void;
-    invalidate(): void;
-}

package/src/modes/components/branch-summary-message.ts

@@ -1,46 +0,0 @@
-import { Box, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
-import { getMarkdownTheme, theme } from "../../modes/theme/theme";
-import type { BranchSummaryMessage } from "../../session/messages";
-
-/**
- * Component that renders a branch summary message with collapsed/expanded state.
- * Uses same background color as hook messages for visual consistency.
- */
-export class BranchSummaryMessageComponent extends Box {
-	#expanded = false;
-
-	constructor(private readonly message: BranchSummaryMessage) {
-		super(1, 1, t => theme.bg("customMessageBg", t));
-		this.setIgnoreTight(true);
-		this.#updateDisplay();
-	}
-
-	setExpanded(expanded: boolean): void {
-		this.#expanded = expanded;
-		this.#updateDisplay();
-	}
-
-	override invalidate(): void {
-		super.invalidate();
-		this.#updateDisplay();
-	}
-
-	#updateDisplay(): void {
-		this.clear();
-
-		const label = theme.fg("customMessageLabel", theme.bold("[branch]"));
-		this.addChild(new Text(label, 0, 0));
-		this.addChild(new Spacer(1));
-
-		if (this.#expanded) {
-			const header = "**Branch Summary**\n\n";
-			this.addChild(
-				new Markdown(header + this.message.summary, 0, 0, getMarkdownTheme(), {
-					color: (text: string) => theme.fg("customMessageText", text),
-				}),
-			);
-		} else {
-			this.addChild(new Text(theme.fg("customMessageText", "Branch summary (ctrl+o to expand)"), 0, 0));
-		}
-	}
-}