@kushalkhemka/opensec-pi-subagents 0.20.3 → 0.20.4

package/CHANGELOG.md

@@ -7,6 +7,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.20.4] - 2026-10-16
+
+The conversation viewer draws a subagent's transcript with Pi's own chat components, so it looks exactly like Pi's
+main session.
+
+> **Possibly breaking:** the `viewerMarkdown` setting (`/agents → Settings → Viewer markdown`) and the viewer's `m`
+> key are removed: Pi's components decide how each message renders. A `viewerMarkdown` key left in `subagents.json`
+> is ignored.
+
+### Changed
+
+- **The conversation viewer (regular overlay and fullscreen observer) renders like Pi's main session.** It builds
+  `UserMessageComponent`, `AssistantMessageComponent` (thinking and text), `ToolExecutionComponent` (each tool's own
+  call and result renderers from the subagent's session: edit diffs, read previews, bash command, output, exit status
+  and duration, running/done/error state, arguments), `BashExecutionComponent`, `CompactionSummaryMessageComponent`,
+  `BranchSummaryMessageComponent`, `SkillInvocationMessageComponent` and `CustomMessageComponent` from the session's
+  messages as Pi's interactive mode does, with the same spacing and collapsed defaults. Streaming messages, tool
+  progress and results update live. It replaces the viewer's own `[User]` / `[Assistant]` / `[Tool: name]` /
+  `[Result]` rendering and its 16k-character result cap (Pi's renderers truncate collapsed output themselves).
+- **`ctrl+o` expands and collapses tool output in the viewer**, as in Pi; it follows a rebinding of Pi's
+  `app.tools.expand`, and the footer shows it when there is room. Pi's `hideThinkingBlock`, `outputPad` and
+  `markdown.codeBlockIndent` settings apply.
+- Each component is built once and its rendered lines are cached per width and expand state; a frame re-renders only
+  the streamed message and tools that changed, scrolling never re-renders, and only visible rows are assembled.
+  Without a JIT (Bun with `BUN_JSC_useJIT=0`, standing in for Pi-Bolt), at 500 messages: a frame 6 µs, a scroll step
+  15 µs, a streaming delta 0.70 ms (was 0.92 ms), a tool call finishing 0.26 ms (was 0.31 ms), the first frame 121 ms
+  (was 160 ms). A new user message costs 0.27 ms (was 0.17 ms): Pi's user message is Markdown on a background.
+- Where the viewer differs from Pi's main session: images in tool results show as Pi's text placeholder, since an
+  inline image cannot be clipped to a scrolled overlay; Mermaid blocks are not drawn as diagrams (Pi's Mermaid
+  transformer is not exported); OSC 133 prompt marks are not emitted inside the overlay; clicking a tool or thinking
+  block does not toggle it (use `ctrl+o`).
+
+### Removed
+
+- The `viewerMarkdown` setting and the viewer's `m` key (see above).
+
 ## [0.20.3] - 2026-10-16
 
 Background agents survive a session switch, subagents run on the parent's model by default, and nested and workflow

package/README.md

@@ -108,6 +108,28 @@ appears under one of them after 2 s. In the conversation viewer (FleetView, `/ag
   run moves from the foreground to the background concurrency pool, over the limit if the pool is full.
 - Nested agents, workflow agents, queued spawns and resumed runs cannot be handed off.
 
+### Conversation viewer
+
+Opening an agent (FleetView, `/agents`, the workflow inspector's `c`) shows its conversation drawn by Pi's own chat
+components, exactly as Pi draws the main session: user and assistant messages with thinking blocks, each tool call
+with its arguments and its tool's own result rendering (edit diffs, read previews, bash command, output, exit status
+and duration, running/done/error state), `!` bash runs, compaction and branch summaries, skill blocks and extension
+messages. Tool renderers come from the subagent's own session, so an extension tool draws as it does in Pi. A message
+that is still streaming and a tool that is still running update live.
+
+- `ctrl+o` expands and collapses tool output, as in Pi (it follows a rebinding of Pi's `app.tools.expand`).
+- Pi's `hideThinkingBlock`, `outputPad` and `markdown.codeBlockIndent` settings apply, read when the viewer opens.
+- Agent output is sanitized before Pi's components see it: escape and control sequences in messages, tool arguments
+  and results are removed (Pi's own styling is kept).
+- Not the same as the main session: images in tool results show as Pi's text placeholder (an inline image cannot be
+  clipped to a scrolled overlay), Mermaid blocks are not drawn as diagrams (Pi's Mermaid renderer is not available to
+  extensions), and clicking a tool block or thinking block does not toggle it (use `ctrl+o`).
+- The `viewerMarkdown` setting and the viewer's `m` key were removed in 0.20.4; a `viewerMarkdown` key left in
+  `subagents.json` is ignored.
+- Cost: each message's component is built once and its rendered lines are kept; a frame re-renders only the streamed
+  message and tools that changed, and scrolling never re-renders. Without a JIT (Pi-Bolt) a frame takes about 5 µs and
+  a scroll step about 15 µs at any transcript length.
+
 ### Fullscreen conversation observer
 
 In Pi's fullscreen mode (`/settings → TUI mode → fullscreen`, Pi's default), an agent opened from FleetView, `/agents`
@@ -118,14 +140,15 @@ or pauses an agent, and `Esc` returns to the previous view (while composing, the
 - A one-column scrollbar in Pi's style that follows Pi's `/settings → Fullscreen scrollbar`: `auto` appears while
   scrolling or hovering and hides after a second, `always` stays, `hidden` removes it and its mouse target. Drag the
   thumb, or click the track to page. The column is kept free in `auto` mode too, so the bar never re-wraps the text.
-- Clickable footer controls (steer, send to background, stop with two clicks, Markdown mode, close).
+- Clickable footer controls (steer, send to background, stop with two clicks, expand tool output, close).
 - While scrolled away, the divider above the footer shows `[ ↓ N new messages · Ctrl+End ]` (conversation messages,
   not streaming updates); click it or press `Ctrl+End` to jump back and follow, without losing a steering draft.
 - Mouse events are consumed, so they never scroll, select or click the main view underneath. Text selection, copying
   and switching agents without leaving the observer are not implemented.
 - Cost: built on the viewer's incremental transcript, so scrolling, wheel and drags reuse cached lines, a frame checks
-  only the transcript's last message and draws only the visible rows, and nothing ticks while it is idle. Without a JIT
-  (Pi-Bolt), a frame or a scroll step costs well under a millisecond whatever the transcript's length.
+  only what changed and draws only the visible rows, and nothing ticks while it is idle (a running bash tool's elapsed
+  time redraws its block once a second, as in Pi). Without a JIT (Pi-Bolt), a frame or a scroll step costs well under a
+  millisecond whatever the transcript's length.
 
 ### Resuming agents
 

package/dist/index.js

@@ -541,14 +541,6 @@ export default function (pi) {
     let showModel = false;
     function isShowModelEnabled() { return showModel; }
     function setShowModel(b) { showModel = b; widget.update(); }
-    /**
-     * How much of the conversation viewer renders as Markdown. Read through a
-     * getter by the viewer rather than captured like `showCost`, because the
-     * viewer's `m` key writes back here while the overlay is on screen.
-     */
-    let viewerMarkdown = "assistant";
-    function getViewerMarkdown() { return viewerMarkdown; }
-    function setViewerMarkdown(mode) { viewerMarkdown = mode; }
     /** The `backgroundKey` setting as written; undefined means the default. Persisted as written. */
     let backgroundKeySetting;
     function setBackgroundKey(key) { backgroundKeySetting = key; }
@@ -557,16 +549,6 @@ export default function (pi) {
         const key = backgroundKeySetting ?? DEFAULT_BACKGROUND_KEY;
         return key === "off" ? undefined : key;
     }
-    /**
-     * The viewer's `m` key, from either entry point: set the mode and persist it,
-     * so the key and `/agents → Settings` stay one setting rather than one per
-     * entry point. `ctx` carries only the warning a failed write notifies with,
-     * and the fleet list may be acting without one.
-     */
-    function chooseViewerMarkdown(mode, ctx) {
-        setViewerMarkdown(mode);
-        persistSettings(ctx, `Viewer markdown set to ${mode}`);
-    }
     const pendingUsage = new PendingUsagePool();
     /**
      * Set once this activation's session is shutting down (`/new`, `/resume`,
@@ -1694,10 +1676,28 @@ export default function (pi) {
             return "auto";
         }
     }
+    /**
+     * Pi's chat settings the conversation viewer draws with, read from the main
+     * session's live settings and normalized as Pi's SettingsManager getters do,
+     * so a subagent's transcript looks like the main one.
+     */
+    function getViewerRenderOptions() {
+        try {
+            const settings = pi.getSettings();
+            return {
+                hideThinkingBlock: settings.hideThinkingBlock ?? false,
+                outputPad: settings.outputPad === 0 ? 0 : 1,
+                codeBlockIndent: settings.markdown?.codeBlockIndent ?? "  ",
+            };
+        }
+        catch {
+            return {};
+        }
+    }
     // Claude Code-style FleetView: navigable list of main + subagents below the editor.
-    // The last two arguments keep a conversation overlay opened here identical to
-    // one opened from `/agents`: same setting on the way in, same persist out.
-    const fleet = new FleetList(manager, agentActivity, isShowCostEnabled, getViewerMarkdown, (mode) => chooseViewerMarkdown(mode, currentCtx), refreshTicker, backgroundActionFor, getFullscreenScrollbar);
+    // The render options keep a conversation overlay opened here identical to one
+    // opened from `/agents`.
+    const fleet = new FleetList(manager, agentActivity, isShowCostEnabled, getViewerRenderOptions, refreshTicker, backgroundActionFor, getFullscreenScrollbar);
     let fleetViewEnabled = true;
     function isFleetViewEnabled() { return fleetViewEnabled; }
     function setFleetViewEnabled(b) { fleetViewEnabled = b; fleet.setEnabled(b); }
@@ -2015,7 +2015,6 @@ export default function (pi) {
         setReportUsage,
         setShowCost,
         setShowModel,
-        setViewerMarkdown,
         setBackgroundKey,
     };
     applyAndEmitLoaded(settingsAppliers, (event, payload) => pi.events.emit(event, payload), process.cwd(), projectTrusted);
@@ -3730,7 +3729,7 @@ Terse command-style prompts produce shallow, generic work.
                 if (manager.abort(record.id)) {
                     ctx.ui.notify(`Stopped "${record.description}".`, "info");
                 }
-            }, keybindings, (message) => manager.steer(record.id, message), showCost, getViewerMarkdown, (mode) => chooseViewerMarkdown(mode, ctx), backgroundActionFor(record, message => ctx.ui.notify(message, "info")), getFullscreenScrollbar());
+            }, keybindings, (message) => manager.steer(record.id, message), showCost, backgroundActionFor(record, message => ctx.ui.notify(message, "info")), getFullscreenScrollbar(), getViewerRenderOptions());
         }, {
             overlay: true,
             overlayOptions: () => overlayOptions,
@@ -4122,7 +4121,6 @@ Write the file using the write tool. Only write the file, nothing else.`;
             reportUsage: isReportUsageEnabled(),
             showCost: isShowCostEnabled(),
             showModel: isShowModelEnabled(),
-            viewerMarkdown: getViewerMarkdown(),
             // As written: undefined (the default) stays out of the file.
             backgroundKey: backgroundKeySetting,
         };
@@ -4292,13 +4290,6 @@ Write the file using the write tool. Only write the file, nothing else.`;
                     currentValue: isShowModelEnabled() ? "on" : "off",
                     values: ["on", "off"],
                 },
-                {
-                    id: "viewerMarkdown",
-                    label: "Viewer markdown",
-                    description: "How much of the conversation viewer renders as Markdown. assistant = assistant text only (default); all = tool results too, for tools that emit Markdown — accepting that a Markdown pass over a diff or a log eats `#` comments, swallows a `---` line and re-fences indented output; off = everything verbatim. `m` in the viewer cycles the same setting (footer: raw / md / md+).",
-                    currentValue: getViewerMarkdown(),
-                    values: ["off", "assistant", "all"],
-                },
                 {
                     id: "fleetView",
                     label: "Fleet view",
@@ -4485,10 +4476,6 @@ Write the file using the write tool. Only write the file, nothing else.`;
                 setShowModel(enabled);
                 notifyApplied(ctx, `Model display ${enabled ? "enabled" : "disabled"}`);
             }
-            else if (id === "viewerMarkdown") {
-                setViewerMarkdown(value);
-                notifyApplied(ctx, `Viewer markdown set to ${value}`);
-            }
             else if (id === "fleetView") {
                 const enabled = value === "on";
                 setFleetViewEnabled(enabled);
@@ -4590,23 +4577,6 @@ Write the file using the write tool. Only write the file, nothing else.`;
     // the right toast. Successful saves show info; persistence failures downgrade
     // to warning so users aren't silently reverted on restart. Event fires regardless
     // of outcome so listeners see the in-memory change.
-    /**
-     * Persist + broadcast the settings, silent on success — for a change whose
-     * feedback is the UI it just changed: the viewer's `m` key, where a
-     * notification per press would talk over the overlay it is describing.
-     *
-     * A *failed* write still speaks. Every other settings path warns when the
-     * value is session-only, and swallowing it here would leave a preference
-     * looking persisted when the next session will not have it.
-     */
-    function persistSettings(ctx, changeMsg) {
-        const { message, level } = saveAndEmitChanged(snapshotSettings(), changeMsg, (event, payload) => pi.events.emit(event, payload));
-        // `ctx` is absent only on the fleet path between sessions, where
-        // `currentCtx` has been cleared and there is no UI to carry the warning to.
-        // The write still happens.
-        if (level === "warning")
-            ctx?.ui.notify(message, level);
-    }
     function notifyApplied(ctx, successMsg) {
         const { message, level } = saveAndEmitChanged(snapshotSettings(), successMsg, (event, payload) => pi.events.emit(event, payload));
         ctx.ui.notify(message, level);

package/dist/session-handoff.d.ts

@@ -35,7 +35,7 @@
  */
 import { type ExtensionContext } from "@earendil-works/pi-coding-agent";
 /** The package version this code ships in. `test/session-handoff.test.ts` keeps it equal to package.json. */
-export declare const PACKAGE_VERSION = "0.20.3";
+export declare const PACKAGE_VERSION = "0.20.4";
 /** Bumped when the shape of a parked entry changes within one version (never in a release). */
 export declare const HANDOFF_PROTOCOL = 1;
 /** Writes an entry into the session `owner` if the caller can (it is the active one there); false otherwise. */

package/dist/session-handoff.js

@@ -36,7 +36,7 @@
 import { existsSync } from "node:fs";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 /** The package version this code ships in. `test/session-handoff.test.ts` keeps it equal to package.json. */
-export const PACKAGE_VERSION = "0.20.3";
+export const PACKAGE_VERSION = "0.20.4";
 /** Bumped when the shape of a parked entry changes within one version (never in a release). */
 export const HANDOFF_PROTOCOL = 1;
 const HANDOFF_KEY = Symbol.for("pi-subagents:handoff:@kushalkhemka/opensec-pi-subagents");

package/dist/settings.d.ts

@@ -1,4 +1,4 @@
-import type { AgentMentionMode, JoinMode, ViewerMarkdownMode, WidgetMode } from "./types.js";
+import type { AgentMentionMode, JoinMode, WidgetMode } from "./types.js";
 export type ProjectTrustMode = "full" | "pi";
 export interface SubagentsSettings {
     maxConcurrent?: number;
@@ -310,19 +310,6 @@ export interface SubagentsSettings {
      * narrow terminal.
      */
     showModel?: boolean;
-    /**
-     * How much of the conversation viewer's transcript renders as Markdown.
-     * Defaults to `assistant`. Applied live — the viewer's `m` key cycles this
-     * same setting, so a choice made in the overlay persists like one made in
-     * `/agents → Settings`.
-     *
-     * Scoped rather than all-or-nothing because the two kinds of content have
-     * different contracts: assistant text is authored as Markdown, while a tool
-     * result is whatever bytes the tool produced. Rendering the latter as
-     * Markdown is lossy in ways that look like the tool misbehaved — see
-     * `ViewerMarkdownMode` for the specific rewrites — so `all` is opt-in.
-     */
-    viewerMarkdown?: ViewerMarkdownMode;
     /**
      * The key that sends every running foreground `Agent` call to the background,
      * as Claude Code's ctrl+b does. A pi key id (`ctrl+b`, `alt+b`, `ctrl+shift+b`,
@@ -363,7 +350,6 @@ export interface SettingsAppliers {
     setReportUsage: (b: boolean) => void;
     setShowCost: (b: boolean) => void;
     setShowModel: (b: boolean) => void;
-    setViewerMarkdown: (mode: ViewerMarkdownMode) => void;
     setBackgroundKey: (key: string) => void;
 }
 /** Emit callback — a subset of `pi.events.emit` to keep helpers testable. */

package/dist/settings.js

@@ -9,7 +9,6 @@ import { createDiscoveryCache } from "./discovery-cache.js";
 const VALID_JOIN_MODES = new Set(["async", "group", "smart"]);
 const VALID_TOOL_DESCRIPTION_MODES = new Set(["full", "compact", "custom"]);
 const VALID_WIDGET_MODES = new Set(["all", "background", "off"]);
-const VALID_VIEWER_MARKDOWN_MODES = new Set(["off", "assistant", "all"]);
 const VALID_AGENT_MENTION_MODES = new Set(["model", "direct", "off"]);
 // Sanity ceilings — prevent hand-edited configs from asking for values that
 // make no operational sense (e.g. 1e6 concurrent subagents). Permissive enough
@@ -116,9 +115,7 @@ function sanitize(raw) {
     if (typeof r.showModel === "boolean") {
         out.showModel = r.showModel;
     }
-    if (typeof r.viewerMarkdown === "string" && VALID_VIEWER_MARKDOWN_MODES.has(r.viewerMarkdown)) {
-        out.viewerMarkdown = r.viewerMarkdown;
-    }
+    // `viewerMarkdown` (until 0.20.3) is ignored: the viewer draws with Pi's own components now.
     if (typeof r.backgroundKey === "string" && r.backgroundKey.trim()) {
         out.backgroundKey = r.backgroundKey.trim().toLowerCase();
     }
@@ -241,8 +238,6 @@ export function applySettings(s, appliers) {
         appliers.setShowCost(s.showCost);
     if (typeof s.showModel === "boolean")
         appliers.setShowModel(s.showModel);
-    if (s.viewerMarkdown)
-        appliers.setViewerMarkdown(s.viewerMarkdown);
     if (s.backgroundKey)
         appliers.setBackgroundKey(s.backgroundKey);
     if (typeof s.workflowsEnabled === "boolean")

package/dist/types.d.ts

@@ -100,20 +100,6 @@ export type JoinMode = 'async' | 'group' | 'smart';
  * - `off`: hide the widget entirely.
  */
 export type WidgetMode = 'all' | 'background' | 'off';
-/**
- * How much of the conversation viewer's transcript is rendered as Markdown.
- * - `off`: every line wraps as literal text, as it did before the mode existed.
- * - `assistant`: assistant text renders as Markdown; tool results stay verbatim
- *   and dim. The default, because assistant text *is* Markdown by contract
- *   while a tool result is arbitrary bytes — a Markdown pass over a log or a
- *   diff eats `#` from shell comments, swallows a `---` line into a setext
- *   heading, re-fences indented output and redraws `| a | b |` as a table.
- *   (Ordered-list renumbering is the one such rewrite actively suppressed —
- *   see `MARKDOWN_OPTIONS` — because it silently changes data, not layout.)
- * - `all`: tool results render as Markdown too, for tools that genuinely emit
- *   it (#210's `ctx_execute`), accepting the rewrites above on ones that don't.
- */
-export type ViewerMarkdownMode = 'off' | 'assistant' | 'all';
 /**
  * How `@handle message` starts an agent that is not already running.
  * - `model`: inject Claude Code's `agent_mention` reminder and let the main

package/dist/ui/conversation-viewer.d.ts

@@ -2,14 +2,19 @@
  * conversation-viewer.ts — Live conversation overlay for viewing agent sessions.
  *
  * Displays a scrollable, live-updating view of an agent's conversation.
- * Subscribes to session events for real-time streaming updates.
+ * Subscribes to session events for real-time streaming updates. The
+ * transcript is drawn with Pi's own chat components (`viewer-transcript.ts`),
+ * so it looks exactly like Pi's main session; the frame around it (header,
+ * footer, scrolling, steering) is the viewer's.
  */
 import { type AgentSession } from "@earendil-works/pi-coding-agent";
 import { type Component, type Focusable, type OverlayOptions, type ScrollViewScrollbar, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
-import type { AgentRecord, ViewerMarkdownMode } from "../types.js";
+import type { AgentRecord } from "../types.js";
 import type { Theme } from "./agent-widget.js";
 import { type AgentActivity } from "./agent-widget.js";
 import { type ViewerKeybindings } from "./viewer-keys.js";
+import { type ViewerRenderOptions } from "./viewer-transcript.js";
+export type { ViewerRenderOptions } from "./viewer-transcript.js";
 /** Height ceiling shared by the overlay's `maxHeight` and the viewer's internal viewport cap. */
 export declare const VIEWPORT_HEIGHT_PCT = 70;
 /**
@@ -18,18 +23,6 @@ export declare const VIEWPORT_HEIGHT_PCT = 70;
  * setting that may need a restart to take effect.
  */
 export declare function getConversationOverlayOptions(tui: Pick<TUI, "mode">): OverlayOptions;
-/**
- * Cap on a single tool result or bash output before the viewer elides the rest.
- *
- * The cap is not cosmetic — it bounds render cost. A message's lines are
- * rebuilt whenever the width or Markdown mode changes, and the streaming tail
- * on every frame it changes, so an uncapped 200 KB result costs ~6 ms per
- * rebuild to parse as Markdown, against ~0.5 ms once capped (best of 5, width
- * 76). 16 KB is roughly a screenful at every terminal size and still ~30x the
- * 500 characters this replaces, which was small enough to cut most real
- * results mid-sentence.
- */
-export declare const RESULT_MAX_CHARS = 16000;
 /** The `b` affordance: whether this run can be handed to the background now, and the handoff. */
 export interface ViewerBackgroundAction {
     available(): boolean;
@@ -52,17 +45,6 @@ export declare class ConversationViewer implements Component, Focusable {
      * cannot change while it is on screen.
      */
     private showCost;
-    /**
-     * The current `viewerMarkdown` setting. Read live rather than captured,
-     * unlike `showCost`: `m` changes it while the overlay is on screen.
-     * Omitted → `assistant`.
-     */
-    private viewerMarkdown?;
-    /**
-     * Persist a mode chosen with `m`, so the key and `/agents → Settings` mean
-     * the same thing. Omitted → `m` still cycles, viewer-locally.
-     */
-    private onMarkdownMode?;
     /**
      * Hand this run to the background. `available` is read live — it turns
      * false the instant the handoff lands or the run ends. Omitted → no `b`
@@ -107,39 +89,13 @@ export declare class ConversationViewer implements Component, Focusable {
     private keys;
     /** Steering composer — present while the user is typing a message to the agent. */
     private composer;
-    /** Resolved once: pi's Markdown theme is fixed for the life of the process. */
-    private readonly markdownTheme;
-    /** Set by the `m` key. Wins over the setting so `m` works without a persist hook. */
-    private markdownModeOverride;
-    /**
-     * One `Markdown` per message, so its own text/width cache does the work. A
-     * fresh instance per render would re-parse the whole transcript on every
-     * keystroke — the component caches, but only across calls to the same object.
-     * Weak so a compacted-away message doesn't pin its render.
-     */
-    private readonly markdownCache;
-    /**
-     * The transcript, kept between frames. `blocks[i]` renders `messages[i]`;
-     * `lines` holds every block's lines (and separators) in order, and
-     * `blockStart[i]` is where block `i`'s part of it begins. All of it is valid
-     * for `cacheWidth` and `cacheMode` only.
-     */
-    private blocks;
-    private blockStart;
-    private lines;
-    /** `lineWidths[i]` is the visible width of `lines[i]`, measured once when the line is built. */
-    private lineWidths;
     /**
-     * The messages array the cache was last validated against. Pi only appends
-     * to that array and replaces it wholesale otherwise, so while it is the same
-     * object only the unsettled tail needs checking — what keeps a frame's cost
-     * flat however long the transcript gets.
+     * The transcript drawn with Pi's components, its lines cached between
+     * frames. Undefined when Pi's theme is not initialized (see `plainLines`).
      */
-    private cacheMessages;
-    private cacheWidth;
-    private cacheMode;
-    /** Messages from this index on may still change in place; earlier ones are settled. */
-    private unsettledFrom;
+    private readonly transcript;
+    /** The plain fallback's lines and what they were built for. */
+    private plain;
     /** Pending coalesced redraw for streaming events. */
     private streamRenderTimer;
     constructor(tui: TUI, session: AgentSession, record: AgentRecord, activity: AgentActivity | undefined, theme: Theme, done: (result: undefined) => void, 
@@ -155,17 +111,6 @@ export declare class ConversationViewer implements Component, Focusable {
      * cannot change while it is on screen.
      */
     showCost?: boolean, 
-    /**
-     * The current `viewerMarkdown` setting. Read live rather than captured,
-     * unlike `showCost`: `m` changes it while the overlay is on screen.
-     * Omitted → `assistant`.
-     */
-    viewerMarkdown?: (() => ViewerMarkdownMode) | undefined, 
-    /**
-     * Persist a mode chosen with `m`, so the key and `/agents → Settings` mean
-     * the same thing. Omitted → `m` still cycles, viewer-locally.
-     */
-    onMarkdownMode?: ((mode: ViewerMarkdownMode) => void) | undefined, 
     /**
      * Hand this run to the background. `available` is read live — it turns
      * false the instant the handoff lands or the run ends. Omitted → no `b`
@@ -173,7 +118,9 @@ export declare class ConversationViewer implements Component, Focusable {
      */
     onBackground?: ViewerBackgroundAction | undefined, 
     /** Pi's `fullscreenScrollbar` preference, captured when the viewer opens. */
-    scrollbarMode?: ScrollViewScrollbar);
+    scrollbarMode?: ScrollViewScrollbar, 
+    /** Pi's chat settings (thinking blocks, padding, code indent), read when the viewer opens. */
+    renderOptions?: ViewerRenderOptions);
     handleInput(data: string): void;
     /** Follow the conversation again and clear the new-message count (fullscreen `Ctrl+End`). */
     private jumpToLatest;
@@ -217,12 +164,10 @@ export declare class ConversationViewer implements Component, Focusable {
      * matches spawns nobody can hand off (the agent generator).
      */
     private canSendToBackground;
-    /** The mode in force: an `m` press, else the setting, else the default. */
-    private markdownMode;
-    /** Wrap `text` literally — the pre-Markdown path, and the fallback from it. */
-    private rawLines;
-    /** Render `text` as Markdown, reusing this message's component instance. */
-    private markdownLines;
+    /** Expand or collapse every tool, bash and summary block, as Pi's `app.tools.expand`. */
+    private toggleExpand;
+    /** The expand toggle's footer control: the key bound to it and what it does next. */
+    private expandHint;
     /** Steerable only when a steer handler exists and the agent is still active. */
     private canSteer;
     /** Open the inline steering composer and route subsequent input to it. */
@@ -236,23 +181,16 @@ export declare class ConversationViewer implements Component, Focusable {
     buildContentLines(width: number): string[];
     private contentLength;
     /**
-     * The content area as cached transcript lines (`base`, owned by the viewer —
-     * do not mutate) plus the live activity indicator (`tail`).
-     *
-     * Only messages that changed are rebuilt. A message is matched to its block
-     * by identity; messages from `unsettledFrom` on (the last one when the
-     * previous frame was drawn, and anything after it) are also compared by
-     * content, because older pi streams into the last message in place and a
-     * message can be edited and then pushed past before the next frame. Earlier
-     * messages are settled: pi never rewrites a message once another follows it,
-     * and compaction replaces the objects, which the identity check catches.
+     * The content area as cached transcript lines (`base`, owned by the
+     * transcript — do not mutate) with their widths, plus the live activity
+     * indicator (`tail`). Only blocks that changed are re-rendered, so a frame
+     * where nothing changed costs a few comparisons however long the transcript.
      */
     private contentView;
     /**
-     * Everything a message's rendered lines depend on, besides width and mode.
-     * Cheap next to rendering: string joins, no wrapping or parsing.
+     * The transcript as plain wrapped text, for a process whose Pi theme is not
+     * initialized (Pi's components cannot render there). Never the case in Pi's
+     * interactive mode; it keeps the viewer usable rather than throwing.
      */
-    private messageSource;
-    /** One message's lines without its separator, clamped to `width`; undefined when it renders nothing. */
-    private messageLines;
+    private plainLines;
 }