@pellux/goodvibes-tui 2.0.21 → 2.1.0

package/src/core/conversation-splash-state.ts

@@ -4,7 +4,7 @@
  *
  * Two pieces of state, kept out of ConversationManager (core/conversation.ts,
  * already at its line-count gate) and out of `suppressSplash`, which is a
- * per-frame posture the panel workspace sets both ways on every render:
+ * per-frame posture the modal layer sets both ways on every render:
  *
  *   - `dismissed`, sticky for the run. Owner rule: the splash yields to ANY
  *     submission, a chat message or a slash command alike. A slash command
@@ -37,6 +37,11 @@ export class SplashGateState {
     return true;
   }
 
+  /** True while the last rebuild drew the splash (the shell centers it). */
+  get showing(): boolean {
+    return this.onScreen;
+  }
+
   /** Record that this rebuild drew the splash. */
   enter(): void {
     this.onScreen = true;

package/src/core/conversation-types.ts

@@ -47,4 +47,39 @@ export type BlockMeta = Omit<SdkBlockMeta, 'type'> & {
    * standalone tool results with no recorded name.
    */
   toolName?: string;
+  /**
+   * The collapse key that reveals each entry of groupMemberIndexes (same
+   * order): the bead body the result sits behind (work-tree-model.ts
+   * beadKeyOf). /expand opens them in the same pass that unfolds the turn,
+   * and search reveals a hit by opening exactly its bead.
+   */
+  groupMemberKeys?: readonly string[];
+  /**
+   * The work-tree row this block is, when it is one: 'turn' (a turn header),
+   * 'bead' (a tool call) or 'lane' (an agent lane's spawn or folded row). The
+   * keyboard moves between these rows (see ConversationManager focus methods).
+   */
+  workTree?: {
+    readonly kind: 'turn' | 'bead' | 'lane';
+    /** Focus identity, stable across rebuilds. */
+    readonly id: string;
+    /** The bead has a body to open (then ▸ shows). */
+    readonly hasBody: boolean;
+    /** The body is open. */
+    readonly open: boolean;
+    /** The body shows its first rows only ("… N more"). */
+    readonly capped: boolean;
+    /** Collapse key of the body's "… N more" (bead only). */
+    readonly moreKey?: string;
+    /** Whether the lane has finished (lane only). */
+    readonly finished?: boolean;
+    /** The lane this row sits on (bead rows inside an agent lane carry that lane's collapse key). */
+    readonly laneKey?: string;
+    /** The agent a lane row draws (Enter opens it full screen). */
+    readonly agentId?: string;
+    /** A lane row's color index (lane-graph/paint.ts laneColor): the agent's own color. */
+    readonly colorIndex?: number;
+    /** The background process a ▶ bead started (Enter opens its output). */
+    readonly processId?: string;
+  };
 };

package/src/core/conversation-usage.ts

@@ -0,0 +1,12 @@
+/**
+ * conversation-usage.ts, usage totals folded from a transcript's assistant
+ * messages (re-exported by conversation.ts).
+ *
+ * The fold is the SDK's (platform/core sumConversationUsage): a resumed
+ * session hydrates its token counters and its context figure from it. The
+ * context figure is the latest real turn request's; a follow-up
+ * acknowledgement (sent without tool definitions) counts toward the totals
+ * only, so the meter never drops to that smaller request's size.
+ */
+
+export { sumConversationUsage } from '@pellux/goodvibes-sdk/platform/core';

package/src/core/conversation.ts

@@ -12,22 +12,25 @@ import {
   type BlockMeta as SdkBlockMeta,
 } from '@pellux/goodvibes-sdk/platform/core';
 import type { BlockMeta } from './conversation-types.ts';
+import type { NoticeSink } from './notices.ts';
 import { MessageLineCache } from './conversation-line-cache.ts';
-import { UserReceiptIndices } from './conversation-user-receipts.ts';
 import { SplashGateState } from './conversation-splash-state.ts';
-import { resolveTranscriptEventLine } from './conversation-event-navigation.ts';
+import { nearestBlock, resolveTranscriptEventLine, wrapToLine } from './conversation-event-navigation.ts';
+import { DisplayOnlyOutput } from './conversation-display-only.ts';
 import { SearchExpansionTracker } from './conversation-search-expansion.ts';
 import {
   addConversationSplashScreen,
   conversationTextToLines,
   logConversationText,
   logConversationToolResult,
-  renderConversationAssistantMessage,
-  renderConversationSystemMessage,
-  renderConversationToolMessage,
-  renderConversationUserMessage,
 } from './conversation-rendering.ts';
 import { renderMarkdown } from '../renderer/markdown.ts';
+import type { WorkTreeSources } from './work-tree-sources.ts';
+import { renderStreamingContinuation } from './work-tree-render.ts';
+import { WorkTreeController } from './work-tree-focus.ts';
+import { isWorkTreeFoldKey } from './work-tree-fold-store.ts';
+import { resolveTreeGlyphSet, type TreeGlyphSetName } from '../renderer/lane-graph/glyphs.ts';
+import { probeUnicodeSupport } from '../renderer/term-caps.ts';
 
 /**
  * ConversationManager - TUI subclass of the SDK's ConversationManager.
@@ -62,39 +65,12 @@ type Message = ConversationMessageSnapshot;
 import type { OrchestratorUsageTotals } from '@pellux/goodvibes-sdk/platform/core';
 export type { OrchestratorUsageTotals };
 
-/**
- * sumConversationUsage - Fold every assistant message's per-turn usage into
- * running totals, plus the *last* assistant message's own input-token figure
- * (context-window occupancy, not a running sum).
- *
- * TUI-side counterpart to SDK Orchestrator.usage: after a session resume
- * replays historical messages into a freshly-constructed Orchestrator (whose
- * `usage` starts at all zeros, bootstrap.ts always constructs a fresh
- * instance, see), this lets the caller hydrate the footer's token
- * counters from messages that already carry real usage data instead of
- * waiting for the first new turn to populate them.
- */
-export function sumConversationUsage(
-  messages: readonly ConversationMessageSnapshot[],
-): { usage: OrchestratorUsageTotals; lastInputTokens: number } {
-  const usage: OrchestratorUsageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-  let lastInputTokens = 0;
-  for (const message of messages) {
-    if (message.role !== 'assistant' || !message.usage) continue;
-    usage.input += message.usage.inputTokens;
-    usage.output += message.usage.outputTokens;
-    usage.cacheRead += message.usage.cacheReadTokens ?? 0;
-    usage.cacheWrite += message.usage.cacheWriteTokens ?? 0;
-    // Context-window occupancy tracks the most recent turn only, not a sum.
-    lastInputTokens = message.usage.inputTokens
-      + (message.usage.cacheReadTokens ?? 0)
-      + (message.usage.cacheWriteTokens ?? 0);
-  }
-  return { usage, lastInputTokens };
-}
+export { sumConversationUsage } from './conversation-usage.ts';
 
 export class ConversationManager extends SdkConversationManager {
   public history = new InfiniteBuffer();
+  /** Display-only output kept for redraw (conversation-display-only.ts). */
+  private readonly displayOnly = new DisplayOnlyOutput();
   private _getWidth: () => number;
   /** Tracks the rendered width; a change invalidates the full history. */
   private lastRenderedWidth = 0;
@@ -143,8 +119,6 @@ export class ConversationManager extends SdkConversationManager {
   private errorLineRegistry: number[] = [];
   /** Maps message index → SystemMessageKind for system-role messages. */
   private messageKindRegistry: Map<number, SystemMessageKind> = new Map();
-  /** See conversation-user-receipts.ts. */
-  private userReceiptIndices = new UserReceiptIndices();
   /** Streaming block start line in history buffer (for incremental streaming update). */
   private streamingStartLine = -1;
   /**
@@ -169,9 +143,24 @@ export class ConversationManager extends SdkConversationManager {
   private _displayFromMessageIndex = 0;
 
   public suppressSplash: boolean = false;
+  private noticeSink: NoticeSink | null = null;
   public splashOptions: SplashOptions = {};
   /** Run-sticky dismissal + the splash→transcript edge (conversation-splash-state.ts). */
   private readonly splashGate = new SplashGateState();
+  /** Live facts the work tree reads (timings, agent lanes, waiting calls); see work-tree-sources.ts. */
+  private workTreeSources: WorkTreeSources = {};
+  /** Turn activity at the last build: a change forces a rebuild (a finished turn's header must drop "working"). */
+  private builtWhileActive = false;
+  /** Whether the terminal draws unicode (term-caps.ts); ascii work-tree glyphs when not. */
+  private unicodeCapable = probeUnicodeSupport();
+  /** Keyboard focus, live repaint and fold state of the work tree (work-tree-focus.ts). */
+  public readonly workTree: WorkTreeController = new WorkTreeController({
+    blocks: () => { this.flushHistory(); return this.blockRegistry; },
+    collapseState: () => this.collapseState,
+    markDirty: () => this.markDirty(),
+    noteUserTouch: (key) => this.searchExpansion.noteUserTouch(key),
+    drewLive: () => this.lineCache.live,
+  });
 
   constructor(
     getWidth: () => number = () => process.stdout.columns || 80,
@@ -229,23 +218,27 @@ export class ConversationManager extends SdkConversationManager {
     // stale kind (e.g. 'operational') and silently mis-classify the new message.
     const nextIndex = this.getMessageSnapshot().length;
     this.messageKindRegistry.delete(nextIndex);
-    this.userReceiptIndices.delete(nextIndex);
     super.addSystemMessage(content);
     this.markDirty();
+    this.noticeSink?.(content, { restored: false });
+  }
+
+  /** Where system notices go (core/notices.ts); the transcript draws none. Absent in bare test conversations. */
+  public setNoticeSink(sink: NoticeSink | null): void {
+    this.noticeSink = sink;
   }
 
   /**
    * addTypedSystemMessage - System message with an explicit kind tag, stored
-   * in messageKindRegistry. `isUserReceipt` (conversation-user-receipts.ts)
-   * additionally marks it for rebuildHistory()'s splash check, only for a
-   * direct receipt to an explicit user action, never ambient boot chatter.
+   * in messageKindRegistry. Like every system message it is a notice: the
+   * notice sink shows it, the transcript does not.
    */
-  public addTypedSystemMessage(content: string, kind: SystemMessageKind, opts?: { isUserReceipt?: boolean }): void {
+  public addTypedSystemMessage(content: string, kind: SystemMessageKind): void {
     const nextIndex = this.getMessageSnapshot().length;
     this.messageKindRegistry.set(nextIndex, kind);
-    if (opts?.isUserReceipt) this.userReceiptIndices.add(nextIndex); else this.userReceiptIndices.delete(nextIndex);
     super.addSystemMessage(content);
     this.markDirty();
+    this.noticeSink?.(content, { restored: false });
   }
 
   public override undo(): boolean {
@@ -260,7 +253,6 @@ export class ConversationManager extends SdkConversationManager {
       for (const key of this.messageKindRegistry.keys()) {
         if (key >= postUndoCount) this.messageKindRegistry.delete(key);
       }
-      this.userReceiptIndices.purgeFrom(postUndoCount);
       this.markDirty();
     }
     return result;
@@ -295,8 +287,13 @@ export class ConversationManager extends SdkConversationManager {
     this.markDirty();
     // Record the line where the streaming block starts so updates can be incremental.
     // Reset the render throttle so the first delta always renders immediately.
+    // The rebuild already treats the placeholder as streaming (its turn ends
+    // without a blank row, the text continues under its spine), the same as a
+    // rebuild later in the stream does.
+    this.streamingStartLine = 0;
     this.flushHistory();
-    this.streamingStartLine = this.history.getLineCount();
+    // The streamed text starts above any display-only draws kept below it.
+    this.streamingStartLine = this.history.getLineCount() - this.displayOnly.trailingLineCount;
     this._streamWidth = this._getWidth();
     this._lastStreamRenderMs = 0;
   }
@@ -324,8 +321,8 @@ export class ConversationManager extends SdkConversationManager {
         this._lastStreamRenderMs = now;
         const width = this._getWidth();
         this.history.truncateToLine(this.streamingStartLine);
-        const rendered = renderMarkdown(content, width, { isStreaming: true });
-        this.history.addLines(rendered);
+        this.history.addLines(this.streamingLines(content, width));
+        this.displayOnly.drawTrailing(width, () => this.history.getLineCount());
       }
     }
   }
@@ -337,6 +334,7 @@ export class ConversationManager extends SdkConversationManager {
   public override finalizeStreamingBlock(): void {
     super.finalizeStreamingBlock();
     this.streamingStartLine = -1;
+    this.displayOnly.resetTrailing();
     this._streamWidth = -1;
     this._lastStreamRenderMs = 0;
     this.markDirty();
@@ -362,18 +360,13 @@ export class ConversationManager extends SdkConversationManager {
     this.messageLineRegistry = [];
     this.errorLineRegistry = [];
     this.messageKindRegistry = new Map();
-    this.userReceiptIndices.clear();
     this.streamingStartLine = -1;
+    this.displayOnly.drop();
+    this.workTree.reset();
     this._displayFromMessageIndex = 0; // full reset, show everything on next render
   }
 
-  /**
-   * replaceMessagesForLLM - Replace the conversation's LLM-visible messages with a new set.
-   * Used by small-window compaction to swap in truncated messages without an LLM call.
-   * System messages are always preserved at the front.
-   *
-   * @param newMessages - Replacement ProviderMessage array (user/assistant/tool roles only)
-   */
+  /** Compaction's replace: the SDK keeps every kept message whole (tool calls, model, reasoning); the display rebuilds. */
   public override replaceMessagesForLLM(newMessages: ProviderMessage[]): void {
     super.replaceMessagesForLLM(newMessages);
     this.history.clear();
@@ -415,6 +408,10 @@ export class ConversationManager extends SdkConversationManager {
     titleSource?: import('@pellux/goodvibes-sdk/platform/core').ConversationTitleSource;
   }): void {
     super.fromJSON(data);
+    // A restored session's notices go back into the history (not toasted).
+    for (const message of data.messages) if (message.role === 'system') this.noticeSink?.(message.content, { restored: true });
+    // Output printed over the conversation this one replaces is not about it.
+    this.displayOnly.drop();
     this.history.clear();
     this.lineCache.clear();
     this.appendedUpTo = 0;
@@ -466,6 +463,8 @@ export class ConversationManager extends SdkConversationManager {
     const width = this._getWidth();
     this.lastRenderedWidth = width;
     this.dirty = false;
+    this.builtWhileActive = this.workTreeSources.turnActive?.() ?? false;
+    this.displayOnly.resetTrailing();
 
     const snapshot = this.getMessageSnapshot();
     // During streaming, the in-progress placeholder (always the last message) is
@@ -484,14 +483,9 @@ export class ConversationManager extends SdkConversationManager {
     const displayStart = this._displayFromMessageIndex;
     const visibleSnapshot = displayStart > 0 ? renderSnapshot.slice(displayStart) : renderSnapshot;
 
-    // Tool/system messages aren't visible splash-purposes content, except a
-    // system message in userReceiptIndices. visibleSnapshot mirrors the
-    // snapshot 1:1 (only front-sliced), so index i is absolute displayStart+i.
-    const displayMessages = visibleSnapshot.filter((m, i) => {
-      if (m.role === 'tool') return false;
-      if (m.role === 'system') return this.userReceiptIndices.has(displayStart + i);
-      return true;
-    });
+    // Tool and system messages are not transcript content: a system message is
+    // a notice (a toast and the notification history, see core/notices.ts).
+    const displayMessages = visibleSnapshot.filter((m) => m.role !== 'tool' && m.role !== 'system');
 
     if (displayMessages.length === 0 && displayStart === 0 && !this.suppressSplash && !this.splashGate.dismissed) {
       this.addSplashScreen(width);
@@ -504,8 +498,14 @@ export class ConversationManager extends SdkConversationManager {
     // renderSnapshot) is left uncached: its content mutates in place per delta and
     // the incremental streaming path (updateStreamingBlock) owns it.
     const streamingPlaceholderAbsIdx = isStreaming ? snapshot.length - 1 : -1;
-    this.appendMessages(visibleSnapshot, width, displayStart, streamingPlaceholderAbsIdx);
+    // Display-only draws go back where they were printed: after the unit that
+    // holds the last message that existed then. The turn still streaming is
+    // last and its text continues below it, so what follows it waits.
+    const kept = this.displayOnly.cursor(width);
+    kept.through(displayStart - 1);
+    this.appendMessages(visibleSnapshot, width, displayStart, streamingPlaceholderAbsIdx, (last, streaming) => { if (!streaming) kept.through(last); });
     this.appendedUpTo = snapshot.length;
+    if (!isStreaming) kept.through(Number.POSITIVE_INFINITY);
 
     if (isStreaming) {
       // Re-anchor the streaming block to the freshly rebuilt buffer and re-render
@@ -515,17 +515,31 @@ export class ConversationManager extends SdkConversationManager {
       this._lastStreamRenderMs = 0;
       const streamingContent = lastMsg?.content;
       if (typeof streamingContent === 'string' && streamingContent.length > 0) {
-        this.history.addLines(renderMarkdown(streamingContent, width, { isStreaming: true }));
+        this.history.addLines(this.streamingLines(streamingContent, width));
       }
+      kept.trailStreamed(() => this.history.getLineCount()); // printed this turn: below the streamed text
     }
   }
 
+  /** Keep a display-only draw and draw it now (below streamed text while streaming; over the splash, it retires the splash). */
+  private recordDisplayOnly(draw: (width: number) => void): void {
+    const seq = this.displayOnly.keep(this.getMessageSnapshot().length, draw);
+    if (this.splashGate.showing && this.splashGate.dismiss()) return this.rebuildHistory();
+    const before = this.history.getLineCount();
+    draw(this._getWidth());
+    this.displayOnly.noteDrawn(seq, this.history.getLineCount() - before, this.streamingStartLine >= 0);
+  }
+
+  /** Display-only draws kept for redraw (bounded; for memory-hygiene assertions). */
+  public getDisplayOnlyCount(): number { return this.displayOnly.count; }
+
   /**
    * flushHistory - Incremental update. Appends only newly added messages.
    * Falls back to a full rebuild when the terminal width has changed.
    */
   public flushHistory(): void {
     const currentWidth = this._getWidth();
+    if ((this.workTreeSources.turnActive?.() ?? false) !== this.builtWhileActive) this.dirty = true;
     if (!this.dirty && currentWidth === this.lastRenderedWidth) return;
     this.rebuildHistory();
   }
@@ -543,29 +557,24 @@ export class ConversationManager extends SdkConversationManager {
       messageKindRegistry: this.messageKindRegistry as ReadonlyMap<number, SystemMessageKind>,
       configManager: this._configManager,
       splashOptions: this.splashOptions,
+      systemNotices: 'elsewhere' as const,
+      workTreeSources: this.workTreeSources,
+      treeGlyphSet: this.treeGlyphSet(),
+      focusId: this.workTree.focus,
+      frame: this.workTree.frame,
     };
   }
 
-  private renderUserMessage(message: Extract<Message, { role: 'user' }>, width: number): void {
-    renderConversationUserMessage(this.renderingContext(), message, width);
-  }
-
-  private renderAssistantMessage(
-    message: Extract<Message, { role: 'assistant' }>,
-    width: number,
-    lineNumberMode: 'all' | 'code' | 'off',
-    collapseThreshold: number,
-    msgIdx: number,
-  ): void {
-    renderConversationAssistantMessage(this.renderingContext(), message, width, lineNumberMode, collapseThreshold, msgIdx);
-  }
-
-  private renderSystemMessage(message: Extract<Message, { role: 'system' }>, width: number, msgIdx: number): void {
-    renderConversationSystemMessage(this.renderingContext(), message, width, msgIdx);
+  /** The work tree's glyph set: display.treeGlyphs, ascii on a terminal without unicode. */
+  private treeGlyphSet(): TreeGlyphSetName {
+    return resolveTreeGlyphSet(this._configManager?.get('display.treeGlyphs'), this.unicodeCapable);
   }
 
-  private renderToolMessage(message: Extract<Message, { role: 'tool' }>, width: number, msgIdx: number): void {
-    renderConversationToolMessage(this.renderingContext(), message, width, msgIdx);
+  /** Streaming text: under the spine of the turn it belongs to when there is one, else full width. */
+  private streamingLines(content: string, width: number): Line[] {
+    const tail = this.lineCache.lastTail;
+    if (!tail) return renderMarkdown(content, width, { isStreaming: true });
+    return renderStreamingContinuation(content, width, tail, this.treeGlyphSet());
   }
 
   /**
@@ -581,6 +590,7 @@ export class ConversationManager extends SdkConversationManager {
     width: number,
     msgIndexOffset = 0,
     streamingPlaceholderAbsIdx = -1,
+    afterUnit?: (lastIndex: number, streaming: boolean) => void,
   ): void {
     this.lineCache.renderInto(
       this.renderingContext(),
@@ -589,34 +599,35 @@ export class ConversationManager extends SdkConversationManager {
       this.messageLineRegistry,
       msgIndexOffset,
       streamingPlaceholderAbsIdx,
+      afterUnit,
     );
   }
 
+  // -------------------------------------------------------------------------
+  // Work tree (see work-tree-model.ts / work-tree-focus.ts)
+  // -------------------------------------------------------------------------
+
+  /** Live facts the work tree draws: timings, agent lanes, the call a prompt is holding. */
+  public setWorkTreeSources(sources: WorkTreeSources): void { this.workTreeSources = sources; this.markDirty(); }
+  // An agent view (core/agent-view-render.ts) draws with main's sources, glyphs and the agent's lane color.
+  public getWorkTreeSources(): WorkTreeSources { return this.workTreeSources; }
+  public getTreeGlyphSet(): TreeGlyphSetName { return this.treeGlyphSet(); }
+  public laneColorOf(agentId: string): number | undefined { return this.getBlockRegistry().find((b) => b.workTree?.kind === 'lane' && b.workTree.agentId === agentId)?.workTree?.colorIndex; }
+  /** Override the unicode probe (tests, and a terminal the caller knows better). */
+  public setUnicodeCapable(capable: boolean): void { this.unicodeCapable = capable; this.markDirty(); }
   /** Find the nearest block to a given line index, optionally filtered by type. */
-  public findNearestBlock(lineIndex: number, typeFilter?: string): BlockMeta | null {
-    let nearest: BlockMeta | null = null;
-    let nearestDist = Infinity;
-    for (const block of this.blockRegistry) {
-      if (typeFilter !== undefined && block.type !== typeFilter) continue;
-      if (lineIndex >= block.startLine && lineIndex < block.startLine + block.lineCount) {
-        return block;
-      }
-      const dist = Math.abs(block.startLine - lineIndex);
-      if (dist < nearestDist) {
-        nearestDist = dist;
-        nearest = block;
-      }
-    }
-    return nearest;
-  }
+  public findNearestBlock(lineIndex: number, typeFilter?: string): BlockMeta | null { return nearestBlock(this.blockRegistry, lineIndex, typeFilter); }
 
-  /**
-   * isCollapsed - Returns whether the block at blockIndex is collapsed.
-   */
+  /** isCollapsed - Returns whether the block at blockIndex is collapsed. */
   public isCollapsed(blockIndex: number): boolean {
     const block = this.blockRegistry[blockIndex];
-    if (!block) return false;
-    return this.collapseState.get(block.collapseKey) ?? false;
+    return block ? this.collapsedNow(block) : false;
+  }
+
+  /** Current collapse of a block: an unset bead key is a closed bead; everything else defaults open. */
+  private collapsedNow(block: BlockMeta): boolean {
+    const stored = this.collapseState.get(block.collapseKey);
+    return block.workTree?.kind === 'bead' ? stored !== false : stored ?? false;
   }
 
   /**
@@ -634,11 +645,7 @@ export class ConversationManager extends SdkConversationManager {
   public getDiffAtLine(lineIndex: number): { filePath: string; original: string; updated: string } | null {
     const nearest = this.findNearestBlock(lineIndex, 'diff');
     if (!nearest || !nearest.filePath) return null;
-    return {
-      filePath: nearest.filePath,
-      original: nearest.diffOriginal ?? '',
-      updated: nearest.diffUpdated ?? '',
-    };
+    return { filePath: nearest.filePath, original: nearest.diffOriginal ?? '', updated: nearest.diffUpdated ?? '' };
   }
 
   /**
@@ -648,10 +655,11 @@ export class ConversationManager extends SdkConversationManager {
   public toggleCollapseAtLine(lineIndex: number): number {
     const nearest = this.findNearestBlock(lineIndex);
     if (!nearest) return -1;
-    const current = this.collapseState.get(nearest.collapseKey) ?? false;
+    const current = this.collapsedNow(nearest);
     this.collapseState.set(nearest.collapseKey, !current);
     this.searchExpansion.noteUserTouch(nearest.collapseKey);
     this.markDirty();
+    if (isWorkTreeFoldKey(nearest.collapseKey)) this.workTree.notifyFoldChange();
     return nearest.blockIndex;
   }
 
@@ -692,23 +700,13 @@ export class ConversationManager extends SdkConversationManager {
    * nextErrorLine - Find the next error line after currentLine (wraps around).
    * Returns -1 if there are no error lines.
    */
-  public nextErrorLine(currentLine: number): number {
-    const errors = this.getErrorLines();
-    if (errors.length === 0) return -1;
-    const after = errors.find(l => l > currentLine);
-    return after ?? errors[0];
-  }
+  public nextErrorLine(currentLine: number): number { return wrapToLine(this.getErrorLines(), currentLine, 'next'); }
 
   /**
    * prevErrorLine - Find the previous error line before currentLine (wraps around).
    * Returns -1 if there are no error lines.
    */
-  public prevErrorLine(currentLine: number): number {
-    const errors = this.getErrorLines();
-    if (errors.length === 0) return -1;
-    const before = [...errors].reverse().find(l => l < currentLine);
-    return before ?? errors[errors.length - 1];
-  }
+  public prevErrorLine(currentLine: number): number { return wrapToLine(this.getErrorLines(), currentLine, 'prev'); }
 
   public nextTranscriptEventLine(currentLine: number, kind: TranscriptEventKind | 'all' = 'all'): number {
     this.flushHistory();
@@ -727,14 +725,13 @@ export class ConversationManager extends SdkConversationManager {
   }
 
   /** Retire the splash for the run, any submission does it (SplashGateState). */
-  public dismissSplash(): void {
-    if (this.splashGate.dismiss()) this.markDirty();
-  }
+  /** Retire the splash; rebuilt now (not marked dirty) so a command's output logged in the same tick survives the next frame. */
+  public dismissSplash(): void { if (this.splashGate.dismiss() && this.splashGate.showing) this.rebuildHistory(); }
 
+  /** True while the conversation area is showing the splash (the shell centers it). */
+  public isSplashShowing(): boolean { return this.splashGate.showing; }
   /** True once, on the frame the splash gives way to transcript content. */
-  public consumeSplashTransition(): boolean {
-    return this.splashGate.consumeTransition();
-  }
+  public consumeSplashTransition(): boolean { return this.splashGate.consumeTransition(); }
 
   private addSplashScreen(width: number): void {
     addConversationSplashScreen(this.renderingContext(), width);
@@ -744,8 +741,9 @@ export class ConversationManager extends SdkConversationManager {
     return conversationTextToLines(text, width, style);
   }
 
+  /** Print display-only text into the transcript (never a message); it survives every rebuild. */
   public log(text: string, style: Partial<Cell> = {}, indent = '      '): void {
-    logConversationText(this.renderingContext(), this._getWidth(), text, style, indent);
+    this.recordDisplayOnly((width) => logConversationText(this.renderingContext(), width, text, style, indent));
   }
 
   /**
@@ -761,7 +759,7 @@ export class ConversationManager extends SdkConversationManager {
     durationMs: number,
     errorMsg?: string,
   ): void {
-    logConversationToolResult(this.renderingContext(), this._getWidth(), toolCall, status, resultSummary, durationMs, errorMsg);
+    this.recordDisplayOnly((width) => logConversationToolResult(this.renderingContext(), width, toolCall, status, resultSummary, durationMs, errorMsg));
     this.markDirty();
   }
 
@@ -778,6 +776,7 @@ export class ConversationManager extends SdkConversationManager {
    */
   public clearDisplay(): void {
     this.history.clear();
+    this.displayOnly.drop();
     this.blockRegistry = [];
     this.messageLineRegistry = [];
     this.errorLineRegistry = [];