@iowarp/clio-coder 0.3.1 → 0.3.3

package/src/interactive/chat-panel.ts

@@ -2,28 +2,52 @@ import { performance } from "node:perf_hooks";
 import type { OutputVerbosity } from "../core/defaults.js";
 import { SKILL_SUGGESTION_PREFIX } from "../core/skill-activation.js";
 import { rawDurationMs } from "../core/timers.js";
-import { estimateReasoningTextTokens, extractReasoningTokens } from "../domains/session/context-accounting.js";
 import { type Component, Markdown, truncateToWidth, wrapTextWithAnsi } from "../engine/tui.js";
 import type { AgentMessage } from "../engine/types.js";
+import { toolPresentationPolicy } from "../tools/presentation.js";
 import type { ChatLoopEvent, RetryStatusPayload } from "./chat-loop.js";
 import { extractText, isSelfExplainingAbort } from "./chat-loop-messages.js";
+import type { ApprovalRequestView } from "./permission-overlay.js";
 import { codeInk } from "./renderers/code-ink.js";
+import { createMermaidMarkdownTransform } from "./renderers/mermaid.js";
 import { styleTaggedNotice } from "./renderers/notice.js";
 import { formatRetryStatus } from "./renderers/retry-status.js";
 import {
-	classifyResourceRead,
-	previewResult,
 	renderToolAwaitingApproval,
 	renderToolCallHeader,
 	renderToolExecution,
 	renderToolRunningStatus,
 	renderToolStreamingExecution,
 	renderToolSubline,
-	unwrapResultEnvelope,
 } from "./renderers/tool-execution.js";
 import { renderWorkerEntryLines } from "./renderers/worker-entry.js";
-import { INLINE_STATUS_INDENT_COLS, type StatusPhase, type VerbRender } from "./status/index.js";
+import {
+	compactReasoningTokens,
+	emptyRunTally,
+	foldMessageIntoRunTally,
+	formatReasoningChip,
+	formatReasoningLabel,
+	INLINE_STATUS_INDENT_COLS,
+	type ReasoningTokenProvenance,
+	type ReasoningUsageView,
+	reasoningFromTally,
+	type StatusPhase,
+	UNMEASURED_REASONING,
+	type VerbRender,
+} from "./status/index.js";
 import { clioTheme, fgSequence, GLYPH, markdownTheme, SGR_DIM, SGR_RESET } from "./theme/index.js";
+import {
+	type Fold,
+	type FoldOverride,
+	policyRunningToolFold,
+	policyThinkingFold,
+	policyToolFold,
+	policyWorkerFold,
+	resolveFold,
+	type TranscriptDetailPolicy,
+	toggledFold,
+	transcriptDetail,
+} from "./transcript-detail.js";
 import { type WorkerEntryState, workerAskedByModel } from "./worker-stream.js";
 
 // Fenced code reaches the screen through pi-tui's Markdown component, which
@@ -33,6 +57,13 @@ import { type WorkerEntryState, workerAskedByModel } from "./worker-stream.js";
 // indentation, and width behavior stay pi-tui's and nothing post-processes
 // already-rendered output.
 const CHAT_MARKDOWN_THEME = markdownTheme(clioTheme(), (code, lang) => codeInk(lang, code.split("\n")));
+const CHAT_MARKDOWN_OPTIONS = {
+	transform: createMermaidMarkdownTransform(clioTheme()),
+	renderLatex: true,
+} as const;
+// TuiAltScreen uses Pi's OSC 133 prompt-start marker for semantic prompt
+// navigation. The sequence is zero-width and stripped before terminal output.
+const OSC133_PROMPT_START = "\x1b]133;A\x07";
 
 // Prefix and rail SGR constants, previously re-exported by the deleted
 // palette.ts. Composing them from fgSequence/GLYPH here yields byte-identical
@@ -49,10 +80,10 @@ const USER_GLYPH = GLYPH.user;
 
 /**
  * An assistant turn is a sequence of text and tool segments interleaved in
- * pi-agent-core event order. pi-agent-core emits: `message_start` →
- * `text_delta`+ → `message_end` → `tool_execution_*` → (next) `message_start`
- * → `text_delta`+ → `message_end`, so tool calls always sit BETWEEN the
- * assistant's pre-tool narration and the post-tool summary. Storing a flat
+ * pi-agent-core event order. A tool turn emits assistant `message_update`
+ * events carrying `toolcall_*` formation, then `message_end`, then the
+ * `tool_execution_*` lifecycle before the next assistant message. Tool calls
+ * therefore sit BETWEEN the assistant's pre-tool narration and the post-tool summary. Storing a flat
  * `text` buffer + `tools[]` array (pre-refactor) collapsed that order: all
  * text across the turn concatenated into one line with every tool block
  * appended at the end. The segment list preserves the stream order instead.
@@ -62,7 +93,7 @@ const USER_GLYPH = GLYPH.user;
  * through the Markdown renderer. Partial markdown (unclosed fence, half-typed
  * bullet) would otherwise paint garbage at ~60 fps under streaming.
  */
