pi-aside 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.2.0
+
+- The panel is never an empty box: before the first words it shows Pi's spinner with `working` and the seconds so
+  far, then `thinking` with the last lines of the model's thinking.
+- Asides answer sooner on models that take effort changes mid-conversation (the Claude models with
+  `supportsMidConvoEffort`, Responses models with `configuration_update`): they think at a `low` effort, sent as the
+  trailing configuration item, so the cache read is unchanged. A second dry run proves that only that item differs;
+  otherwise the main session's level is kept.
+- Answers, thinking and the `/aside` reader render as Markdown.
+- Enter on an empty editor puts the panel away: the frame collapses to one line, and a second Enter clears it.
+  The frame shows `↵ hides` while the editor is empty.
+- ctrl+o (Pi's "more") expands a long answer to the terminal's room and reopens a collapsed panel; Pi still
+  toggles its tool output. A truncated answer ends with `… ctrl+o more`.
+- The `/aside` reader opens at the latest question, and its lines wrap at the frame instead of being cut.
+- `aside:done` carries `effort`, `firstTextMs` and `totalMs`.
+
 ## 0.1.0
 
 First release.

package/README.md

@@ -42,8 +42,10 @@ or from a checkout: `pi install /path/to/pi-aside`.
 | Alt+Enter | Pi's meaning: a follow-up. |
 | Another `?` message while the answer is shown | Continues the side conversation. |
 | Send anything to the agent | The answer collapses to one dim line. |
+| Enter on an empty editor | Puts the answer away: first to one dim line, then gone. The frame shows `↵ hides` while the editor is empty. |
+| ctrl+o (Pi's "more") | Expands a long answer, or reopens a collapsed one. Pi still toggles its tool output. |
 | `/aside <question>` | Asks on the side, busy or not. |
-| `/aside` | Opens the latest side conversation in a reader. Esc closes it. |
+| `/aside` | Opens the latest side conversation in a reader, at the latest question. Esc closes it. |
 | Tab on an empty editor when `⇥ suggestion` is shown | Accepts the aside's suggested instruction for the agent. Enter sends it, with the side Q&A attached as a note. |
 | Esc | Pi's meaning: aborts the agent. pi-aside never takes focus. |
 

package/docs/implementation.md

@@ -72,12 +72,48 @@ as cache read plus cache write. OpenAI APIs report no cache writes, so the prefi
 plus cache read). Anthropic reports the counts in its first stream event, so the figure is available while the main
 reply still streams.
 
-### 2.6 Not implemented
+### 2.6 Asides think at a low effort when that keeps the cache (amends design §4.2 C2, C3)
+
+An aside inherited the main session's thinking level. At `xhigh` the panel stayed empty for seconds while the
+model thought about a side question. Some models take effort changes in the middle of a conversation
+(`compat.supportsMidConvoEffort`): pi-ai then sends the level as a trailing configuration item (E: an Anthropic
+`system` item with `output_config.effort`, a Responses `configuration_update`), after the cached prefix, and keeps
+the top-level fields unchanged.
+
+On such models the aside asks at `low` when the main level is higher (`asideLevel` in `src/fork.ts`; a level the
+model's `thinkingLevelMap` lacks or maps to nothing is not used). The change is proved, not assumed: when the fork
+is made, a second dry run of T at the lower level must differ from B0 in E only (same core, same other top-level
+fields). Then C2 compares B1 with that dry run, and C3 compares E(F) with its E instead of E(P). Every other check
+is unchanged, so the request still extends P byte for byte up to E. Without the proof the aside keeps the main
+level. T1 uses the same rule on its own requests.
+
+Measured on the Anthropic relay (Claude Opus 5.5, main at `xhigh`, idle aside, two runs each): the first words came
+after 3.8 s at the main level and after 1.7–1.9 s at `low`; the cache read was the same (3,557 tokens, `exact`).
+
+### 2.7 The panel while an answer has no words yet, Markdown, and putting it away (amends ux §3.2)
+
+- Before the first words the panel shows Pi's spinner with `working` and the seconds so far. Once the model
+  thinks, the line says `thinking` and the last three lines of its (summarized) thinking follow, dim and italic.
+  Tool calls show as before (`reading src/a.ts`), with the spinner. While the answer streams, the spinner sits in
+  the title.
+- Answers, thinking and the reader are rendered with Pi's Markdown component and Markdown theme.
+- Enter on an empty editor puts the panel away: the frame collapses to its one dim line, and the next such Enter
+  clears that line. Pi does nothing on an empty Enter, so no meaning changes. While the editor is empty, the
+  frame's lower edge says `↵ hides`. A handoff suggestion goes away with the panel. `/aside` still rereads the
+  thread.
+- Pi's "more" key (`app.tools.expand`, ctrl+o, which Pi's own header teaches as `ctrl+o more`) also expands the
+  aside: a long answer gets the terminal's room (its height minus 14 lines) instead of 10 lines, and a collapsed
+  panel opens again. Pi still toggles its tool output, so the key keeps its meaning: show more. A truncated answer
+  ends with `… ctrl+o more` (the key as bound); an answer longer than the room ends with `… /aside to read all`.
+- The `/aside` reader opens at the latest question instead of the first.
+
+### 2.8 Not implemented
 
 - **The fork-point breakpoint (ux §5.5).** The aside's markers are pi-ai's defaults. When the main cache has
   expired, the aside pays the cold write, and the money line says so.
 - **A `background-work` emitter in pi-durable-subagents.** Until an emitter exists, "busy" means running, as ux §3.1
-  specifies for that case.
+  specifies for that case. So while the agent is idle and only subagents run, a `?` message goes to the agent as a
+  prompt (seen in real use, dsa 1.2.0); `/aside <question>` asks on the side meanwhile.
 - **The user studies of ux §6 (U1) and the 40-message misroute set (U8).** Both need real users and a real model.
   The route check is implemented and tested with scripted replies.
 
@@ -96,7 +132,8 @@ interaction, in a private tmux server. Nothing touches `~/.pi` or the network.
 | Fallbacks | A handler that rewrites the transcript, which gives T1 with a fresh session id; no main request yet, which gives T1 with the session's system prompt. |
 | Order | A payload replacement by an extension loaded after pi-aside (the tap). Loading as an installed package. |
 | Follow-ups | The fork continues; after the main session moves, it forks again with the earlier exchange quoted. |
-| TUI | The hint, a busy `?` asked on the side and never seen by the main session, collapse on the next send, CJK `？`, a steer without `?`, an idle `?` as a prompt, Esc aborting with the panel visible, Tab accepting the suggestion and Enter sending it with the side note, `route: agent` sent as a steer, a failed aside sent as a steer, a bracketed paste, and the waiting state. |
+| TUI | The hint, a busy `?` asked on the side and never seen by the main session, collapse on the next send, CJK `？`, a steer without `?`, an idle `?` as a prompt, Esc aborting with the panel visible, Tab accepting the suggestion and Enter sending it with the side note, `route: agent` sent as a steer, a failed aside sent as a steer, a bracketed paste, the waiting state, the spinner and thinking before the first words, Markdown, and Enter on an empty editor putting the panel away. |
+| Effort | On models with mid-conversation effort, the aside's E carries `low` and everything else matches the main request (Anthropic and Responses); other models keep the main level. |
 | Units | The text rules (71 gate cases), strip, lists, C1–C3, the observer state machine, the usage queue, background work, placeholders, the notice, money. |
 
 ### 3.2 Real provider (2026-10-21, a few cents in total)

package/docs/ux.md

@@ -1,6 +1,6 @@
 # pi-aside: interaction design
 
-Status: implemented, revision 5 (§4: Enter is routed through Pi's `input` event, and the ghost text is a line below the editor; §3.2: an answer still streaming does not collapse; see `implementation.md` §2). Revision 4: busy includes waiting for subagents (§3.1, §3.8), and follow-ups see the latest main state (§3.2). This document covers only what the user sees and does. The engine in `design.md`
+Status: implemented, revision 6 (§3.2: the panel is never an empty box, renders Markdown, and an Enter on an empty editor puts it away). Revision 5 (§4: Enter is routed through Pi's `input` event, and the ghost text is a line below the editor; §3.2: an answer still streaming does not collapse; see `implementation.md` §2). Revision 4: busy includes waiting for subagents (§3.1, §3.8), and follow-ups see the latest main state (§3.2). This document covers only what the user sees and does. The engine in `design.md`
 (observation, T0/T1, C1–C3, routing, accounting) changes in two places only: follow-ups fork again when the main session has moved (§3.2), and a fork-point breakpoint is proposed (§5.5). Revision 1 is critiqued in §7.
 
 ## 1. The goal
@@ -102,9 +102,18 @@ question mark is a steer, exactly as today.
   `T ++ G ++ Q ++ A1 ++ Q2`.
 - **Dismissal needs no key.** When the user next sends anything to the agent, the panel collapses to one dim line
   (`▸ why did it pick B?`). An answer still streaming stays expanded: the user is waiting for it. The next aside replaces it, and a session switch clears it.
+- **Putting it away by hand is the same Enter.** Enter on an empty editor sends nothing, so it collapses the panel
+  the same way, and a second one clears the line (revision 6). While the editor is empty, the frame's lower edge
+  says `↵ hides`. `/aside` still rereads the thread.
+- **Never an empty box.** Before the first words, the panel shows Pi's spinner with `working` and the seconds so
+  far; once the model thinks, `thinking` and the last lines of its thinking, dim. Answers render as Markdown.
+  On models that take effort changes mid-conversation, an aside thinks at a low effort, which keeps the cache
+  (`implementation.md` §2.6), so its first words come sooner.
 - **Long answers.** While streaming, the panel shows the last 10 lines. When the answer is done, it shows the
-  first 10 lines and `… /aside to read all`. `/aside` with no argument opens the latest aside in a reader overlay.
-  The reader is an explicit modal with its own footer, and Esc closes it, as in every Pi selector.
+  first 10 lines and `… ctrl+o more`: Pi's own "more" key expands the aside with everything else (revision 6),
+  up to the terminal's room, and reopens a collapsed panel. Beyond that, `… /aside to read all`. `/aside` with no argument opens the latest aside in a reader overlay.
+  The reader is an explicit modal with its own footer, opens at the latest question, and Esc closes it, as in
+  every Pi selector.
 - Read-only tools run silently. A dim line such as `reading src/adapter.ts` appears while one runs.
 - **The session does not fork.** The side thread is an in-memory continuation of the main request
   (`design.md` §4.2: `T ++ G ++ Q`, where G is what the branch gained since the observed request). It sees the
@@ -203,10 +212,11 @@ The aside request itself answers the routing question, so no extra request is ne
 
 | Key | Meaning | New? |
 |---|---|---|
-| Enter | Send. While busy, a question-mark ending asks on the side unless the route check finds a request or correction (shown before sending) | Extended, visibly |
+| Enter | Send. While busy, a question-mark ending asks on the side unless the route check finds a request or correction (shown before sending). On an empty editor, put the aside panel away (`↵ hides` on its frame) | Extended, visibly |
 | Alt+Enter | Queue a follow-up | Pi |
 | Esc | Abort the agent; close the reader overlay | Pi |
 | Tab | Autocomplete, which now also accepts the handoff ghost text in an empty editor | Pi |
+| ctrl+o | Show more: Pi's tool output, and now the aside panel too | Pi |
 
 Revision 1 had Tab with three meanings, Esc meaning "dismiss", and a focus mode. Revision 2 has no new key.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-aside",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Pi extension: ask a side question about a running session without touching it, at the cache-read price.",
   "type": "module",
   "license": "MIT",

package/src/fork.ts

@@ -14,7 +14,9 @@ import {
 	type Delta,
 	deepEqual,
 	diffTopLevel,
+	differsOnlyInConfig,
 	type Payload,
+	splitList,
 	T0_APIS,
 } from "./payload.ts";
 import { OWN_REQUEST } from "./tap.ts";
@@ -131,8 +133,12 @@ export interface Fork {
 		thinkingBudgets: unknown;
 		blockImages: boolean;
 	};
+	/** The thinking level the aside sends with, when lower than the main session's (see `asideLevel`). */
+	effort?: string;
 	/** T0 only. */
 	b0?: Payload;
+	/** T0 with `effort`: the dry run of T at the aside's effort; it differs from B0 only in E. */
+	b0e?: Payload;
 	delta?: Delta;
 	modelSnapshot?: Any;
 	/** Number of entries in the session branch when the fork was made. */
@@ -151,11 +157,36 @@ export interface SendResult {
 	sent?: Payload;
 }
 
-function baseOptions(env: ForkEnv, fork: Fork, model: Any, signal: AbortSignal | undefined): Any {
+/** The effort an aside asks for: quick answers, so its first words arrive soon. */
+export const ASIDE_LEVEL = "low";
+const LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"];
+
+/**
+ * The thinking level for an aside: `ASIDE_LEVEL` when the main session's is higher and the model takes effort
+ * changes mid-conversation (`compat.supportsMidConvoEffort`: pi-ai sends the level as a trailing configuration item,
+ * after the cached prefix), otherwise the main session's level. A level the model maps to nothing is not used.
+ */
+export function asideLevel(model: Any, level: string | undefined): string | undefined {
+	if (!level || model?.compat?.supportsMidConvoEffort !== true) return level;
+	const map = model.thinkingLevelMap;
+	if (map && typeof map === "object" && (map[ASIDE_LEVEL] === null || (Object.keys(map).length > 0 && !(ASIDE_LEVEL in map)))) {
+		return level;
+	}
+	const i = LEVELS.indexOf(level);
+	return i > LEVELS.indexOf(ASIDE_LEVEL) ? ASIDE_LEVEL : level;
+}
+
+function baseOptions(
+	env: ForkEnv,
+	fork: Fork,
+	model: Any,
+	signal: AbortSignal | undefined,
+	reasoning: string | undefined = fork.effort ?? fork.recipe.reasoning,
+): Any {
 	const settings = env.settings();
 	const opts = requestOptions(settings);
 	return {
-		reasoning: fork.recipe.reasoning,
+		reasoning,
 		sessionId: fork.recipe.sessionId,
 		transport: fork.recipe.transport,
 		thinkingBudgets: fork.recipe.thinkingBudgets,
@@ -179,9 +210,15 @@ async function finish(stream: Any): Promise<Any> {
 }
 
 /** B0: the dry conversion of T; onPayload records the payload and aborts before any request is sent. */
-export async function dryRun(env: ForkEnv, fork: Fork, model: Any, messages: unknown[]): Promise<Payload> {
+export async function dryRun(
+	env: ForkEnv,
+	fork: Fork,
+	model: Any,
+	messages: unknown[],
+	reasoning: string | undefined = fork.recipe.reasoning,
+): Promise<Payload> {
 	let captured: Payload | undefined;
-	const options = baseOptions(env, fork, model, undefined);
+	const options = baseOptions(env, fork, model, undefined, reasoning);
 	options.onPayload = (payload: unknown) => {
 		captured = structuredClone(payload) as Payload;
 		throw new Fallback("dry run");
@@ -248,6 +285,19 @@ async function prepareExact(env: ForkEnv, observation: Observation, branchLength
 	fork.b0 = b0;
 	fork.delta = delta;
 	fork.pHash = await sha256(canonical(p));
+	// A lower effort is used only when the dry conversion proves that it changes nothing but E.
+	const lower = asideLevel(snapshot, recipe.reasoning);
+	if (lower !== recipe.reasoning) {
+		try {
+			const b0e = await dryRun(env, fork, structuredClone(snapshot), observation.transcript, lower);
+			if (differsOnlyInConfig(recipe.api, b0e, b0) && !deepEqual(b0e, b0)) {
+				fork.effort = lower;
+				fork.b0e = b0e;
+			}
+		} catch {
+			// the main session's level
+		}
+	}
 	return fork;
 }
 
@@ -312,11 +362,13 @@ export function makeRebuilt(env: ForkEnv, observation: Observation | undefined,
 	}
 	const level = recipe?.reasoning ?? (env.thinkingLevel() === "off" ? undefined : env.thinkingLevel());
 	const settings = env.settings();
+	const lower = asideLevel(env.registry.find(provider, modelId), level);
 	return {
 		tier: "rebuilt",
 		reason,
 		base,
 		observation,
+		...(lower !== level ? { effort: lower } : {}),
 		recipe: {
 			provider,
 			modelId,
@@ -364,7 +416,9 @@ async function demote(
 	fork.tier = "rebuilt";
 	fork.reason = reason;
 	fork.recipe = rebuilt.recipe;
+	fork.effort = rebuilt.effort;
 	fork.b0 = undefined;
+	fork.b0e = undefined;
 	fork.delta = undefined;
 	return sendRebuilt(env, fork, messages, signal, onEvent);
 }
@@ -409,13 +463,13 @@ async function sendExact(
 			restart = true;
 			throw new Fallback("restart");
 		}
-		const c2 = checkC2(recipe.api, fork.b0!, b1 as Payload, p);
+		const c2 = checkC2(recipe.api, fork.b0e ?? fork.b0!, b1 as Payload, p);
 		if (!c2.ok) {
 			fallback = c2.reason;
 			throw new Fallback(c2.reason);
 		}
 		const f = applyDelta(b1 as Payload, fork.delta!);
-		const c3 = checkC3(recipe.api, f, p);
+		const c3 = checkC3(recipe.api, f, p, fork.b0e ? splitList(recipe.api, fork.b0e)?.config : undefined);
 		if (!c3.ok) {
 			fallback = c3.reason;
 			throw new Fallback(c3.reason);

package/src/index.ts

@@ -1,12 +1,23 @@
 // pi-aside: ask a side question about a running Pi session without touching it, at the cache-read price.
 // Engine: docs/design.md. Interaction: docs/ux.md.
 
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { getKeybindings } from "@earendil-works/pi-tui";
+import { type ExtensionAPI, type ExtensionContext, getMarkdownTheme, keyText } from "@earendil-works/pi-coding-agent";
+import { getKeybindings, Markdown } from "@earendil-works/pi-tui";
 import { BackgroundWork } from "./busy.ts";
 import type { ForkEnv } from "./fork.ts";
 import { Observer, type Recipe } from "./observe.ts";
-import { MONEY_THRESHOLD, type PanelState, Reader, type ReaderTurn, renderBelow, renderPanel } from "./panel.ts";
+import {
+	type MarkdownRenderer,
+	MONEY_THRESHOLD,
+	PANEL_LINES,
+	type PanelState,
+	plainText,
+	Reader,
+	type ReaderTurn,
+	renderBelow,
+	renderPanel,
+	SPIN_MS,
+} from "./panel.ts";
 import { endsWithQuestionMark, routeEnter } from "./qmark.ts";
 import { parseReply } from "./reply.ts";
 import { AsideThread, type TurnView } from "./thread.ts";
@@ -23,6 +34,28 @@ const STATUS_KEY = "pi-aside";
 const SIDE_NOTE_TYPE = "aside";
 const REBUILT_NOTICE_AFTER = 3;
 
+/** Pi's Markdown component with Pi's Markdown theme; the last few renders are kept (the spinner redraws often). */
+function markdownRenderer(theme: Any): MarkdownRenderer {
+	const cache = new Map<string, string[]>();
+	return (text, width, style) => {
+		const key = `${style ?? ""}|${width}|${text}`;
+		const hit = cache.get(key);
+		if (hit) return hit;
+		let lines: string[];
+		try {
+			const textStyle = style === "thinking" ? { color: (s: string) => theme.fg("dim", s), italic: true } : undefined;
+			lines = new Markdown(text, 0, 0, getMarkdownTheme(), textStyle).render(Math.max(10, width)).map((line) => line.replace(/\s+$/u, ""));
+			while (lines.length > 0 && lines.at(-1) === "") lines.pop();
+			while (lines.length > 0 && lines[0] === "") lines.shift();
+		} catch {
+			lines = plainText(text, width);
+		}
+		if (cache.size >= 8) cache.delete(cache.keys().next().value!);
+		cache.set(key, lines);
+		return lines;
+	};
+}
+
 export default function piAside(pi: ExtensionAPI): void {
 	const observer = new Observer();
 	let ctxRef: ExtensionContext | undefined;
@@ -36,6 +69,7 @@ export default function piAside(pi: ExtensionAPI): void {
 	let rebuiltInARow = 0;
 	let rebuiltNoticeShown = false;
 	let unsubscribeInput: (() => void) | undefined;
+	let ticker: ReturnType<typeof setInterval> | undefined;
 
 	const usage = new UsageQueue({
 		state: () => (ctxRef ? { idle: ctxRef.isIdle(), sessionId: ctxRef.sessionManager.getSessionId() } : undefined),
@@ -131,7 +165,7 @@ export default function piAside(pi: ExtensionAPI): void {
 	function resetSession(ctx: ExtensionContext | undefined): void {
 		thread?.abort();
 		thread = undefined;
-		panel = { turns: [], collapsed: false };
+		panel = { turns: [], collapsed: false, expanded: panel.expanded };
 		handoff = undefined;
 		acceptedHandoff = undefined;
 		rebuiltInARow = 0;
@@ -263,7 +297,7 @@ export default function piAside(pi: ExtensionAPI): void {
 		if (!continuing) {
 			thread?.abort();
 			thread = new AsideThread(threadHost());
-			panel = { turns: thread.turns, collapsed: false };
+			panel = { turns: thread.turns, collapsed: false, expanded: panel.expanded };
 		} else if (thread!.busy) {
 			thread!.abort();
 		}
@@ -271,6 +305,7 @@ export default function piAside(pi: ExtensionAPI): void {
 		handoff = undefined;
 		acceptedHandoff = undefined;
 		panel.collapsed = false;
+		panel.hidden = false;
 		panel.sentToAgent = undefined;
 		showPanel(true);
 		refreshBelow();
@@ -338,6 +373,7 @@ export default function piAside(pi: ExtensionAPI): void {
 			parts.push(`rebuilt: not expected to hit${turn.reason ? ` (${turn.reason})` : ""}`);
 			parts.push(`read ${fmt(turn.read)}, wrote ${fmt(turn.written)}`);
 		}
+		if (turn.effort) parts.push(`thinking ${turn.effort}`);
 		parts.push(`$${turn.cost.toFixed(turn.cost < MONEY_THRESHOLD ? 3 : 2)}`);
 		return parts.join(" · ");
 	}
@@ -351,6 +387,9 @@ export default function piAside(pi: ExtensionAPI): void {
 			read: turn.read,
 			written: turn.written,
 			predicted: turn.predicted,
+			effort: turn.effort,
+			firstTextMs: turn.firstTextAt === undefined ? undefined : turn.firstTextAt - turn.startedAt,
+			totalMs: Date.now() - turn.startedAt,
 			cost: turn.cost,
 			error: turn.error,
 			aborted: turn.aborted === true,
@@ -401,7 +440,14 @@ export default function piAside(pi: ExtensionAPI): void {
 	async function openReader(ctx: ExtensionContext): Promise<void> {
 		await ctx.ui.custom<void>(
 			(tui: Any, theme: Any, _keybindings: Any, done: (result: void) => void) =>
-				new Reader(readerTurns, theme, () => done(undefined), () => tui.requestRender(), () => tui.terminal?.rows ?? process.stdout.rows ?? 40),
+				new Reader(
+					readerTurns,
+					theme,
+					() => done(undefined),
+					() => tui.requestRender(),
+					() => tui.terminal?.rows ?? process.stdout.rows ?? 40,
+					markdownRenderer(theme),
+				),
 			{ overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } as Any },
 		);
 	}
@@ -410,7 +456,8 @@ export default function piAside(pi: ExtensionAPI): void {
 
 	function renderNow(): void {
 		if (ctxRef?.mode !== "tui") return;
-		showPanel(panel.turns.length > 0);
+		showPanel(panel.turns.length > 0 && !panel.hidden);
+		animate();
 		try {
 			tuiRef?.requestRender();
 		} catch {
@@ -418,6 +465,54 @@ export default function piAside(pi: ExtensionAPI): void {
 		}
 	}
 
+	/** Whether the panel shows an answer still running (its spinner turns). */
+	function spinning(): boolean {
+		const turn = panel.turns.at(-1);
+		return !!turn && !turn.done && !panel.hidden && !panel.sentToAgent;
+	}
+
+	/** Redraw at the spinner's pace while an answer runs. */
+	function animate(): void {
+		if (ticker || !spinning()) return;
+		ticker = setInterval(() => {
+			if (!spinning() || ctxRef?.mode !== "tui") {
+				clearInterval(ticker);
+				ticker = undefined;
+			}
+			try {
+				tuiRef?.requestRender();
+			} catch {
+				// not mounted
+			}
+		}, SPIN_MS);
+		ticker.unref?.();
+	}
+
+	/** ctrl+o (`app.tools.expand`): a collapsed panel opens again, expanded; otherwise expanded and compact toggle. */
+	function toggleMore(): void {
+		if (panel.collapsed && !panel.hidden && panel.turns.length > 0) {
+			panel.collapsed = false;
+			panel.expanded = true;
+		} else {
+			panel.expanded = !panel.expanded;
+		}
+		renderNow();
+	}
+
+	/**
+	 * Enter on an empty editor puts the panel away (docs/ux.md §3.2): the frame collapses to one dim line, and the
+	 * next such Enter clears that line. The thread stays readable with `/aside`.
+	 */
+	function putAway(): boolean {
+		if (panel.turns.length === 0 || panel.hidden) return false;
+		if (panel.collapsed) panel.hidden = true;
+		else panel.collapsed = true;
+		handoff = undefined;
+		renderNow();
+		refreshBelow();
+		return true;
+	}
+
 	function showPanel(show: boolean): void {
 		const ctx = ctxRef;
 		if (!ctx || ctx.mode !== "tui") return;
@@ -432,7 +527,20 @@ export default function piAside(pi: ExtensionAPI): void {
 				PANEL_WIDGET,
 				(tui: Any, theme: Any) => {
 					tuiRef = tui;
-					return { render: (width: number) => renderPanel(panel, width, theme), invalidate() {} };
+					const md = markdownRenderer(theme);
+					return {
+						render: (width: number) => {
+							const rows = tui?.terminal?.rows ?? process.stdout.rows ?? 40;
+							panel.maxLines = Math.max(PANEL_LINES, rows - 14);
+							try {
+								panel.moreKey = keyText("app.tools.expand") || undefined;
+							} catch {
+								panel.moreKey = undefined;
+							}
+							return renderPanel(panel, width, theme, md, Date.now());
+						},
+						invalidate() {},
+					};
 				},
 				{ placement: "aboveEditor" },
 			);
@@ -462,6 +570,7 @@ export default function piAside(pi: ExtensionAPI): void {
 		if (!ctx || ctx.mode !== "tui") return;
 		const state = belowState();
 		belowCache = state;
+		panel.editorEmpty = editorText().trim() === "";
 		const show = state.hint || state.ghost !== undefined;
 		try {
 			if (show !== belowShown) {
@@ -483,6 +592,22 @@ export default function piAside(pi: ExtensionAPI): void {
 		}
 	}
 
+	function editorText(): string {
+		try {
+			return ctxRef?.ui.getEditorText() ?? "";
+		} catch {
+			return "";
+		}
+	}
+
+	/** Whether Pi's input editor has the focus (not a selector, a dialog or another extension's overlay). */
+	function editorFocused(): boolean {
+		const focus = tuiRef?.getFocusedComponent;
+		if (typeof focus !== "function") return true;
+		const focused = focus.call(tuiRef);
+		return !!focused && typeof focused === "object" && focused.actionHandlers instanceof Map;
+	}
+
 	function installTui(ctx: ExtensionContext): void {
 		unsubscribeInput?.();
 		unsubscribeInput = undefined;
@@ -491,6 +616,11 @@ export default function piAside(pi: ExtensionAPI): void {
 		if (ctx.mode !== "tui") return;
 		unsubscribeInput = ctx.ui.onTerminalInput((data) => {
 			const kb = getKeybindings();
+			if (kb.matches(data, "tui.input.submit") && editorText().trim() === "" && editorFocused() && putAway()) {
+				return { consume: true };
+			}
+			// Pi's "more" (ctrl+o) expands the aside with everything else; Pi still toggles its tool output.
+			if (kb.matches(data, "app.tools.expand") && editorFocused()) toggleMore();
 			if (handoff && kb.matches(data, "tui.input.tab")) {
 				let text = "";
 				try {

package/src/panel.ts

@@ -10,16 +10,54 @@ import type { TurnView } from "./thread.ts";
 type Theme = any;
 
 export const PANEL_LINES = 10;
+/** Lines of the model's thinking shown while no answer text has arrived. */
+export const THINKING_LINES = 3;
 export const MONEY_THRESHOLD = 0.25;
 export const HINT = "↵ asks on the side · corrections still reach the agent";
+/** On the panel's lower edge while the editor is empty: Enter there puts the panel away (docs/ux.md §3.2). */
+export const HIDE_HINT = "↵ hides";
+
+/** Pi's own loader frames. */
+export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export const SPIN_MS = 80;
+
+export function spinnerFrame(now: number): string {
+	return SPINNER[Math.floor(now / SPIN_MS) % SPINNER.length]!;
+}
 
 export interface PanelState {
 	turns: TurnView[];
+	/** One dim line instead of the frame. */
 	collapsed: boolean;
+	/** Not shown at all (`/aside` still rereads the thread). */
+	hidden?: boolean;
+	/** Whether the editor is empty: the lower edge then shows `HIDE_HINT`. */
+	editorEmpty?: boolean;
+	/** Pi's "more" toggle (`app.tools.expand`, ctrl+o) is on: the answer gets up to `maxLines` lines. */
+	expanded?: boolean;
+	/** Lines an expanded answer may take (from the terminal height). */
+	maxLines?: number;
+	/** The key that toggles "more", as Pi shows it (`ctrl+o`). */
+	moreKey?: string;
 	/** Set when the route check sent the text to the agent. */
 	sentToAgent?: { text: string; waiting: boolean };
 }
 
+/** Markdown to terminal lines; `thinking` text is rendered dim and italic. */
+export type MarkdownRenderer = (text: string, width: number, style?: "thinking") => string[];
+
+function wrap(text: string, width: number): string[] {
+	const out: string[] = [];
+	for (const line of text.split("\n")) {
+		if (line === "") out.push("");
+		else out.push(...wrapTextWithAnsi(line, Math.max(10, width)));
+	}
+	return out;
+}
+
+/** Plain wrapping, for tests and when Pi's Markdown component is unavailable. */
+export const plainText: MarkdownRenderer = (text, width) => wrap(text, width);
+
 function formatCost(cost: number): string {
 	return `$${cost.toFixed(2)}`;
 }
@@ -32,17 +70,37 @@ export function moneyLine(turn: TurnView): string | undefined {
 	return undefined;
 }
 
-function wrap(text: string, width: number): string[] {
-	const out: string[] = [];
-	for (const line of text.split("\n")) {
-		if (line === "") out.push("");
-		else out.push(...wrapTextWithAnsi(line, Math.max(10, width)));
+function elapsed(turn: TurnView, now: number): string {
+	const seconds = Math.floor((now - turn.startedAt) / 1000);
+	return seconds >= 1 ? ` · ${seconds}s` : "";
+}
+
+/** The end of a long thinking text, cut at a paragraph or line start so that its Markdown stays whole. */
+function thinkingTail(text: string): string {
+	const trimmed = text.trimEnd();
+	if (trimmed.length <= 600) return trimmed;
+	const tail = trimmed.slice(-600);
+	const cut = tail.indexOf("\n");
+	return cut >= 0 && cut < tail.length - 1 ? tail.slice(cut + 1) : tail;
+}
+
+/**
+ * The live line of an answer in progress: a spinner, what is happening and for how long, and while the model thinks,
+ * the last lines of its thinking. Shown until the answer's first words, and during a tool call.
+ */
+export function progressLines(turn: TurnView, width: number, theme: Theme, md: MarkdownRenderer, now: number): string[] {
+	const spin = theme.fg("accent", spinnerFrame(now));
+	const dim = (s: string) => theme.fg("dim", s);
+	if (turn.activity) return [`${spin} ${dim(`${turn.activity}${elapsed(turn, now)}`)}`];
+	if (turn.thinking?.trim()) {
+		const tail = md(thinkingTail(turn.thinking), Math.max(10, width - 2), "thinking").filter((line) => line.trim() !== "");
+		return [`${spin} ${dim(`thinking${elapsed(turn, now)}`)}`, ...tail.slice(-THINKING_LINES).map((line) => `  ${line}`)];
 	}
-	return out;
+	return [`${spin} ${dim(`working${elapsed(turn, now)}`)}`];
 }
 
 /** Body lines of the panel for its current state (without the frame). */
-export function panelBody(state: PanelState, width: number, theme: Theme): string[] {
+export function panelBody(state: PanelState, width: number, theme: Theme, md: MarkdownRenderer = plainText, now = Date.now()): string[] {
 	const turn = state.turns.at(-1);
 	if (!turn) return [];
 	const dim = (s: string) => theme.fg("dim", s);
@@ -51,15 +109,16 @@ export function panelBody(state: PanelState, width: number, theme: Theme): strin
 	}
 	const lines: string[] = [];
 	const parsed = parseReply(turn.raw, turn.done);
-	const body = wrap(parsed.body, width);
+	const body = parsed.body ? md(parsed.body, width) : [];
+	const limit = state.expanded ? Math.max(PANEL_LINES, state.maxLines ?? PANEL_LINES) : PANEL_LINES;
 	if (!turn.done) {
-		lines.push(...body.slice(-PANEL_LINES));
-		if (turn.activity) lines.push(dim(turn.activity));
-		else if (body.length === 0) lines.push(dim("…"));
+		lines.push(...body.slice(-limit));
+		if (turn.activity || body.length === 0) lines.push(...progressLines(turn, width, theme, md, now));
 	} else {
-		if (body.length > PANEL_LINES) {
-			lines.push(...body.slice(0, PANEL_LINES));
-			lines.push(dim("… /aside to read all"));
+		if (body.length > limit) {
+			lines.push(...body.slice(0, limit));
+			const more = !state.expanded && state.moreKey ? `${state.moreKey} more` : "/aside to read all";
+			lines.push(dim(`… ${more}`));
 		} else {
 			lines.push(...body);
 		}
@@ -71,21 +130,37 @@ export function panelBody(state: PanelState, width: number, theme: Theme): strin
 	return lines;
 }
 
-/** The framed panel (rounded box with the question as title), or one dim line when collapsed. */
-export function renderPanel(state: PanelState, width: number, theme: Theme): string[] {
+/**
+ * The framed panel (rounded box with the question as its title, a spinner before it while the answer streams, and
+ * `↵ hides` on the lower edge while the editor is empty), one dim line when collapsed, nothing when hidden.
+ */
+export function renderPanel(state: PanelState, width: number, theme: Theme, md: MarkdownRenderer = plainText, now = Date.now()): string[] {
 	const turn = state.turns.at(-1);
-	if (!turn) return [];
+	if (!turn || state.hidden) return [];
 	const border = (s: string) => theme.fg("borderMuted", s);
-	if (state.collapsed) return [truncateToWidth(theme.fg("dim", `▸ ${turn.question.replace(/\s+/g, " ")}`), width)];
+	const question = turn.question.replace(/\s+/g, " ");
+	const running = !turn.done && !state.sentToAgent;
+	if (state.collapsed) {
+		const mark = running ? theme.fg("accent", spinnerFrame(now)) : theme.fg("dim", "▸");
+		return [truncateToWidth(`${mark} ${theme.fg("dim", question)}`, width)];
+	}
 	const inner = Math.max(10, width - 4);
-	const title = truncateToWidth(` ${turn.question.replace(/\s+/g, " ")} `, Math.max(4, width - 6), "…");
+	// The spinner sits in the title while the answer streams, and on the progress line before it (never both).
+	const progress = !!turn.activity || parseReply(turn.raw, turn.done).body === "";
+	const spin = running && !progress ? `${spinnerFrame(now)} ` : "";
+	const title = truncateToWidth(` ${spin}${question} `, Math.max(4, width - 6), "…");
 	const top = border("╭─") + theme.fg("muted", title) + border(`${"─".repeat(Math.max(0, width - 3 - visibleWidth(title)))}╮`);
 	const out = [truncateToWidth(top, width)];
-	for (const line of panelBody(state, inner, theme)) {
-		const text = truncateToWidth(line, inner);
+	for (const line of panelBody(state, inner, theme, md, now)) {
+		const text = truncateToWidth(line.replace(/\s+$/u, ""), inner);
 		out.push(`${border("│")} ${text}${" ".repeat(Math.max(0, inner - visibleWidth(text)))} ${border("│")}`);
 	}
-	out.push(border(`╰${"─".repeat(Math.max(0, width - 2))}╯`));
+	const hint = state.editorEmpty ? ` ${HIDE_HINT} ` : "";
+	if (hint && width >= visibleWidth(hint) + 6) {
+		out.push(border(`╰${"─".repeat(Math.max(0, width - 3 - visibleWidth(hint)))}`) + theme.fg("dim", hint) + border("─╯"));
+	} else {
+		out.push(border(`╰${"─".repeat(Math.max(0, width - 2))}╯`));
+	}
 	return out;
 }
 
@@ -103,7 +178,7 @@ export interface ReaderTurn {
 	detail: string;
 }
 
-/** The `/aside` reader: every question and answer of the latest thread, scrollable; Esc closes. */
+/** The `/aside` reader: every question and answer of the latest thread, opened at the latest question; Esc closes. */
 export class Reader {
 	private offset = 0;
 	private lastHeight = 20;
@@ -114,15 +189,21 @@ export class Reader {
 		private readonly done: () => void,
 		private readonly requestRender: () => void,
 		private readonly rows: () => number,
+		private readonly md: MarkdownRenderer = plainText,
 	) {}
 
+	/** Where the latest question starts: the reader opens there, like a conversation opens at its end. */
+	private latestStart = 0;
+	private opened = false;
+
 	private lines(width: number): string[] {
 		const out: string[] = [];
 		const inner = Math.max(10, width - 2);
 		for (const turn of this.turns()) {
+			this.latestStart = out.length;
 			out.push(...wrap(this.theme.fg("accent", `? ${turn.question}`), inner));
 			out.push("");
-			out.push(...wrap(turn.answer, inner));
+			out.push(...this.md(turn.answer, inner).map((line) => line.replace(/\s+$/u, "")));
 			out.push(...wrap(this.theme.fg("dim", turn.detail), inner));
 			out.push("");
 		}
@@ -132,8 +213,12 @@ export class Reader {
 	render(width: number): string[] {
 		const height = Math.max(5, Math.floor(this.rows() * 0.8) - 2);
 		this.lastHeight = height;
-		const all = this.lines(width);
+		const all = this.lines(width - 2);
 		const max = Math.max(0, all.length - height);
+		if (!this.opened) {
+			this.opened = true;
+			this.offset = this.latestStart;
+		}
 		if (this.offset > max) this.offset = max;
 		const view = all.slice(this.offset, this.offset + height);
 		const border = (s: string) => this.theme.fg("borderMuted", s);

package/src/payload.ts

@@ -223,12 +223,27 @@ export function checkC2(api: string, b0: Payload, b1: Payload, p: Payload): Chec
 	return ok;
 }
 
-/** C3, on the bytes sent: F's top-level fields equal P's, and strip(core(F)) extends strip(core(P)). */
-export function checkC3(api: string, f: Payload, p: Payload): CheckResult {
+/**
+ * Whether two dry conversions of the same transcript differ only in their trailing configuration items E: the same
+ * core and the same other top-level fields. This is what proves that a lower aside effort keeps the cache prefix.
+ */
+export function differsOnlyInConfig(api: string, a: Payload, b: Payload): boolean {
+	const sa = splitList(api, a);
+	const sb = splitList(api, b);
+	if (!sa || !sb) return false;
+	if (!deepEqual(strip(sa.core), strip(sb.core))) return false;
+	return otherFieldsEqual(api, a, b) === undefined;
+}
+
+/**
+ * C3, on the bytes sent: F's top-level fields equal P's, and strip(core(F)) extends strip(core(P)). E(F) equals E(P),
+ * or `expectedConfig` when the aside runs at its own effort (proved by `differsOnlyInConfig` on the dry runs).
+ */
+export function checkC3(api: string, f: Payload, p: Payload, expectedConfig?: unknown[]): CheckResult {
 	const sf = splitList(api, f);
 	const sp = splitList(api, p);
 	if (!sf || !sp) return fail("no content list");
-	if (!deepEqual(strip(sf.config), strip(sp.config))) return fail("the trailing configuration differs from the observed request");
+	if (!deepEqual(strip(sf.config), strip(expectedConfig ?? sp.config))) return fail("the trailing configuration differs from the observed request");
 	if (!extendsList(sf.core, sp.core)) return fail("the request does not extend the observed request");
 	const field = otherFieldsEqual(api, f, p);
 	if (field) return fail(`\`${field}\` differs from the observed request`);

package/src/thread.ts

@@ -39,6 +39,13 @@ export interface TurnView {
 	error?: string;
 	/** A dim activity line, such as `reading src/a.ts`. */
 	activity?: string;
+	/** The model's (summarized) thinking in the current request, while no answer text has arrived. */
+	thinking?: string;
+	/** When the question was asked, and when the answer's first text arrived (ms since the epoch). */
+	startedAt: number;
+	firstTextAt?: number;
+	/** The thinking level the aside used, when lower than the main session's. */
+	effort?: string;
 	tier?: Tier;
 	reason?: string;
 	cost: number;
@@ -66,6 +73,14 @@ function textOf(message: Any): string {
 		.join("");
 }
 
+function thinkingOf(message: Any): string {
+	if (!message || !Array.isArray(message.content)) return "";
+	return message.content
+		.filter((c: Any) => c?.type === "thinking" && typeof c.thinking === "string")
+		.map((c: Any) => c.thinking)
+		.join("\n\n");
+}
+
 function activityFor(call: Any): string {
 	const args = call.arguments ?? {};
 	switch (call.name) {
@@ -140,7 +155,7 @@ export class AsideThread {
 
 	/** Ask a question in this thread. Resolves when the answer is complete, failed or aborted. */
 	async ask(question: string, options: { routeCheck: boolean; onRoute?: (route: "side" | "agent") => void }): Promise<TurnView> {
-		const turn: TurnView = { question, raw: "", done: false, cost: 0, read: 0, written: 0 };
+		const turn: TurnView = { question, raw: "", done: false, startedAt: Date.now(), cost: 0, read: 0, written: 0 };
 		this.turns.push(turn);
 		const controller = new AbortController();
 		this.controller = controller;
@@ -175,6 +190,7 @@ export class AsideThread {
 			const fork = this.fork!;
 			turn.tier = fork.tier;
 			turn.reason = fork.reason;
+			turn.effort = fork.effort;
 			turn.predicted = fork.observation?.cacheablePrefix;
 			const q = {
 				role: "user",
@@ -188,6 +204,8 @@ export class AsideThread {
 				const result: SendResult = await send(this.host.env, fork, [...this.exchange, ...added], signal, (event: Any) => {
 					if (event?.partial) {
 						turn.raw = textBefore + textOf(event.partial);
+						turn.thinking = thinkingOf(event.partial) || undefined;
+						if (turn.firstTextAt === undefined && turn.raw.trim() !== "") turn.firstTextAt = Date.now();
 						reportRoute();
 						update();
 					}
@@ -195,6 +213,8 @@ export class AsideThread {
 				const message = result.message;
 				turn.tier = result.tier;
 				turn.reason = result.reason ?? turn.reason;
+				turn.effort = fork.effort;
+				turn.thinking = undefined;
 				this.account(fork, result, turn);
 				added.push(message);
 				turn.raw = textBefore + textOf(message);
@@ -231,6 +251,7 @@ export class AsideThread {
 		} finally {
 			turn.done = true;
 			turn.activity = undefined;
+			turn.thinking = undefined;
 			if (this.controller === controller) this.controller = undefined;
 			reportRoute();
 			update();