-export type ReasoningTokenProvenance = "provider" | "estimated" | "mixed";
+export type { ReasoningTokenProvenance } from "./status/index.js";
 
 export interface ChatPanelTurnUsage {
 	inputTokens: number;
@@ -117,6 +148,10 @@ type ToolSegment = {
 	result?: unknown;
 	/** True once `tool_execution_end` has landed (success or error). */
 	finished: boolean;
+	/** Pi streamed the call row before execution and later starts this same row. */
+	executionStarted: boolean;
+	/** The assistant stream closed this call's argument block. */
+	argsComplete: boolean;
 	/**
 	 * True when the segment was force-settled without its own end event
 	 * (blocked at admission, aborted mid-batch, id reused). A late
@@ -128,8 +163,13 @@ type ToolSegment = {
 	settledWithoutResult?: boolean | undefined;
 	/** True when the finished result was an error. Meaningful only after `finished`. */
 	isError: boolean;
-	/** When true, render the full structured block instead of the collapsed subline. */
-	expanded: boolean;
+	/**
+	 * The operator's explicit fold for this block, or none. The effective state
+	 * is this override when set, else what the transcript detail policy gives
+	 * the call (through the tool's presentation once it has finished). Cleared
+	 * when `/output` changes and when a session is switched in.
+	 */
+	fold?: FoldOverride;
 	/** Wall-clock start time captured by the chat panel for live duration display. */
 	startedAtMs?: number;
 	/** Completed call duration in milliseconds (event-supplied or measured locally). */
@@ -137,13 +177,15 @@ type ToolSegment = {
 	/** Persisted result summary (bytes, truncated, offloadPath, observation) from the chat loop. */
 	resultSummary?: Record<string, unknown> | undefined;
 	/**
-	 * Latest cumulative partial output from `tool_execution_update`. Cleared
+	 * Latest cumulative Pi result from `tool_execution_update`, including the
+	 * display content and structured progress details. Cleared
 	 * back to `undefined` on `tool_execution_end` so the finished `result`
-	 * takes over. Only consumed when `!finished && expanded`. The explicit
+	 * takes over. Only consumed while the call is in flight and its effective
+	 * state is expanded. The explicit
 	 * `| undefined` is required under `exactOptionalPropertyTypes: true` so
 	 * the clear path can re-assign `undefined` without a `delete`.
 	 */
-	partialOutput?: string | undefined;
+	partialResult?: unknown;
 	/**
 	 * True while the call is parked at the permission gate. Set/cleared by
 	 * `tool_approval_state` events and cleared by any settle so a denied or
@@ -151,6 +193,8 @@ type ToolSegment = {
 	 * while `!finished`.
 	 */
 	awaitingApproval?: boolean | undefined;
+	/** Live, redacted approval facts. Never reconstructed during replay. */
+	approvalView?: ApprovalRequestView | undefined;
 	settlement?: "blocked" | "aborted" | "orphaned" | undefined;
 	/**
 	 * The admission verdict's short reason, present only on a settlement the
@@ -158,6 +202,8 @@ type ToolSegment = {
 	 * was refused and leaves the operator no way to learn why.
 	 */
 	blockReason?: string | undefined;
+	/** View-only marker: historical calls render mutation diffs without live color. */
+	replayed?: true;
 };
 /**
  * A turn's terminal-error marker (`[error] ...`, `[aborted] ...`,
@@ -170,8 +216,32 @@ type ErrorSegment = {
 	kind: "error";
 	text: string;
 };
-type AssistantSegment = TextSegment | ToolSegment | ErrorSegment;
-type ReplayBlockRenderer = (width: number) => string[];
+/**
+ * One stretch of reasoning, in stream order with the text and tool segments
+ * around it. A turn used to hold one `thinking` string, so reasoning could only
+ * ever render in one place (above everything or below everything) and a
+ * turn that thought, wrote, thought again, called a tool, and thought once more
+ * had its reasoning pinned at the tail while the prose streamed in above it.
+ * Each stretch is its own segment now: it renders where it happened, and the
+ * one still open at the tail is the live indicator.
+ */
+type ThinkingSegment = {
+	kind: "thinking";
+	text: string;
+	/** Closed by the first text, tool, or message_end that follows it. */
+	finalized: boolean;
+	/** Panel clock when the first delta of this stretch arrived. */
+	startedAtMs?: number;
+	/** The operator's explicit fold for this stretch, or none. */
+	fold?: FoldOverride;
+};
+type AssistantSegment = TextSegment | ToolSegment | ErrorSegment | ThinkingSegment;
+/**
+ * A caller-rendered block receives the frame's transcript detail policy so a
+ * block that owns fold state (the operator's `!` bash row) resolves it the same
+ * way the panel resolves a model call. Blocks that ignore it are unaffected.
+ */
+type ReplayBlockRenderer = (width: number, detail: TranscriptDetailPolicy) => string[];
 type AssistantStatusLine = { phase: StatusPhase; verb: string; toneHint: VerbRender["toneHint"] };
 
 type TranscriptEntry =
@@ -181,23 +251,13 @@ type TranscriptEntry =
 			role: "assistant";
 			segments: AssistantSegment[];
 			/**
-			 * Raw thinking content from `thinking_delta` events plus
-			 * `thinking` blocks captured on `message_end`. Renders live while
-			 * the turn is pending: a folded `Thinking (N tokens)…` marker by
-			 * default, or the tail of the reasoning down a dim `│ ` rail if
-			 * expanded via `toggleLastThinking()` (Ctrl+T). Once the turn
-			 * settles it collapses to a static `Thinking...` marker (folded) or
-			 * a head-anchored rail (expanded), mirroring the pi-coding-agent
-			 * reference which streams thinking from the partial message.
-			 */
-			thinking: string;
-			/**
-			 * Whether the thinking block renders as the full body (true) or
-			 * the one-line dim marker (false/undefined). Toggled by
-			 * `toggleLastThinking()`. New thinking inherits the panel-level
-			 * visibility mode until Ctrl+T toggles it again.
+			 * `segments.length` when the current model call began, so `message_end`
+			 * can tell which segments belong to the message it is settling. A
+			 * provider that delivers thinking only in the final message (no
+			 * `thinking_delta`) gets its thinking segment inserted here, ahead of
+			 * the text the same message produced, rather than at the tail.
 			 */
-			expandedThinking?: boolean;
+			messageStartSegmentIndex?: number | undefined;
 			pending: boolean;
 			statusLine?: AssistantStatusLine | null | undefined;
 			isError: boolean;
@@ -205,19 +265,53 @@ type TranscriptEntry =
 	  }
 	/**
 	 * A dispatched worker's attributed block. The panel owns only the fold
-	 * state; `state` is the live object the worker-stream reducer mutates, so a
-	 * streaming delta reaches the screen without copying the entry per frame.
+	 * override; `state` is the live object the worker-stream reducer mutates, so
+	 * a streaming delta reaches the screen without copying the entry per frame.
 	 * The panel is told when that happened through `applyWorkerState`.
 	 */
-	| { role: "worker"; state: WorkerEntryState; folded: boolean }
-	| { role: "replayBlock"; renderBlock: ReplayBlockRenderer };
+	| { role: "worker"; state: WorkerEntryState; fold?: FoldOverride }
+	/**
+	 * A block the caller renders itself. Most are settled the moment they are
+	 * appended, but a few (the operator's `!` bash row) keep mutating the state
+	 * their closure reads until the work behind them finishes. Such a block
+	 * declares `isLive`, which keeps it out of the frozen prefix and keeps the
+	 * panel's time-keyed tick running while it is unsettled.
+	 */
+	| {
+			role: "replayBlock";
+			renderBlock: ReplayBlockRenderer;
+			isLive?: (() => boolean) | undefined;
+			fold?: ReplayBlockFoldControl | undefined;
+	  };
 
 type WorkerTranscriptEntry = Extract<TranscriptEntry, { role: "worker" }>;
 
+/**
+ * Fold state a caller-rendered block owns. The panel never stores it: the
+ * block's closure reads it when rendering, so the panel only needs to resolve
+ * and flip it when the operator uses an expand/collapse key, and to clear it
+ * when `/output` changes. Same tri-state as a tool segment: an override, or
+ * none, over the fold the policy gives the block.
+ */
+export interface ReplayBlockFoldControl {
+	/** The fold the policy gives this block when no override is set. */
+	policyFold(detail: TranscriptDetailPolicy): Fold;
+	/** The operator's override, or none. */
+	fold(): FoldOverride;
+	setFold(fold: FoldOverride): void;
+}
+
 export interface ChatPanel extends Component {
 	appendUser(text: string): void;
-	appendReplayBlock(renderBlock: ReplayBlockRenderer): void;
+	/**
+	 * Append a caller-rendered block. Pass `isLive` when the closure reads state
+	 * that keeps changing after the append, so the panel keeps re-rendering it
+	 * instead of treating the first frame as final.
+	 */
+	appendReplayBlock(renderBlock: ReplayBlockRenderer, isLive?: () => boolean, fold?: ReplayBlockFoldControl): void;
 	applyEvent(event: ChatLoopEvent): void;
+	/** Mark a just-rehydrated tool segment so its mutation diff remains plain. */
+	markToolReplayed?(toolCallId: string): void;
 	/**
 	 * Place or refresh a worker's block. The first call for an assignment
 	 * inserts the entry (agent origin nests under the tool segment named by
@@ -232,23 +326,37 @@ export interface ChatPanel extends Component {
 	 */
 	workerStates(): ReadonlyArray<WorkerEntryState>;
 	setStatusLine(line: AssistantStatusLine | null): void;
+	/**
+	 * Publish the live run tally's reasoning projection. The pending entry's
+	 * tail line reads this; passing null returns it to unmeasured, which is what
+	 * an idle or just-started turn is.
+	 */
+	setLiveReasoning(view: ReasoningUsageView | null): void;
+	/**
+	 * Flip the newest foldable block (tool call, worker card, or fold-owning
+	 * replay block) away from its effective state. The flip is an override
+	 * over the transcript detail policy: under `/output verbose` it folds an
+	 * open block, under `/output minimal` it opens a folded one.
+	 */
 	toggleLastToolExpanded(): boolean;
+	/** Set an explicit override on every tool, worker, and fold-owning block at once. */
 	toggleAllToolsExpanded(): boolean;
 	/**
-	 * Force every tool segment into its collapsed one-line form. Replay
-	 * (`rehydrateChatPanelFromTurns`) calls this so a resumed or forked
-	 * transcript reproduces the settled live view, where tools are collapsed to
-	 * their ledger summary rather than the expanded body. Idempotent.
+	 * Drop every operator override so each block returns to what the transcript
+	 * detail policy gives it. `/output` changes and session switches do this:
+	 * the operator asked for a new baseline, and what they had opened belonged
+	 * to the transcript they left. Idempotent.
 	 */
-	collapseAllTools(): void;
+	clearFoldOverrides(): void;
 	/**
-	 * Flip thinking-bearing assistant turns between the one-line dim marker
-	 * and the full rail-prefixed body. The target visibility is panel-level
-	 * sticky state, then applied to current thinking history so Ctrl+T behaves
-	 * like a transcript-level thinking visibility toggle.
+	 * Flip the newest thinking stretch between the one-line dim marker
+	 * and the full rail-prefixed body, as an override over the policy. A turn
+	 * with no thinking yet is left alone; a new stretch inherits the policy.
 	 */
 	toggleLastThinking(): boolean;
 	toggleAllThinking(): boolean;
+	/** Whether live thinking would render open this frame, which presentation pacing consults. */
+	isThinkingExpanded(): boolean;
 	/** Toggle whether expanded live tool bodies include cumulative partial output. */
 	toggleLiveToolOutput(): boolean;
 	/** Clears the visible transcript. /new uses this after rotating the session. */
@@ -328,39 +436,42 @@ function extractAssistantThinking(message: unknown): string {
 		.join("");
 }
 
-function finiteToken(value: unknown): number {
-	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
-}
-
+/**
+ * The panel's view of one assistant message's spend, folded through the same
+ * `foldMessageIntoRunTally` the status machine uses. The panel used to
+ * re-derive reasoning here with its own provider-lookup-then-estimate rule, so
+ * the transcript receipt and the footer could report the same turn differently.
+ */
 function assistantUsage(message: unknown): ChatPanelTurnUsage | undefined {
 	if (!message || typeof message !== "object" || (message as { role?: unknown }).role !== "assistant") return undefined;
-	const record = message as Record<string, unknown>;
-	const usage = record.usage && typeof record.usage === "object" ? (record.usage as Record<string, unknown>) : undefined;
-	const thinking = extractAssistantThinking(message);
-	const reportedReasoning = usage ? extractReasoningTokens(usage) : null;
-	const estimatedReasoning = reportedReasoning === null ? estimateReasoningTextTokens(thinking) : null;
-	const inputTokens = finiteToken(usage?.input);
-	const outputTokens = finiteToken(usage?.output);
-	const cacheReadTokens = finiteToken(usage?.cacheRead);
-	const cacheWriteTokens = finiteToken(usage?.cacheWrite);
+	const tally = foldMessageIntoRunTally(emptyRunTally(), message as AgentMessage);
+	const reasoning = reasoningFromTally(tally);
 	if (
-		inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens === 0 &&
-		reportedReasoning === null &&
-		estimatedReasoning === null
+		tally.inputTokens + tally.outputTokens + tally.cacheReadTokens + tally.cacheWriteTokens === 0 &&
+		reasoning.provenance === "unmeasured"
 	) {
 		return undefined;
 	}
-	const turnUsage: ChatPanelTurnUsage = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, modelCalls: 1 };
-	if (reportedReasoning !== null) {
-		turnUsage.reasoningTokens = reportedReasoning;
-		turnUsage.reasoningTokenProvenance = "provider";
-	} else if (estimatedReasoning !== null) {
-		turnUsage.reasoningTokens = estimatedReasoning;
-		turnUsage.reasoningTokenProvenance = "estimated";
+	const turnUsage: ChatPanelTurnUsage = {
+		inputTokens: tally.inputTokens,
+		outputTokens: tally.outputTokens,
+		cacheReadTokens: tally.cacheReadTokens,
+		cacheWriteTokens: tally.cacheWriteTokens,
+		modelCalls: 1,
+	};
+	if (reasoning.provenance !== "unmeasured") {
+		turnUsage.reasoningTokens = reasoning.tokens;
+		turnUsage.reasoningTokenProvenance = reasoning.provenance;
 	}
 	return turnUsage;
 }
 
+/** Settled-turn adapter onto the shared projection; the panel's own summary shape. */
+function reasoningFromTurnUsage(usage: ChatPanelTurnUsage | undefined): ReasoningUsageView {
+	if (!usage || usage.reasoningTokenProvenance === undefined) return UNMEASURED_REASONING;
+	return { tokens: Math.max(0, usage.reasoningTokens ?? 0), provenance: usage.reasoningTokenProvenance };
+}
+
 function aggregateAssistantUsage(messages: unknown): ChatPanelTurnUsage | undefined {
 	if (!Array.isArray(messages)) return undefined;
 	const total: ChatPanelTurnUsage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
@@ -426,6 +537,24 @@ function scopeTerminalErrorAfterSuccessfulTool(
 	return `[error] ${modelFailure}${detachedDispatchSucceeded ? "; detached runs continue" : ""}`;
 }
 
+function hasThinking(entry: Extract<TranscriptEntry, { role: "assistant" }>): boolean {
+	return entry.segments.some((seg) => seg.kind === "thinking" && seg.text.length > 0);
+}
+
+/** The thinking segment still receiving deltas, which is always the tail. */
+function openThinkingSegment(entry: Extract<TranscriptEntry, { role: "assistant" }>): ThinkingSegment | null {
+	const tail = entry.segments[entry.segments.length - 1];
+	return tail?.kind === "thinking" && !tail.finalized ? tail : null;
+}
+
+/** Index of the last thinking segment, which is where a settled turn's count chip rides. */
+function lastThinkingIndex(entry: Extract<TranscriptEntry, { role: "assistant" }>): number {
+	for (let index = entry.segments.length - 1; index >= 0; index -= 1) {
+		if (entry.segments[index]?.kind === "thinking") return index;
+	}
+	return -1;
+}
+
 function hasVisibleOutput(entry: Extract<TranscriptEntry, { role: "assistant" }>): boolean {
 	for (const seg of entry.segments) {
 		if (seg.kind === "tool") return true;
@@ -510,7 +639,7 @@ function renderTextSegmentLines(seg: TextSegment, width: number): string[] {
 		return wrapped;
 	}
 	if (!seg.md) {
-		seg.md = new Markdown(seg.text, 0, 0, CHAT_MARKDOWN_THEME);
+		seg.md = new Markdown(seg.text, 0, 0, CHAT_MARKDOWN_THEME, undefined, CHAT_MARKDOWN_OPTIONS);
 	}
 	// pi-tui Markdown right-pads lines to the render width. If a long streaming
 	// reply has already scrolled, flipping the finalized segment from unpadded
@@ -558,49 +687,60 @@ function hangProseLines(lines: string[], firstPrefix?: string): string[] {
  */
 const THINKING_HIDDEN_LABEL = `Thinking${GLYPH.ellipsis}`;
 const THINKING_LINE_LIMIT = 12;
-const REASONING_CHARS_PER_TOKEN = 4;
 
-function estimateThinkingTokens(thinking: string): number {
-	return estimateReasoningTextTokens(thinking) ?? Math.max(1, Math.round(thinking.length / REASONING_CHARS_PER_TOKEN));
+function dimLine(text: string, width: number): string {
+	return `${DIM}${truncateToWidth(text, Math.max(1, width), GLYPH.ellipsis, false)}${RESET}`;
 }
 
-function reasoningDisplay(usage: ChatPanelTurnUsage | undefined, thinking: string): { tokens: number; marker: string } {
-	if (usage?.reasoningTokens !== undefined) {
-		return {
-			tokens: usage.reasoningTokens,
-			marker: usage.reasoningTokenProvenance === "provider" ? "provider-reported" : "mixed/estimated",
-		};
-	}
-	return { tokens: estimateThinkingTokens(thinking), marker: "estimated" };
+/**
+ * A closed thinking stretch's folded marker, in place in the segment order. The
+ * turn's count chip rides on the last marker of a settled turn (`view` is
+ * unmeasured everywhere else), and comes from the settled usage, never from
+ * measuring the excerpt the panel happens to be holding.
+ */
+function renderSettledThinkingMarker(view: ReasoningUsageView, width: number): string {
+	const chip = formatReasoningChip(view, compactReasoningTokens);
+	return dimLine(
+		chip === null ? THINKING_HIDDEN_LABEL : `${THINKING_HIDDEN_LABEL} · ${chip} ${formatReasoningLabel(view)}`,
+		width,
+	);
 }
 
 /**
- * Render the assistant turn's thinking block. Collapsed (default) returns a
- * single dim `Thinking...` marker. Expanded returns the full body dimmed and
- * prefixed with a dim `│ ` rail, capped at `THINKING_LINE_LIMIT` lines with a
- * tail `... N more lines hidden` overflow message. Mirrors the tool toggle's
+ * The live turn's one reasoning line, rendered where the open thinking segment
+ * sits, which is the tail of the entry by construction: the first text, tool,
+ * or message_end closes it. Anchoring reasoning at the head put it above every
+ * streamed segment, so on a long turn the only progress indicator scrolled off
+ * the top; pinning one line at the tail put it below prose that streamed in
+ * after the model had already moved on, so the transcript read out of order.
+ *
+ * The count is whatever the run tally has folded so far, so between model calls
+ * the line states elapsed and nothing else. Visible thinking text is never
+ * counted: that number moved with how much reasoning the provider chose to
+ * display, not with what the turn spent.
+ */
+function renderLiveReasoningLine(view: ReasoningUsageView, elapsedMs: number | undefined, width: number): string {
+	const chip = formatReasoningChip(view, compactReasoningTokens);
+	const head = chip === null ? THINKING_HIDDEN_LABEL : `Thinking · ${chip} ${formatReasoningLabel(view)}`;
+	const seconds = elapsedMs === undefined ? 0 : Math.floor(Math.max(0, elapsedMs) / 1000);
+	return dimLine(seconds > 0 ? `${head} · ${seconds}s` : head, width);
+}
+
+/**
+ * Render the expanded thinking body: the text dimmed behind a dim `│ ` rail,
+ * capped at `THINKING_LINE_LIMIT` lines. A streaming turn keeps the tail (the
+ * reasoning still arriving); a settled one keeps the head with a
+ * `... N more lines hidden` overflow message. Mirrors the tool toggle's
  * lab-notebook minimalism: no colored glyphs, no boxes.
  */
-function renderThinkingLines(
-	thinking: string,
-	expanded: boolean,
-	width: number,
-	streaming: boolean,
-	usage?: ChatPanelTurnUsage,
-): string[] {
+function renderThinkingRail(thinking: string, width: number, streaming: boolean, unbounded = false): string[] {
 	if (thinking.length === 0) return [];
-	const dimWrap = (s: string): string => `${DIM}${s}${RESET}`;
-	if (!expanded) {
-		const lineBudget = Math.max(1, width);
-		const display = reasoningDisplay(usage, thinking);
-		const label = streaming
-			? `Thinking (${display.tokens} tokens)${display.marker === "provider-reported" ? "" : " ≈ estimated"}…`
-			: THINKING_HIDDEN_LABEL;
-		return [dimWrap(truncateToWidth(label, lineBudget, GLYPH.ellipsis, false))];
-	}
 	const splitLines = thinking.split("\n");
 	let visible: string[];
-	if (streaming) {
+	if (unbounded) {
+		// /export reproduces the whole transcript; the live cap is a screen budget.
+		visible = splitLines;
+	} else if (streaming) {
 		if (splitLines.length > THINKING_LINE_LIMIT) {
 			const hiddenCount = splitLines.length - THINKING_LINE_LIMIT;
 			visible = [`… ${hiddenCount} earlier lines hidden`, ...splitLines.slice(-THINKING_LINE_LIMIT)];
@@ -632,9 +772,13 @@ function renderThinkingLines(
  * reported 717676 input tokens against a 500k window; it was 65 calls of about
  * 11k, which the preceding one-call turns had already shown.
  */
-function renderTurnUsageLine(usage: ChatPanelTurnUsage, width: number, verbosity: OutputVerbosity): string[] {
-	if (verbosity === "minimal") return [];
-	if (verbosity === "default") {
+function renderTurnUsageLine(
+	usage: ChatPanelTurnUsage,
+	width: number,
+	receipt: TranscriptDetailPolicy["receipt"],
+): string[] {
+	if (receipt === "none") return [];
+	if (receipt === "compact") {
 		const receipt = truncateToWidth(
 			`  turn · in ${usage.inputTokens} · out ${usage.outputTokens}`,
 			width,
@@ -654,9 +798,10 @@ function renderTurnUsageLine(usage: ChatPanelTurnUsage, width: number, verbosity
 	// provenance of zero, and at narrow widths `reasoning 0 provider` orphaned
 	// the word `provider` on its own line. Zero suppresses the whole suffix, the
 	// same rule the caveat below already follows.
+	const view = reasoningFromTurnUsage(usage);
 	const reason =
-		usage.reasoningTokens !== undefined && usage.reasoningTokens > 0
-			? ` reasoning ${usage.reasoningTokenProvenance === "provider" ? `${usage.reasoningTokens} provider` : `≈${usage.reasoningTokens} estimated`}`
+		view.tokens > 0 && view.provenance !== "unmeasured"
+			? ` reasoning ${view.provenance === "provider" ? "" : "≈"}${view.tokens} ${formatReasoningLabel(view)}`
 			: "";
 	const cache =
 		usage.cacheReadTokens > 0 || usage.cacheWriteTokens > 0
@@ -665,10 +810,7 @@ function renderTurnUsageLine(usage: ChatPanelTurnUsage, width: number, verbosity
 	// The caveat is about reasoning text the panel displayed. A turn that spent
 	// no reasoning tokens displayed none, so appending it there warned about
 	// something absent and cost a wrapped line per turn at narrow widths.
-	const caveat =
-		usage.reasoningTokens !== undefined && usage.reasoningTokens > 0
-			? " · reasoning text is a UI excerpt, not a verification"
-			: "";
+	const caveat = view.tokens > 0 ? " · reasoning text is a UI excerpt, not a verification" : "";
 	return wrapTextWithAnsi(
 		`${DIM}  turn · in ${usage.inputTokens}${calls} · out ${usage.outputTokens}${cache}${reason}${caveat}${RESET}`,
 		width,
@@ -685,6 +827,22 @@ function styleStatusVerb(text: string, toneHint: VerbRender["toneHint"]): string
 	return `${DIM}${text}${RESET}`;
 }
 
+/**
+ * The fold the policy gives a tool segment this frame: the running-tool rule
+ * while in flight, the tool body rule (through the tool's own presentation)
+ * once finished, and the error rule for a finished failure.
+ */
+function policySegmentFold(seg: ToolSegment, detail: TranscriptDetailPolicy): Fold {
+	if (!seg.finished) return policyRunningToolFold(detail);
+	if (seg.isError && detail.errors === "body") return "expanded";
+	return policyToolFold(detail, toolPresentationPolicy(seg.name, seg.args));
+}
+
+/** Effective state of a tool segment: the operator's override, else the policy. */
+function toolSegmentExpanded(seg: ToolSegment, detail: TranscriptDetailPolicy): boolean {
+	return resolveFold(seg.fold, policySegmentFold(seg, detail)) === "expanded";
+}
+
 function renderToolSegmentLines(
 	seg: ToolSegment,
 	width: number,
@@ -692,17 +850,26 @@ function renderToolSegmentLines(
 	latestHintToolId: string | null,
 	nowMs: number,
 	unboundedToolBodies: boolean,
-	verbosity: OutputVerbosity,
+	detail: TranscriptDetailPolicy,
 	liveToolOutput: boolean,
 ): string[] {
 	const hintKey = seg.id === latestHintToolId ? expandKey : undefined;
-	const expanded = verbosity === "verbose" || (verbosity !== "minimal" && seg.expanded);
+	const expanded = toolSegmentExpanded(seg, detail);
 	const elapsedMs = seg.startedAtMs !== undefined ? Math.max(0, rawDurationMs(seg.startedAtMs, nowMs)) : undefined;
+	const phase: "forming" | "ready" | "running" = seg.executionStarted
+		? "running"
+		: seg.argsComplete
+			? "ready"
+			: "forming";
 	// A parked call is not executing: the awaiting-approval line replaces the
 	// counting elapsed spinner in both collapsed and expanded form (there is no
 	// body or partial output to expand while the call sits at the gate).
 	if (!seg.finished && seg.awaitingApproval === true) {
-		return renderToolAwaitingApproval({ toolCallId: seg.id, toolName: seg.name, args: seg.args }, width);
+		return renderToolAwaitingApproval(
+			{ toolCallId: seg.id, toolName: seg.name, args: seg.args },
+			width,
+			seg.approvalView,
+		);
 	}
 	if (!expanded) {
 		return renderToolSubline(
@@ -718,20 +885,24 @@ function renderToolSegmentLines(
 						outcome: seg.settlement,
 						blockReason: seg.blockReason,
 					}
-				: { toolCallId: seg.id, toolName: seg.name, args: seg.args, elapsedMs },
+				: { toolCallId: seg.id, toolName: seg.name, args: seg.args, elapsedMs, phase },
 			width,
 			hintKey,
+			{
+				diffStyle: seg.replayed === true ? "plain" : "color",
+				foldedExtras: detail.toolBody === "folded" ? "none" : "per-tool",
+			},
 		);
 	}
 	if (!seg.finished) {
-		if (liveToolOutput && seg.partialOutput !== undefined) {
+		if (liveToolOutput && seg.partialResult !== undefined) {
 			return renderToolStreamingExecution(
-				{ toolCallId: seg.id, toolName: seg.name, args: seg.args, elapsedMs },
+				{ toolCallId: seg.id, toolName: seg.name, args: seg.args, elapsedMs, phase },
 				width,
-				seg.partialOutput,
+				seg.partialResult,
 			);
 		}
-		const call = { toolCallId: seg.id, toolName: seg.name, args: seg.args, elapsedMs };
+		const call = { toolCallId: seg.id, toolName: seg.name, args: seg.args, elapsedMs, phase };
 		return liveToolOutput ? renderToolCallHeader(call, width) : renderToolRunningStatus(call, width);
 	}
 	return renderToolExecution(
@@ -747,19 +918,22 @@ function renderToolSegmentLines(
 			blockReason: seg.blockReason,
 		},
 		width,
-		{ unbounded: unboundedToolBodies },
+		{ unbounded: unboundedToolBodies, diffStyle: seg.replayed === true ? "plain" : "color" },
 	);
 }
 
 /**
- * Whether a worker block draws its one-line card this frame. `/output verbose`
- * opens every block and `/output minimal` folds every block, so the entry's own
- * fold decides only in between.
+ * Whether a worker block draws its one-line card this frame: the operator's
+ * override when set, else the policy's worker rule, which under the balanced
+ * level is the origin default (a run the model asked for folds).
  */
-function workerEntryFolded(entry: WorkerTranscriptEntry, verbosity: OutputVerbosity): boolean {
-	if (verbosity === "verbose") return false;
-	if (verbosity === "minimal") return true;
-	return entry.folded;
+function workerEntryFolded(entry: WorkerTranscriptEntry, detail: TranscriptDetailPolicy): boolean {
+	return resolveFold(entry.fold, policyWorkerFold(detail, workerAskedByModel(entry.state))) === "folded";
+}
+
+/** Effective state of one thinking stretch: the operator's override, else the policy. */
+function thinkingExpanded(segment: ThinkingSegment, detail: TranscriptDetailPolicy): boolean {
+	return resolveFold(segment.fold, policyThinkingFold(detail)) === "expanded";
 }
 
 function renderEntryLines(
@@ -770,24 +944,27 @@ function renderEntryLines(
 	latestFoldedWorkerId: string | null,
 	nowMs: number,
 	unboundedToolBodies: boolean,
-	verbosity: OutputVerbosity,
+	detail: TranscriptDetailPolicy,
 	liveToolOutput: boolean,
+	liveReasoning: ReasoningUsageView,
 ): string[] {
 	if (entry.role === "replayBlock") {
-		return entry.renderBlock(width);
+		return entry.renderBlock(width, detail);
 	}
 	if (entry.role === "user") {
 		const contentWidth = Math.max(1, width - PROSE_GUTTER_WIDTH);
 		const lines: string[] = [];
 		for (const sourceLine of entry.text.split("\n")) lines.push(...wrapTextWithAnsi(sourceLine, contentWidth));
-		return hangProseLines(lines, USER_PREFIX);
+		const rendered = hangProseLines(lines, USER_PREFIX);
+		if (rendered[0] !== undefined) rendered[0] = `${OSC133_PROMPT_START}${rendered[0]}`;
+		return rendered;
 	}
 	if (entry.role === "retryStatus") {
 		return wrapTextWithAnsi(formatRetryStatus(entry.status), width);
 	}
 	if (entry.role === "worker") {
 		return renderWorkerEntryLines(entry.state, width, {
-			folded: workerEntryFolded(entry, verbosity),
+			folded: workerEntryFolded(entry, detail),
 			...(expandKey !== undefined && entry.state.assignmentId === latestFoldedWorkerId ? { expandKey } : {}),
 			unbounded: unboundedToolBodies,
 		});
@@ -796,38 +973,50 @@ function renderEntryLines(
 	// A mid-turn notice splits the transcript, so the events after it open a
 	// fresh entry that a stopped turn never fills; that entry used to reach the
 	// tail below and print a lone agent bubble under the notice.
-	if (
-		!entry.pending &&
-		entry.thinking.length === 0 &&
-		entry.turnUsage === undefined &&
-		!hasVisibleOutput(entry) &&
-		entry.segments.length === 0
-	) {
+	if (!entry.pending && entry.turnUsage === undefined && !hasVisibleOutput(entry) && entry.segments.length === 0) {
 		return [];
 	}
 	const lines: string[] = [];
-	// Thinking renders BEFORE assistant text/tool segments so the folded marker
-	// or expanded rail sits above the response, matching the order the
-	// pi-coding-agent reference uses. It streams live while `pending === true`
-	// (folded shows a dynamic token count; expanded tail-anchors the tail) and
-	// collapses to a static marker / head-anchored rail once the turn settles.
-	// The generic "thinking" status verb is suppressed while this marker is
-	// active so only one indicator shows (see `shouldRenderStatus` below).
-	if (entry.thinking.length > 0) {
-		lines.push(
-			...renderThinkingLines(
-				entry.thinking,
-				verbosity === "verbose" || (verbosity !== "minimal" && entry.expandedThinking === true),
-				width,
-				entry.pending,
-				entry.turnUsage,
-			),
-		);
-	}
+	// Reasoning renders in stream order, between the text and tool segments it
+	// came between. A closed stretch is a folded marker (or a head-anchored rail
+	// when expanded); the stretch still open while the turn is pending is the
+	// live indicator, with the tally's count and its own elapsed. The turn's
+	// settled count chip rides on the last marker once the turn has settled.
+	const chipIndex = entry.pending ? -1 : lastThinkingIndex(entry);
 	const clioPrefix = entry.isError ? CLIO_PREFIX_ERROR : CLIO_PREFIX;
 	const proseWidth = Math.max(1, width - PROSE_GUTTER_WIDTH);
 	let labeled = false;
-	for (const seg of entry.segments) {
+	let liveIndicatorShown = false;
+	let latestThinkingExpanded = policyThinkingFold(detail) === "expanded";
+	for (let segIndex = 0; segIndex < entry.segments.length; segIndex += 1) {
+		const seg = entry.segments[segIndex];
+		if (seg === undefined) continue;
+		if (seg.kind === "thinking") {
+			if (seg.text.length === 0) continue;
+			const thinkingExpandedNow = thinkingExpanded(seg, detail);
+			latestThinkingExpanded = thinkingExpandedNow;
+			const live = entry.pending && !seg.finalized;
+			if (thinkingExpandedNow) lines.push(...renderThinkingRail(seg.text, width, live, unboundedToolBodies));
+			if (live) {
+				liveIndicatorShown = true;
+				// The bare marker level states that the model is thinking and
+				// nothing else: no count, no elapsed. An operator who opened the
+				// stretch anyway gets the progress line under the rail.
+				lines.push(
+					detail.thinking === "marker" && !thinkingExpandedNow
+						? dimLine(THINKING_HIDDEN_LABEL, width)
+						: renderLiveReasoningLine(
+								liveReasoning,
+								seg.startedAtMs === undefined ? undefined : Math.max(0, nowMs - seg.startedAtMs),
+								width,
+							),
+				);
+			} else if (!thinkingExpandedNow) {
+				const view = segIndex === chipIndex ? reasoningFromTurnUsage(entry.turnUsage) : UNMEASURED_REASONING;
+				lines.push(renderSettledThinkingMarker(view, width));
+			}
+			continue;
+		}
 		if (seg.kind === "tool") {
 			lines.push(
 				...renderToolSegmentLines(
@@ -837,7 +1026,7 @@ function renderEntryLines(
 					latestHintToolId,
 					nowMs,
 					unboundedToolBodies,
-					verbosity,
+					detail,
 					liveToolOutput,
 				),
 			);
@@ -870,21 +1059,30 @@ function renderEntryLines(
 			lines.push(...hangProseLines(rendered));
 		}
 	}
-	if (entry.turnUsage && !entry.pending) lines.push(...renderTurnUsageLine(entry.turnUsage, width, verbosity));
+	// A thinking stretch closes when text or a tool follows it so the historical
+	// marker stays in stream order. The turn-level reasoning projection is still
+	// live, though, and must remain beside the current tail instead of scrolling
+	// away with that marker. An open tail stretch already rendered this line.
+	if (entry.pending && hasThinking(entry) && !liveIndicatorShown) {
+		lines.push(
+			detail.thinking === "marker" && !latestThinkingExpanded
+				? dimLine(THINKING_HIDDEN_LABEL, width)
+				: renderLiveReasoningLine(liveReasoning, undefined, width),
+		);
+		liveIndicatorShown = true;
+	}
+	if (entry.turnUsage && !entry.pending) lines.push(...renderTurnUsageLine(entry.turnUsage, width, detail.receipt));
+	// The open thinking segment's line is the one that speaks for reasoning while
+	// the turn runs. The generic thinking verb is suppressed while it shows so
+	// the entry never carries two indicators for the same thing.
 	const shouldRenderStatus =
 		entry.pending &&
 		entry.statusLine !== null &&
 		entry.statusLine !== undefined &&
 		!(entry.statusLine.phase === "writing" && hasStreamingText(entry)) &&
-		!(entry.statusLine.phase === "thinking" && entry.thinking.length > 0);
-	if (!labeled && !hasVisibleOutput(entry)) {
-		lines.push(clioPrefix.trimEnd());
-		if (shouldRenderStatus) {
-			lines.push(
-				`${STATUS_INDENT}${styleStatusVerb(entry.statusLine?.verb ?? "", entry.statusLine?.toneHint ?? "muted")}`,
-			);
-		}
-	} else if (shouldRenderStatus) {
+		!(entry.statusLine.phase === "thinking" && liveIndicatorShown);
+	if (!labeled && !hasVisibleOutput(entry)) lines.push(clioPrefix.trimEnd());
+	if (shouldRenderStatus) {
 		lines.push(`${STATUS_INDENT}${styleStatusVerb(entry.statusLine?.verb ?? "", entry.statusLine?.toneHint ?? "muted")}`);
 	}
 	return lines;
@@ -898,8 +1096,14 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 	let cachedWidth: number | undefined;
 	let cachedLines: string[] = [];
 	let cachedExpandKey: string | undefined;
-	let cachedVerbosity: OutputVerbosity | undefined;
+	let cachedDetail: TranscriptDetailPolicy | undefined;
 	let cachedLiveToolOutput: boolean | undefined;
+	/**
+	 * The verbosity the last frame rendered under, or null before any frame.
+	 * A change between frames is the operator asking for a new baseline
+	 * (`/output`, or Settings → Terminal), and every override goes with it.
+	 */
+	let lastVerbosity: OutputVerbosity | undefined | null = null;
 	let cachedTick = 0;
 	/**
 	 * Did the last executed render put a counting elapsed line on screen? It is
@@ -921,18 +1125,23 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 	const entryCacheCapacity = (): number =>
 		Math.max(MIN_ENTRY_RENDER_CACHE, Math.min(MAX_ENTRY_RENDER_CACHE, transcript.length));
 	/**
-	 * Windowed-tail build (F19 on pi-tui 0.83 terms): the lines of every settled
+	 * Regular-screen windowed-tail build: the lines of every settled
 	 * leading entry are baked into one frozen prefix, so a dirty frame re-renders
-	 * only the live tail and re-emits the prefix by reference. pi-tui still
-	 * receives the full line array, deliberately: the 0.83 renderer keeps every
+	 * only the live tail and re-emits the prefix by reference. TuiMainScreen still
+	 * receives the full line array, deliberately: the renderer keeps every
 	 * line in `previousLines` and full-redraws (clearing scrollback) when the
-	 * head shrinks, so a real shrinking window needs the 0.84 ScrollView
-	 * architecture. The freeze is dropped whenever a frozen entry is invalidated
-	 * or the render key changes.
+	 * head shrinks. Fullscreen mode instead gives the transcript its own pi-tui
+	 * ScrollView. The freeze is dropped whenever a frozen entry is invalidated or
+	 * the render key changes.
 	 */
 	let frozen: { lines: string[]; through: number; key: string } | null = null;
-	let thinkingExpanded = false;
 	let liveToolOutput = true;
+	/**
+	 * The run tally's reasoning, projected. It is panel-level rather than
+	 * per-entry because only the pending tail entry ever renders it, and that
+	 * entry is by definition unfrozen and uncached.
+	 */
+	let liveReasoning: ReasoningUsageView = UNMEASURED_REASONING;
 	const unboundedToolBodies = options.unboundedToolBodies === true;
 
 	const markDirty = (): void => {
@@ -964,6 +1173,32 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 
 	const now = (): number => options.now?.() ?? Date.now();
 
+	/** The policy for a frame or a keypress, from whatever the settings say right now. */
+	const currentDetail = (): TranscriptDetailPolicy => transcriptDetail(options.getOutputVerbosity?.());
+
+	/**
+	 * Drop every operator override. Shared by the panel method and the
+	 * verbosity-change path in render, so both leave the same state behind.
+	 */
+	const dropFoldOverrides = (): void => {
+		for (const entry of transcript) {
+			if (entry.role === "replayBlock") {
+				entry.fold?.setFold(undefined);
+				continue;
+			}
+			if (entry.role === "worker") {
+				entry.fold = undefined;
+				continue;
+			}
+			if (entry.role !== "assistant") continue;
+			for (const seg of entry.segments) {
+				if (seg.kind === "tool" || seg.kind === "thinking") seg.fold = undefined;
+			}
+		}
+		clearRenderCaches();
+		markDirty();
+	};
+
 	/**
 	 * Force an in-flight tool segment to a settled error line. A call blocked at
 	 * admission (loop guard, safety) or one whose `tool_execution_end` never
@@ -983,8 +1218,9 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 		if (seg.result === undefined)
 			seg.result = "(no result: the call did not complete; execution was aborted, blocked, or orphaned)";
 		seg.settlement = settlement;
-		seg.partialOutput = undefined;
+		seg.partialResult = undefined;
 		seg.awaitingApproval = undefined;
+		seg.approvalView = undefined;
 	};
 
 	/**
@@ -1025,8 +1261,6 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 		const entry: Extract<TranscriptEntry, { role: "assistant" }> = {
 			role: "assistant",
 			segments: [],
-			thinking: "",
-			expandedThinking: thinkingExpanded,
 			pending: false,
 			isError: false,
 		};
@@ -1034,9 +1268,34 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 		return entry;
 	};
 
+	/**
+	 * Close the thinking stretch at the tail, if one is open. Anything that
+	 * follows reasoning in the stream (text, a tool call, the message settling)
+	 * ends that stretch; a later `thinking_delta` opens a new segment after it,
+	 * so the transcript keeps the order the model actually worked in.
+	 */
+	const closeOpenThinking = (entry: Extract<TranscriptEntry, { role: "assistant" }>): void => {
+		const open = openThinkingSegment(entry);
+		if (open === null) return;
+		open.finalized = true;
+		invalidateEntryCache(entry);
+	};
+
+	const appendThinkingDelta = (entry: Extract<TranscriptEntry, { role: "assistant" }>, delta: string): void => {
+		if (delta.length === 0) return;
+		invalidateEntryCache(entry);
+		const open = openThinkingSegment(entry);
+		if (open !== null) {
+			open.text += delta;
+			return;
+		}
+		entry.segments.push({ kind: "thinking", text: delta, finalized: false, startedAtMs: now() });
+	};
+
 	const appendTextDelta = (entry: Extract<TranscriptEntry, { role: "assistant" }>, delta: string): void => {
 		if (delta.length === 0) return;
 		invalidateEntryCache(entry);
+		closeOpenThinking(entry);
 		const tail = entry.segments[entry.segments.length - 1];
 		if (tail && tail.kind === "text" && !tail.finalized) {
 			tail.text += delta;
@@ -1046,15 +1305,22 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 	};
 
 	/**
-	 * Canonicalize a streamed text segment from a completed assistant message.
-	 * When streaming produced a prefix of the final text (the common case),
-	 * the tail segment is overwritten and flipped to finalized so the next
-	 * render pipes it through Markdown. When the message arrived fully formed
-	 * with no deltas (non-streaming test path, synthetic notices), a fresh
-	 * finalized text segment is appended after any tool segments that may
-	 * have landed in this turn already. `replaceTail` forces the overwrite for
-	 * messages the chat loop rewrote after streaming (locked-turn markup
-	 * sanitation): the streamed tail is dead text there, not a prefix.
+	 * Canonicalize the streamed text of a completed assistant message.
+	 *
+	 * The streamed text is wherever this message put it, not necessarily at the
+	 * tail: a message that thinks, writes, and thinks again leaves its text
+	 * behind a thinking segment. Looking only at the tail appended the message
+	 * text a second time under the reasoning marker, so the answer read twice.
+	 *
+	 * One streamed segment that is a prefix of the final text (the common case)
+	 * is overwritten in place and flipped to finalized so the next render pipes
+	 * it through Markdown. Several streamed segments (text split by reasoning)
+	 * are each finalized where they stand; the deltas already are the text.
+	 * When the message arrived fully formed with no deltas (non-streaming
+	 * path, synthetic notices, replay), a fresh finalized segment is appended.
+	 * `replaceTail` forces the overwrite for messages the chat loop rewrote
+	 * after streaming (locked-turn markup sanitation): the streamed text is dead
+	 * there, not a prefix.
 	 */
 	const canonicalizeMessageText = (
 		entry: Extract<TranscriptEntry, { role: "assistant" }>,
@@ -1062,15 +1328,36 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 		replaceTail = false,
 	): void => {
 		if (text.length === 0) return;
-		const tail = entry.segments[entry.segments.length - 1];
-		if (tail?.kind === "text" && !tail.finalized && (replaceTail || text.startsWith(tail.text))) {
-			tail.text = text;
-			tail.finalized = true;
+		closeOpenThinking(entry);
+		const messageStart = Math.min(entry.messageStartSegmentIndex ?? 0, entry.segments.length);
+		const streamed: TextSegment[] = [];
+		for (let index = messageStart; index < entry.segments.length; index += 1) {
+			const segment = entry.segments[index];
+			if (segment?.kind === "text" && !segment.finalized) streamed.push(segment);
+		}
+		const finalize = (segment: TextSegment, value: string): void => {
+			segment.text = value;
+			segment.finalized = true;
 			// The streaming wrap cache assumes append-only text. This is the one
 			// path that rewrites it wholesale, and finalized segments render through
 			// Markdown instead, so the cache is dead here either way.
-			delete tail.wrapCache;
-			if (tail.md) tail.md.setText(text);
+			delete segment.wrapCache;
+			if (segment.md) segment.md.setText(value);
+		};
+		if (replaceTail && streamed.length > 0) {
+			const [first, ...rest] = streamed;
+			if (first) finalize(first, text);
+			for (const dead of rest) entry.segments.splice(entry.segments.indexOf(dead), 1);
+			return;
+		}
+		if (streamed.length === 1 && streamed[0] !== undefined) {
+			const only = streamed[0];
+			if (text.startsWith(only.text)) {
+				finalize(only, text);
+				return;
+			}
+		} else if (streamed.length > 1) {
+			for (const segment of streamed) finalize(segment, segment.text);
 			return;
 		}
 		entry.segments.push({ kind: "text", text, finalized: true });
@@ -1089,25 +1376,30 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 	};
 
 	/**
-	 * Who advertises the fold key this frame: the newest folded worker card, or
-	 * the newest finished collapsed tool subline with no worker card behind it.
+	 * Who advertises the fold key this frame: the newest worker card whose
+	 * effective state is folded, or the newest finished tool subline whose
+	 * effective state is folded with no worker card behind it. Effective means
+	 * override-or-policy, so the hint follows the block whatever the verbosity.
 	 * One surface at most, because the key reaches the newest foldable thing of
 	 * either kind, and a chord shown anywhere else would open something the
 	 * operator was not looking at. An already-open newest card advertises
 	 * nothing, since folding it again needs no invitation.
 	 */
-	const expandHintOwner = (): { toolId: string | null; workerId: string | null } => {
+	const expandHintOwner = (detail: TranscriptDetailPolicy): { toolId: string | null; workerId: string | null } => {
 		let workerMayOwn = true;
 		for (let entryIndex = transcript.length - 1; entryIndex >= 0; entryIndex -= 1) {
 			const entry = transcript[entryIndex];
 			if (entry?.role === "worker") {
-				return { toolId: null, workerId: workerMayOwn && entry.folded ? entry.state.assignmentId : null };
+				return {
+					toolId: null,
+					workerId: workerMayOwn && workerEntryFolded(entry, detail) ? entry.state.assignmentId : null,
+				};
 			}
 			if (entry?.role !== "assistant") continue;
 			for (let segIndex = entry.segments.length - 1; segIndex >= 0; segIndex -= 1) {
 				const seg = entry.segments[segIndex];
 				if (seg?.kind !== "tool") continue;
-				if (seg.finished && !seg.expanded) return { toolId: seg.id, workerId: null };
+				if (seg.finished && !toolSegmentExpanded(seg, detail)) return { toolId: seg.id, workerId: null };
 				workerMayOwn = false;
 			}
 		}
@@ -1142,18 +1434,25 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 
 	/** True when the entry renders at least one counting elapsed line this frame. */
 	const entryHasRunningTool = (entry: TranscriptEntry): boolean =>
-		entry.role === "assistant" &&
-		entry.segments.some((segment) => segment.kind === "tool" && !segment.finished && segment.startedAtMs !== undefined);
+		(entry.role === "assistant" &&
+			(entry.segments.some(
+				(segment) => segment.kind === "tool" && !segment.finished && segment.startedAtMs !== undefined,
+				// The live reasoning line counts its own elapsed, so a turn that is
+				// only thinking still needs the time-keyed render key.
+			) ||
+				(entry.pending && openThinkingSegment(entry)?.startedAtMs !== undefined))) ||
+		(entry.role === "replayBlock" && entry.isLive?.() === true);
 
 	/**
 	 * Settled entries whose render is a pure function of the base key. A live
 	 * worker block is excluded for the same reason a running tool is: the
 	 * reducer mutates its state object in place, so a cached render would keep
-	 * serving the answer as it looked several deltas ago.
+	 * serving the answer as it looked several deltas ago. A replay block that
+	 * declares itself live is excluded on the same grounds.
 	 */
 	const entryIsStable = (entry: TranscriptEntry): boolean =>
 		entry.role === "user" ||
-		entry.role === "replayBlock" ||
+		(entry.role === "replayBlock" && entry.isLive?.() !== true) ||
 		(entry.role === "worker" && !entry.state.pending) ||
 		(entry.role === "assistant" &&
 			!entry.pending &&
@@ -1162,7 +1461,12 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 	const render = (width: number): string[] => {
 		const startedAt = performance.now();
 		const expandKey = resolveExpandKey();
-		const verbosity = options.getOutputVerbosity?.() ?? "default";
+		const verbosity = options.getOutputVerbosity?.();
+		// A new verbosity is a new baseline: the operator's per-block overrides
+		// were answers to the old one, so they go before the frame is built.
+		if (lastVerbosity !== null && verbosity !== lastVerbosity) dropFoldOverrides();
+		lastVerbosity = verbosity;
+		const detail = transcriptDetail(verbosity);
 		const nowMs = now();
 		// `dirty` is set on mutation and never on a tick, so without time in the
 		// key a running tool's elapsed counter advanced only when something
@@ -1180,14 +1484,14 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 			!dirty &&
 			cachedWidth === width &&
 			cachedExpandKey === expandKey &&
-			cachedVerbosity === verbosity &&
+			cachedDetail === detail &&
 			cachedLiveToolOutput === liveToolOutput &&
 			cachedTick === tick
 		) {
 			options.onRenderMetrics?.({ durationMs: performance.now() - startedAt, cacheHit: true, entriesRendered: 0 });
 			return cachedLines;
 		}
-		const { toolId: latestHintToolId, workerId: latestFoldedWorkerId } = expandHintOwner();
+		const { toolId: latestHintToolId, workerId: latestFoldedWorkerId } = expandHintOwner(detail);
 		// The hint id is deliberately NOT part of the shared key: it changes on
 		// every finished collapsed tool, and keying every entry on it re-rendered
 		// the entire transcript per tool completion. Only the entry that contains
@@ -1196,7 +1500,7 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 		// bytes at every tick, and keying it on time would drop the entry cache
 		// and the frozen prefix ten times a second. Only the panel-level guard
 		// above is time-keyed, so a tick re-renders the live tail and nothing else.
-		const baseKey = `${width}|${expandKey ?? ""}|${verbosity}|${liveToolOutput}`;
+		const baseKey = `${width}|${expandKey ?? ""}|${detail.toolBody}:${detail.runningTool}:${detail.thinking}:${detail.worker}:${detail.receipt}:${detail.errors}|${liveToolOutput}`;
 		const capacity = entryCacheCapacity();
 		if (frozen !== null && frozen.key !== baseKey) frozen = null;
 		const out: string[] = frozen === null ? [] : frozen.lines.slice();
@@ -1222,8 +1526,8 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 			const stacksOnPrevious =
 				entry.role === "worker" &&
 				previous?.role === "worker" &&
-				workerEntryFolded(entry, verbosity) &&
-				workerEntryFolded(previous, verbosity);
+				workerEntryFolded(entry, detail) &&
+				workerEntryFolded(previous, detail);
 			if (i > 0 && !stacksOnPrevious) out.push("");
 			const containsHint =
 				entryContainsHint(entry, latestHintToolId) ||
@@ -1245,8 +1549,9 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 					latestFoldedWorkerId,
 					nowMs,
 					unboundedToolBodies,
-					verbosity,
+					detail,
 					liveToolOutput,
+					liveReasoning,
 				);
 				for (const line of renderedEntry) out.push(line);
 				if (cacheable) {
@@ -1269,7 +1574,7 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 		cachedLines = out;
 		cachedWidth = width;
 		cachedExpandKey = expandKey;
-		cachedVerbosity = verbosity;
+		cachedDetail = detail;
 		cachedLiveToolOutput = liveToolOutput;
 		cachedTick = tick;
 		renderedRunningTool = sawRunningTool;
@@ -1283,8 +1588,8 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 			transcript.push({ role: "user", text });
 			markDirty();
 		},
-		appendReplayBlock(renderBlock: ReplayBlockRenderer): void {
-			transcript.push({ role: "replayBlock", renderBlock });
+		appendReplayBlock(renderBlock: ReplayBlockRenderer, isLive?: () => boolean, fold?: ReplayBlockFoldControl): void {
+			transcript.push({ role: "replayBlock", renderBlock, isLive, fold });
 			markDirty();
 		},
 		applyWorkerState(state: WorkerEntryState): void {
@@ -1296,7 +1601,7 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 				markDirty();
 				return;
 			}
-			const entry: WorkerTranscriptEntry = { role: "worker", state, folded: workerAskedByModel(state) };
+			const entry: WorkerTranscriptEntry = { role: "worker", state };
 			workerEntries.set(state.assignmentId, entry);
 			const at = workerInsertionIndex(state);
 			if (at === null) {
@@ -1313,13 +1618,26 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 			return [...workerEntries.values()].map((entry) => entry.state);
 		},
 		toggleLastToolExpanded(): boolean {
-			// Ctrl+O owns the newest foldable thing, whichever kind it is. A worker
+			// The key owns the newest foldable thing, whichever kind it is. A worker
 			// block the operator just watched land is what they mean by "expand
-			// that", not the tool call two screens up that spawned it.
+			// that", not the tool call two screens up that spawned it. Every flip
+			// is an override away from the block's effective state, so the same
+			// key opens a folded block under minimal and folds an open one under
+			// verbose.
+			const detail = currentDetail();
 			for (let entryIndex = transcript.length - 1; entryIndex >= 0; entryIndex -= 1) {
 				const entry = transcript[entryIndex];
+				// A caller-rendered block that owns fold state (the operator's own
+				// `!` bash row) is foldable too, and it is usually the newest thing
+				// on screen when the key is pressed.
+				if (entry?.role === "replayBlock" && entry.fold !== undefined) {
+					entry.fold.setFold(toggledFold(resolveFold(entry.fold.fold(), entry.fold.policyFold(detail))));
+					clearRenderCaches();
+					markDirty();
+					return true;
+				}
 				if (entry?.role === "worker") {
-					entry.folded = !entry.folded;
+					entry.fold = workerEntryFolded(entry, detail) ? "expanded" : "folded";
 					clearRenderCaches();
 					markDirty();
 					return true;
@@ -1328,7 +1646,7 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 				for (let segIndex = entry.segments.length - 1; segIndex >= 0; segIndex -= 1) {
 					const seg = entry.segments[segIndex];
 					if (seg?.kind !== "tool") continue;
-					seg.expanded = !seg.expanded;
+					seg.fold = toolSegmentExpanded(seg, detail) ? "folded" : "expanded";
 					clearRenderCaches();
 					markDirty();
 					return true;
@@ -1337,9 +1655,15 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 			return false;
 		},
 		toggleAllToolsExpanded(): boolean {
+			const detail = currentDetail();
 			const tools: ToolSegment[] = [];
 			const workers: WorkerTranscriptEntry[] = [];
+			const blocks: ReplayBlockFoldControl[] = [];
 			for (const entry of transcript) {
+				if (entry.role === "replayBlock") {
+					if (entry.fold !== undefined) blocks.push(entry.fold);
+					continue;
+				}
 				if (entry.role === "worker") {
 					workers.push(entry);
 					continue;
@@ -1349,61 +1673,70 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 					if (seg.kind === "tool") tools.push(seg);
 				}
 			}
-			if (tools.length === 0 && workers.length === 0) return false;
-			const expand = tools.some((seg) => !seg.expanded) || workers.some((entry) => entry.folded);
-			for (const seg of tools) seg.expanded = expand;
-			for (const entry of workers) entry.folded = !expand;
+			if (tools.length === 0 && workers.length === 0 && blocks.length === 0) return false;
+			// One folded block anywhere means "open everything"; otherwise fold
+			// everything. Either way every block gets an explicit override.
+			const expand =
+				tools.some((seg) => !toolSegmentExpanded(seg, detail)) ||
+				workers.some((entry) => workerEntryFolded(entry, detail)) ||
+				blocks.some((fold) => resolveFold(fold.fold(), fold.policyFold(detail)) === "folded");
+			const next: Fold = expand ? "expanded" : "folded";
+			for (const seg of tools) seg.fold = next;
+			for (const entry of workers) entry.fold = next;
+			for (const fold of blocks) fold.setFold(next);
 			clearRenderCaches();
 			markDirty();
 			return true;
 		},
-		collapseAllTools(): void {
-			for (const entry of transcript) {
-				if (entry.role === "worker") {
-					// The settled view for a worker is its origin default, not
-					// universally folded: the operator's own run is the one block
-					// /run exists to show them.
-					entry.folded = workerAskedByModel(entry.state);
-					continue;
-				}
-				if (entry.role !== "assistant") continue;
-				for (const seg of entry.segments) {
-					if (seg.kind === "tool") seg.expanded = false;
-				}
-			}
-			clearRenderCaches();
-			markDirty();
+		clearFoldOverrides(): void {
+			dropFoldOverrides();
 		},
 		toggleLastThinking(): boolean {
+			const detail = currentDetail();
 			for (let entryIndex = transcript.length - 1; entryIndex >= 0; entryIndex -= 1) {
 				const entry = transcript[entryIndex];
 				if (entry?.role !== "assistant") continue;
-				if (entry.thinking.length === 0) continue;
-				entry.expandedThinking = entry.expandedThinking !== true;
-				thinkingExpanded = entry.expandedThinking === true;
-				clearRenderCaches();
-				markDirty();
-				return true;
+				for (let segIndex = entry.segments.length - 1; segIndex >= 0; segIndex -= 1) {
+					const segment = entry.segments[segIndex];
+					if (segment?.kind !== "thinking" || segment.text.length === 0) continue;
+					segment.fold = thinkingExpanded(segment, detail) ? "folded" : "expanded";
+					clearRenderCaches();
+					markDirty();
+					return true;
+				}
 			}
-			thinkingExpanded = !thinkingExpanded;
-			return true;
+			return false;
 		},
 		toggleAllThinking(): boolean {
-			const entries: Array<Extract<TranscriptEntry, { role: "assistant" }>> = [];
+			const detail = currentDetail();
+			const segments: ThinkingSegment[] = [];
 			for (const entry of transcript) {
-				if (entry.role === "assistant" && entry.thinking.length > 0) entries.push(entry);
-			}
-			if (entries.length === 0) {
-				thinkingExpanded = !thinkingExpanded;
-				return true;
+				if (entry.role !== "assistant") continue;
+				for (const segment of entry.segments) {
+					if (segment.kind === "thinking" && segment.text.length > 0) segments.push(segment);
+				}
 			}
-			const expand = entries.some((entry) => entry.expandedThinking !== true);
-			for (const entry of entries) entry.expandedThinking = expand;
-			thinkingExpanded = expand;
+			if (segments.length === 0) return false;
+			const expand = segments.some((segment) => !thinkingExpanded(segment, detail));
+			for (const segment of segments) segment.fold = expand ? "expanded" : "folded";
 			clearRenderCaches();
 			markDirty();
 			return true;
 		},
+		isThinkingExpanded(): boolean {
+			// The live stretch lives on the newest assistant entry; its own override,
+			// if any, is the one that applies. Before a stretch arrives, the policy answers.
+			const detail = currentDetail();
+			const index = lastAssistantIndex(transcript);
+			const entry = index === null ? undefined : transcript[index];
+			if (entry?.role === "assistant") {
+				for (let segIndex = entry.segments.length - 1; segIndex >= 0; segIndex -= 1) {
+					const segment = entry.segments[segIndex];
+					if (segment?.kind === "thinking" && segment.text.length > 0) return thinkingExpanded(segment, detail);
+				}
+			}
+			return policyThinkingFold(detail) === "expanded";
+		},
 		toggleLiveToolOutput(): boolean {
 			liveToolOutput = !liveToolOutput;
 			markDirty();
@@ -1412,9 +1745,17 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 		reset(): void {
 			transcript.length = 0;
 			workerEntries.clear();
+			liveReasoning = UNMEASURED_REASONING;
 			clearRenderCaches();
 			markDirty();
 		},
+		markToolReplayed(toolCallId: string): void {
+			const owner = findToolSegmentOwner(toolCallId);
+			if (!owner || owner.segment.finished) return;
+			invalidateEntryCache(owner.entry);
+			owner.segment.replayed = true;
+			markDirty();
+		},
 		applyEvent(event: ChatLoopEvent): void {
 			if (event.type === "agent_status") {
 				return;
@@ -1439,6 +1780,50 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 				markDirty();
 				return;
 			}
+			if (event.type === "message_update") {
+				const assistantEvent = event.assistantMessageEvent as {
+					type?: unknown;
+					contentIndex?: unknown;
+					partial?: { content?: unknown };
+				};
+				if (
+					assistantEvent.type !== "toolcall_start" &&
+					assistantEvent.type !== "toolcall_delta" &&
+					assistantEvent.type !== "toolcall_end"
+				) {
+					return;
+				}
+				const index = typeof assistantEvent.contentIndex === "number" ? assistantEvent.contentIndex : -1;
+				const content = Array.isArray(assistantEvent.partial?.content) ? assistantEvent.partial.content : [];
+				const block = content[index];
+				if (block === null || typeof block !== "object" || Array.isArray(block)) return;
+				const streamed = block as { type?: unknown; id?: unknown; name?: unknown; arguments?: unknown };
+				if (streamed.type !== "toolCall" || typeof streamed.id !== "string" || streamed.id.length === 0) return;
+				const owner = findToolSegmentOwner(streamed.id);
+				const existing = owner?.segment;
+				if (existing && !existing.finished && !existing.executionStarted) {
+					if (owner) invalidateEntryCache(owner.entry);
+					existing.name = typeof streamed.name === "string" && streamed.name.length > 0 ? streamed.name : existing.name;
+					existing.args = streamed.arguments ?? existing.args;
+					existing.argsComplete = assistantEvent.type === "toolcall_end";
+				} else if (existing === undefined) {
+					const assistant = ensureAssistant();
+					assistant.pending = true;
+					closeOpenThinking(assistant);
+					assistant.segments.push({
+						kind: "tool",
+						id: streamed.id,
+						name: typeof streamed.name === "string" && streamed.name.length > 0 ? streamed.name : "tool",
+						args: streamed.arguments ?? {},
+						finished: false,
+						executionStarted: false,
+						argsComplete: assistantEvent.type === "toolcall_end",
+						isError: false,
+					});
+				}
+				markDirty();
+				return;
+			}
 			if (event.type === "text_delta") {
 				const assistant = ensureAssistant();
 				assistant.pending = true;
@@ -1447,20 +1832,34 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 				return;
 			}
 			if (event.type === "thinking_delta") {
-				// Capture for downstream consumers but never render inline.
+				// The text itself is never rendered unless the operator expands it;
+				// the segment is what keeps reasoning in its place in the stream.
 				const assistant = ensureAssistant();
 				assistant.pending = true;
-				assistant.thinking += event.delta;
-				assistant.expandedThinking = thinkingExpanded;
+				appendThinkingDelta(assistant, event.delta);
 				markDirty();
 				return;
 			}
 			if (event.type === "message_start" && event.message.role === "assistant") {
-				ensureAssistant().pending = true;
+				const assistant = ensureAssistant();
+				assistant.pending = true;
+				assistant.messageStartSegmentIndex = assistant.segments.length;
 				markDirty();
 				return;
 			}
 			if (event.type === "tool_execution_start") {
+				const streamedOwner = findToolSegmentOwner(event.toolCallId);
+				if (streamedOwner !== undefined && !streamedOwner.segment.finished && !streamedOwner.segment.executionStarted) {
+					invalidateEntryCache(streamedOwner.entry);
+					const streamed = streamedOwner.segment;
+					streamed.name = event.toolName;
+					streamed.args = event.args;
+					streamed.executionStarted = true;
+					streamed.argsComplete = true;
+					streamed.startedAtMs = now();
+					markDirty();
+					return;
+				}
 				// A model that reuses a tool-call id across calls would leave the
 				// prior same-id segment unsettled (its end matches the first segment
 				// on lookup). Settle any such orphan now, wherever it lives, so it
@@ -1472,18 +1871,20 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 					}
 				}
 				const assistant = ensureAssistant();
-				// Compact resource reads (SKILL.md, CLIO-CODER.md, AGENTS.md, docs/) stay
-				// collapsed to one labeled line until explicitly expanded.
-				const expanded = assistant.pending === false && classifyResourceRead(event.toolName, event.args) === null;
+				// No fold is stored here: the segment's effective state is resolved
+				// per frame from the transcript detail policy and the tool's
+				// registered presentation, with the operator's override on top.
 				assistant.pending = true;
+				closeOpenThinking(assistant);
 				assistant.segments.push({
 					kind: "tool",
 					id: event.toolCallId,
 					name: event.toolName,
 					args: event.args,
 					finished: false,
+					executionStarted: true,
+					argsComplete: true,
 					isError: false,
-					expanded,
 					startedAtMs: now(),
 				});
 				markDirty();
@@ -1499,24 +1900,22 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 				const tool = owner?.segment;
 				if (tool && !tool.finished) {
 					tool.awaitingApproval = event.state === "awaiting-approval" ? true : undefined;
+					tool.approvalView = event.state === "awaiting-approval" ? event.view : undefined;
 					markDirty();
 				}
 				return;
 			}
 			if (event.type === "tool_execution_update") {
-				// pi-agent emits `partialResult` as a cumulative tool-result envelope
-				// (the bash tool concatenates its rolling tail buffer on every tick).
-				// Unwrap with the same helper the finished-result path uses, then
-				// REPLACE `partialOutput` rather than appending: the upstream
-				// semantics are cumulative, so appending would double-print every
-				// snapshot. Render dispatch picks up the new buffer on the next
-				// frame via `renderToolSegmentLines`.
+				// pi-agent emits `partialResult` as a cumulative AgentToolResult.
+				// Preserve that full envelope so the renderer can use structured
+				// progress details as well as content. Replace rather than append:
+				// Pi's update semantics are cumulative, and appending would duplicate
+				// every earlier snapshot.
 				const owner = findToolSegmentOwner(event.toolCallId);
 				if (owner) invalidateEntryCache(owner.entry);
 				const tool = owner?.segment;
 				if (tool && !tool.finished) {
-					const unwrapped = unwrapResultEnvelope(event.partialResult);
-					tool.partialOutput = typeof unwrapped === "string" ? unwrapped : previewResult(unwrapped);
+					tool.partialResult = event.partialResult;
 				}
 				markDirty();
 				return;
@@ -1568,32 +1967,57 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 					// expanded render switches to `renderToolExecution` and stays
 					// stable instead of churning through partial-frame layout. A
 					// denied park settles here too, so the awaiting styling must go.
-					tool.partialOutput = undefined;
+					tool.partialResult = undefined;
 					tool.awaitingApproval = undefined;
+					tool.approvalView = undefined;
 				}
 				markDirty();
 				return;
 			}
 			if (event.type === "message_end") {
+				const current = transcript[transcript.length - 1];
+				let completedStreamedArgs = false;
+				if (current?.role === "assistant") {
+					for (const segment of current.segments) {
+						if (segment.kind !== "tool" || segment.finished || segment.executionStarted || segment.argsComplete) continue;
+						segment.argsComplete = true;
+						completedStreamedArgs = true;
+					}
+					if (completedStreamedArgs) invalidateEntryCache(current);
+				}
 				const text = extractAssistantText(event.message);
 				const thinking = extractAssistantThinking(event.message);
 				const extractedTerminalError = extractAssistantTerminalError(event.message);
-				const current = transcript[transcript.length - 1];
 				const terminalError =
 					current?.role === "assistant"
 						? scopeTerminalErrorAfterSuccessfulTool(current, extractedTerminalError)
 						: extractedTerminalError;
 				const usage = assistantUsage(event.message);
-				if (text.length === 0 && thinking.length === 0 && terminalError.length === 0 && usage === undefined) return;
+				if (text.length === 0 && thinking.length === 0 && terminalError.length === 0 && usage === undefined) {
+					if (completedStreamedArgs) markDirty();
+					return;
+				}
 				const assistant = ensureAssistant();
 				// message_end rewrites exactly one entry: the assistant it lands on.
 				invalidateEntryCache(assistant);
 				if (usage !== undefined) assistant.turnUsage = usage;
 				if (terminalError.length > 0) assistant.isError = true;
+				// The message is settled, so whatever reasoning it streamed is closed.
+				// A message that carried thinking the panel never saw as deltas (a
+				// non-streaming provider, a replayed message) gets one segment at the
+				// point this message began, ahead of the text the same message
+				// produced, rather than a marker dangling after the answer.
+				closeOpenThinking(assistant);
 				if (thinking.length > 0) {
-					assistant.thinking = thinking;
-					assistant.expandedThinking = thinkingExpanded;
+					const messageStart = Math.min(assistant.messageStartSegmentIndex ?? 0, assistant.segments.length);
+					const streamedThisMessage = assistant.segments
+						.slice(messageStart)
+						.some((segment) => segment.kind === "thinking" && segment.text.length > 0);
+					if (!streamedThisMessage) {
+						assistant.segments.splice(messageStart, 0, { kind: "thinking", text: thinking, finalized: true });
+					}
 				}
+				assistant.messageStartSegmentIndex = undefined;
 				// The chat loop marks messages it sanitized after streaming (dead
 				// tool-call markup on a synthesis-locked turn); the streamed tail
 				// must be replaced, not kept alongside a duplicate segment.
@@ -1664,13 +2088,26 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 					}
 					if (entry.pending) {
 						invalidateEntryCache(entry);
+						closeOpenThinking(entry);
 						entry.pending = false;
 						entry.statusLine = null;
+						entry.messageStartSegmentIndex = undefined;
 					}
 				}
 				markDirty();
 			}
 		},
+		setLiveReasoning(view: ReasoningUsageView | null): void {
+			const next = view ?? UNMEASURED_REASONING;
+			if (next.tokens === liveReasoning.tokens && next.provenance === liveReasoning.provenance) return;
+			liveReasoning = next;
+			// The line lives on the pending tail entry, which the freeze may already
+			// cover if nothing has mutated since the last settle.
+			unfreezeTail();
+			const last = transcript[transcript.length - 1];
+			if (last !== undefined) invalidateEntryCache(last);
+			markDirty();
+		},
 		setStatusLine(line): void {
 			if (line) {
 				const assistant = ensureAssistant();