@pellux/goodvibes-tui 1.19.5 → 1.20.0

package/src/core/conversation-line-cache.ts

@@ -25,6 +25,10 @@
  *   - the absolute message index (embedded in every collapseKey and used for the
  *     system-message kind lookup)
  *   - the system-message kind (drives the error-navigation registry side effect)
+ *   - this message's tool-group membership (see conversation-tool-groups.ts):
+ *     whether it's folded under a group header, which member owns that header,
+ *     and the group's honest tool/line counts — a group growing as new tool
+ *     results stream in changes these for every existing member
  *   - the live values of every collapseState key the render READS (recorded via a
  *     proxy during a miss; a collapse toggle flips a recorded value and
  *     invalidates exactly the owning message)
@@ -50,7 +54,9 @@ import {
   renderConversationToolMessage,
   renderConversationUserMessage,
   collectCompletedToolCallIds,
+  isFoldedGroupMember,
 } from './conversation-rendering.ts';
+import { computeToolGroupMembership, type ToolGroupMembership } from './conversation-tool-groups.ts';
 import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
 // SystemMessageKind imported from runtime directly to avoid a cycle, mirroring
 // conversation-rendering.ts's own import.
@@ -96,17 +102,42 @@ interface KeyMeta {
   readonly blockBase: number;
   readonly kind: SystemMessageKind | undefined;
   /**
-   * True when this (assistant) message has a tool call with no result yet — it
-   * renders as pending rather than done. Keyed so the entry invalidates and
-   * re-renders ✓ once the tool result arrives. (item 2c.)
+   * Per-call completion signature for an assistant message's tool calls (see
+   * pendingToolKeyOf) — undefined when the message has none. Each call's id
+   * is paired with whether it has a matching result yet, in call order, so a
+   * SINGLE call finishing invalidates and re-renders that call's glyph from
+   * ◌ to ✓ immediately. A prior aggregate boolean only flipped once EVERY
+   * call in the message had completed, so in a multi-call turn the earlier
+   * calls kept showing ◌ until the last result arrived.
    */
-  readonly hasPendingTool: boolean;
+  readonly pendingToolKey: string | undefined;
+  /**
+   * Tool-group membership fields (see conversation-tool-groups.ts), flattened
+   * so a change invalidates the cache like any other structural input — e.g.
+   * a group growing from 2 to 3 members as tool results stream in changes
+   * groupToolCount/groupTotalLines for every existing member, and must
+   * re-render all of them with the updated header counts. `groupKey` is
+   * undefined when the message isn't part of a folded group.
+   */
+  readonly groupKey: string | undefined;
+  readonly groupIsFirst: boolean;
+  readonly groupToolCount: number;
+  readonly groupTotalLines: number;
 }
 
-/** Whether an assistant message has any tool call still awaiting a result. */
-function hasPendingToolCall(m: Message, completed: ReadonlySet<string>): boolean {
-  if (m.role !== 'assistant' || !m.toolCalls) return false;
-  return m.toolCalls.some((tc) => tc.id === undefined || !completed.has(tc.id));
+/**
+ * Per-call completion signature for an assistant message's tool calls, in
+ * call order — `id:0` or `id:1` per call, joined. Undefined for a message
+ * with no tool calls at all (nothing to key). Comparing this instead of an
+ * aggregate boolean lets exactly the calls whose completion status changed
+ * invalidate the entry, rather than waiting for every call in the message to
+ * complete before any of them re-renders as done.
+ */
+function pendingToolKeyOf(m: Message, completed: ReadonlySet<string>): string | undefined {
+  if (m.role !== 'assistant' || !m.toolCalls || m.toolCalls.length === 0) return undefined;
+  return m.toolCalls
+    .map((tc) => `${tc.id ?? ''}:${tc.id !== undefined && completed.has(tc.id) ? 1 : 0}`)
+    .join('|');
 }
 
 interface CacheEntry {
@@ -288,31 +319,51 @@ export class MessageLineCache {
     // Tool calls with no matching tool-result message are still pending; the
     // render context and the cache key both depend on this. (item 2c.)
     const completedToolCallIds = collectCompletedToolCallIds(messages);
-    const renderContext: ConversationRenderContext = { ...context, completedToolCallIds };
+    // Fold runs of >=2 consecutive tool-result messages sharing one assistant
+    // turn under a single collapsible header (see conversation-tool-groups.ts).
+    // Computed once per pass, over the same slice+offset appendConversationMessages
+    // would see, so both entry points fold identically.
+    const toolGroupMembership = computeToolGroupMembership(messages, msgIndexOffset, width);
+    const renderContext: ConversationRenderContext = { ...context, completedToolCallIds, toolGroupMembership };
 
     const touched = new Set<number>();
+    // Header line of each currently-open tool-group, keyed by groupKey — the
+    // first member's own registered line, recorded as that member is reached
+    // below so later (non-first) members of the SAME group can resolve to it.
+    const groupHeaderLines = new Map<string, number>();
 
     for (let i = 0; i < messages.length; i++) {
       const message = messages[i]!;
       const absoluteIdx = msgIndexOffset + i;
       const base = context.history.getLineCount();
       const blockBase = context.blockRegistry.length;
-      messageLineRegistry[absoluteIdx] = base;
 
       const uncacheable = absoluteIdx === streamingPlaceholderAbsIdx;
       const kind = context.messageKindRegistry.get(absoluteIdx);
-      const hasPendingTool = hasPendingToolCall(message, completedToolCallIds);
+      const pendingToolKey = pendingToolKeyOf(message, completedToolCallIds);
+      const groupMembership = toolGroupMembership.get(absoluteIdx);
+
+      if (groupMembership?.isFirst) groupHeaderLines.set(groupMembership.groupKey, base);
+      // A folded (non-first, currently collapsed) group member renders zero
+      // lines of its own — `base` here is just wherever the buffer happens to
+      // sit after the last member that DID render, which is the position the
+      // NEXT real content starts at, not this message's own position. Anchor
+      // it at the group's header line instead, so transcript-event
+      // navigation lands on the group rather than skipping past it.
+      messageLineRegistry[absoluteIdx] = isFoldedGroupMember(groupMembership, context.collapseState)
+        ? (groupHeaderLines.get(groupMembership!.groupKey) ?? base)
+        : base;
 
       if (!uncacheable) {
         const existing = this.entries.get(absoluteIdx);
-        if (existing && this.isValid(existing, message, width, cfg, blockBase, kind, hasPendingTool, context.collapseState)) {
+        if (existing && this.isValid(existing, message, width, cfg, blockBase, kind, pendingToolKey, groupMembership, context.collapseState)) {
           this.applyEntry(context, existing, base);
           touched.add(absoluteIdx);
           continue;
         }
       }
 
-      const entry = this.renderScratch(renderContext, message, width, absoluteIdx, cfg, blockBase, kind, hasPendingTool);
+      const entry = this.renderScratch(renderContext, message, width, absoluteIdx, cfg, blockBase, kind, pendingToolKey, groupMembership);
       this.applyEntry(context, entry, base);
       if (!uncacheable) {
         this.entries.set(absoluteIdx, entry);
@@ -338,7 +389,8 @@ export class MessageLineCache {
     cfg: RenderConfig,
     blockBase: number,
     kind: SystemMessageKind | undefined,
-    hasPendingTool: boolean,
+    pendingToolKey: string | undefined,
+    groupMembership: ToolGroupMembership | undefined,
     collapseState: Map<string, boolean>,
   ): boolean {
     const k = entry.keyMeta;
@@ -351,7 +403,11 @@ export class MessageLineCache {
       k.showReasoningSummary !== cfg.showReasoningSummary ||
       k.blockBase !== blockBase ||
       k.kind !== kind ||
-      k.hasPendingTool !== hasPendingTool
+      k.pendingToolKey !== pendingToolKey ||
+      k.groupKey !== groupMembership?.groupKey ||
+      k.groupIsFirst !== (groupMembership?.isFirst ?? false) ||
+      k.groupToolCount !== (groupMembership?.toolCount ?? 0) ||
+      k.groupTotalLines !== (groupMembership?.totalLines ?? 0)
     ) {
       return false;
     }
@@ -376,7 +432,8 @@ export class MessageLineCache {
     cfg: RenderConfig,
     blockBase: number,
     kind: SystemMessageKind | undefined,
-    hasPendingTool: boolean,
+    pendingToolKey: string | undefined,
+    groupMembership: ToolGroupMembership | undefined,
   ): CacheEntry {
     const scratchLines: Line[] = [];
     const scratchHistory = {
@@ -401,11 +458,18 @@ export class MessageLineCache {
       configManager: context.configManager,
       splashOptions: context.splashOptions,
       completedToolCallIds: context.completedToolCallIds,
+      toolGroupMembership: context.toolGroupMembership,
     };
 
     renderOne(scratchCtx, message, width, absoluteIdx, cfg);
-    // Trailing blank line, exactly as appendConversationMessages appends per message.
-    scratchLines.push(createEmptyLine(width));
+    // Trailing blank line, exactly as appendConversationMessages appends per
+    // message — except a non-owning member of a currently-collapsed
+    // tool-result group (see conversation-tool-groups.ts) rendered nothing
+    // above and gets no filler line either; every other message keeps the
+    // unconditional separator.
+    if (!isFoldedGroupMember(groupMembership, context.collapseState)) {
+      scratchLines.push(createEmptyLine(width));
+    }
 
     const collapseDeps: Array<[string, boolean | undefined]> = [];
     for (const key of readKeys) collapseDeps.push([key, context.collapseState.get(key)]);
@@ -420,7 +484,11 @@ export class MessageLineCache {
         showReasoningSummary: cfg.showReasoningSummary,
         blockBase,
         kind,
-        hasPendingTool,
+        pendingToolKey,
+        groupKey: groupMembership?.groupKey,
+        groupIsFirst: groupMembership?.isFirst ?? false,
+        groupToolCount: groupMembership?.toolCount ?? 0,
+        groupTotalLines: groupMembership?.totalLines ?? 0,
       },
       contentSig: contentSigOf(message),
       lines: scratchLines,

package/src/core/conversation-rendering.ts

@@ -1,6 +1,6 @@
 import { UIFactory } from '../renderer/ui-factory.ts';
 import { renderMarkdownTracked } from '../renderer/markdown.ts';
-import { renderDiffView } from '../renderer/diff-view.ts';
+import { isDiffContent, renderExpandedToolResultLines } from '../renderer/tool-result-expanded-lines.ts';
 import { activeTheme, activeUiTones } from '../renderer/theme.ts';
 import { renderToolCallBlock } from '../renderer/tool-call.ts';
 import { summarizeToolResult } from '../renderer/tool-result-summary.ts';
@@ -15,6 +15,7 @@ import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { renderConversationCollapsedFragment, renderConversationEventLine } from '../renderer/conversation-surface.ts';
 import { GLYPHS } from '../renderer/ui-primitives.ts';
 import type { BlockMeta } from './conversation-types.ts';
+import { computeToolGroupMembership, type ToolGroupMembership } from './conversation-tool-groups.ts';
 import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
 import { parseDiffForApply } from '@pellux/goodvibes-sdk/platform/core';
 import { extractUserDisplayText, COMPACTION_HANDOFF_HEADER } from '@pellux/goodvibes-sdk/platform/core';
@@ -82,6 +83,13 @@ export interface ConversationRenderContext {
    * behaviour. (item 2c.)
    */
   readonly completedToolCallIds?: ReadonlySet<string>;
+  /**
+   * Per-tool-message group membership for the currently rendered slice (see
+   * conversation-tool-groups.ts). A message index absent from this map (or an
+   * undefined map itself) isn't part of a folded run of tool results and
+   * renders exactly as it always has.
+   */
+  readonly toolGroupMembership?: ReadonlyMap<number, ToolGroupMembership>;
 }
 
 export function renderConversationUserMessage(
@@ -199,8 +207,34 @@ export function renderConversationAssistantMessage(
     const thinkingStartLine = context.history.getLineCount();
     const thinkingBlockIdx = context.blockRegistry.length;
     const thinkingCollapseKey = `msg_${msgIdx}_thinking`;
-    const thinkingLines = renderThinkingBlock(message.reasoningContent, width);
-    context.history.addLines(thinkingLines);
+    // Collapsed by default, like every other collapsible block — Tab (or the
+    // block-actions menu) expands it via the same collapseKey the BlockMeta
+    // below registers. Previously this key was registered but never
+    // consulted: the toggle existed but did nothing.
+    const isThinkingCollapsed = context.collapseState.has(thinkingCollapseKey)
+      ? context.collapseState.get(thinkingCollapseKey)!
+      : true;
+    if (!context.collapseState.has(thinkingCollapseKey)) {
+      context.collapseState.set(thinkingCollapseKey, true);
+    }
+    if (isThinkingCollapsed) {
+      const thinkingLineCount = message.reasoningContent.split('\n').length;
+      const rendered = renderConversationCollapsedFragment(
+        `thinking · ${thinkingLineCount} line${thinkingLineCount === 1 ? '' : 's'}`,
+        width,
+        {
+          prefix: ' ▌ ',
+          prefixFg: T.reasoningAccent,
+          text: '244',
+          bodyBg: T.collapsedBodyBg,
+          dim: true,
+        },
+      );
+      context.history.addLines(rendered);
+    } else {
+      const thinkingLines = renderThinkingBlock(message.reasoningContent, width);
+      context.history.addLines(thinkingLines);
+    }
     context.history.addLine(createEmptyLine(width));
     const thinkingRenderedLines = context.history.getLineCount() - thinkingStartLine;
     context.blockRegistry.push({
@@ -316,6 +350,95 @@ export function renderConversationSystemMessage(
   }
 }
 
+/**
+ * True when `message` is a non-owning member of a folded tool-result group
+ * (see conversation-tool-groups.ts) that is currently collapsed — it rendered
+ * nothing (renderConversationToolMessage returns right after the header-owning
+ * member's header line), so the per-message trailing blank-line separator is
+ * skipped for it too. The header-owning ("first") member always gets its
+ * separator since it always renders at least the header line; any member of
+ * an EXPANDED group renders in full and keeps its separator as well.
+ */
+export function isFoldedGroupMember(
+  membership: ToolGroupMembership | undefined,
+  collapseState: ReadonlyMap<string, boolean>,
+): boolean {
+  return membership !== undefined && !membership.isFirst && (collapseState.get(membership.groupKey) ?? true);
+}
+
+/**
+ * Dedupe a group's per-member tool names into a compact, honest summary —
+ * "read×3 exec write" rather than either a bare count or a full repeated
+ * list. Truncates with an honest "…+N more" tail rather than silently
+ * dropping names once the list gets long.
+ */
+function summarizeToolNames(names: readonly string[]): string {
+  const counts = new Map<string, number>();
+  const order: string[] = [];
+  for (const name of names) {
+    if (!counts.has(name)) {
+      counts.set(name, 0);
+      order.push(name);
+    }
+    counts.set(name, counts.get(name)! + 1);
+  }
+  const MAX_SHOWN = 4;
+  const parts = order.map((name) => (counts.get(name)! > 1 ? `${name}×${counts.get(name)}` : name));
+  if (parts.length > MAX_SHOWN) {
+    return `${parts.slice(0, MAX_SHOWN).join(' ')} …+${parts.length - MAX_SHOWN} more`;
+  }
+  return parts.join(' ');
+}
+
+/**
+ * Render the synthetic header line for a folded run of >=2 tool-result
+ * messages: one line + one BlockMeta (type 'tool_group'), shared by every
+ * member under `membership.groupKey`. Returns whether the group is currently
+ * collapsed, establishing the collapsed-by-default state on first render —
+ * mirrors the has/set default-establishment idiom used by every other
+ * collapsible block in this file.
+ */
+function renderToolGroupHeader(
+  context: ConversationRenderContext,
+  width: number,
+  membership: ToolGroupMembership,
+): boolean {
+  const T = activeTheme();
+  const isCollapsed = context.collapseState.has(membership.groupKey)
+    ? context.collapseState.get(membership.groupKey)!
+    : true;
+  if (!context.collapseState.has(membership.groupKey)) {
+    context.collapseState.set(membership.groupKey, true);
+  }
+
+  const blockIdx = context.blockRegistry.length;
+  const startLine = context.history.getLineCount();
+  const toolNamesSummary = summarizeToolNames(membership.toolNames);
+  context.history.addLine(renderConversationEventLine(width, {
+    marker: GLYPHS.surface.altCursor,
+    markerFg: T.toolAccent,
+    label: 'tool results',
+    labelFg: T.toolAccent,
+    detailFg: '244',
+  }, [
+    { text: ` ${membership.toolCount} tool${membership.toolCount === 1 ? '' : 's'} `, fg: T.toolAccent },
+    ...(toolNamesSummary ? [{ text: ` ${toolNamesSummary} `, fg: T.toolNameFg }] : []),
+    { text: ` ${isCollapsed ? GLYPHS.navigation.collapsed : GLYPHS.navigation.expanded} ${membership.totalLines} line${membership.totalLines === 1 ? '' : 's'} `, fg: '244', dim: true },
+  ]));
+
+  context.blockRegistry.push({
+    blockIndex: blockIdx,
+    collapseKey: membership.groupKey,
+    type: 'tool_group',
+    startLine,
+    lineCount: 1,
+    rawContent: `${membership.toolCount} tool result${membership.toolCount === 1 ? '' : 's'} folded (${toolNamesSummary}, ${membership.totalLines} line${membership.totalLines === 1 ? '' : 's'} total)`,
+    groupMemberIndexes: membership.memberIndexes,
+  });
+
+  return isCollapsed;
+}
+
 export function renderConversationToolMessage(
   context: ConversationRenderContext,
   message: Extract<Message, { role: 'tool' }>,
@@ -323,18 +446,33 @@ export function renderConversationToolMessage(
   msgIdx: number,
 ): void {
   const T = activeTheme();
+  const groupMembership = context.toolGroupMembership?.get(msgIdx);
+  if (groupMembership) {
+    const collapsed = groupMembership.isFirst
+      ? renderToolGroupHeader(context, width, groupMembership)
+      : (context.collapseState.get(groupMembership.groupKey) ?? true);
+    // Folded: the header (rendered above, once, by the first member) is the
+    // group's entire visible representation while collapsed — no member,
+    // first or not, renders its own header/body/BlockMeta.
+    if (collapsed) return;
+  }
+
   const collapseKey = `msg_${msgIdx}`;
   const blockIdx = context.blockRegistry.length;
   const startLine = context.history.getLineCount();
   const contentLines = message.content.split('\n');
-  const lineCount = contentLines.length;
-  const hasDiffHeader = contentLines.some((l) => l.startsWith('--- ')) && contentLines.some((l) => l.startsWith('+++ '));
-  const hasHunk = contentLines.some((l) => l.startsWith('@@ '));
-  const isDiff = hasDiffHeader && hasHunk;
+  const isDiff = isDiffContent(message.content);
   const blockType: 'diff' | 'tool' = isDiff ? 'diff' : 'tool';
   // Parsed once, ahead of the collapse check, so it's available for the
   // block-registry meta merge below regardless of collapsed/expanded state.
   const diffParse = isDiff ? parseDiffForApply(message.content) : undefined;
+  // The EXPANDED render, computed unconditionally (even while collapsed) so
+  // the header's "N lines" badge always names what Tab would actually reveal
+  // — a raw JSON blob that pretty-prints to 50 lines must say 50, not 1, even
+  // while it's still folded. Reused below as the actual body when expanded,
+  // so this is never rendered twice.
+  const expandedLines = renderExpandedToolResultLines(message.content, width);
+  const lineCount = expandedLines.length;
 
   // Human one-line summary for tool results (write/read/exec/edit): shown as the
   // collapsed line so the transcript reads "wrote foo.txt (532 B)" instead of a
@@ -403,22 +541,11 @@ export function renderConversationToolMessage(
       dim: true,
     });
     context.history.addLines(rendered);
-  } else if (isDiff) {
-    // No filename banner: the diff text's own --- / +++ headers already
-    // identify the file (matches the pre-v0.9.6 call site in tool-call.ts).
-    context.history.addLines(renderDiffView(message.content, width));
   } else {
-    let contentToRender = message.content;
-    const trimmed = contentToRender.trimStart();
-    if ((trimmed.startsWith('{') || trimmed.startsWith('[')) && contentToRender.length < 100_000) {
-      try {
-        const parsed = JSON.parse(contentToRender);
-        contentToRender = `\`\`\`json\n${JSON.stringify(parsed, null, 2)}\n\`\`\``;
-      } catch {
-        // Leave invalid JSON as-is.
-      }
-    }
-    context.history.addLines(renderMarkdownTracked(contentToRender, width).lines);
+    // Diff or plain result — either way this is exactly `expandedLines`,
+    // already computed above (and already what the header's line count is
+    // honest about), so there is nothing left to render here.
+    context.history.addLines(expandedLines);
   }
 
   const renderedLineCount = context.history.getLineCount() - startLine;
@@ -429,6 +556,7 @@ export function renderConversationToolMessage(
     startLine,
     lineCount: renderedLineCount,
     rawContent: message.content,
+    toolName: message.toolName,
   };
 
   if (isDiff && diffParse) {
@@ -458,23 +586,53 @@ export function appendConversationMessages(
   const renderContext: ConversationRenderContext = context.completedToolCallIds !== undefined
     ? context
     : { ...context, completedToolCallIds: collectCompletedToolCallIds(messages) };
+  // Fold runs of >=2 consecutive tool-result messages sharing one assistant
+  // turn under a single collapsible header (see conversation-tool-groups.ts),
+  // unless the caller already supplied membership (the line-cache path
+  // computes it once per renderInto call and threads it through).
+  const toolGroupMembership = renderContext.toolGroupMembership
+    ?? computeToolGroupMembership(messages, msgIndexOffset, width);
+  const groupedContext: ConversationRenderContext = renderContext.toolGroupMembership !== undefined
+    ? renderContext
+    : { ...renderContext, toolGroupMembership };
+
+  // Header line of each currently-open tool-group, keyed by groupKey — the
+  // first member's own registered line, recorded as that member is reached
+  // below so later (non-first) members of the SAME group can resolve to it
+  // instead of whatever position the buffer happens to be at when a folded
+  // (zero-line) member is processed. See isFoldedGroupMember's doc.
+  const groupHeaderLines = new Map<string, number>();
 
   for (let msgIdx = 0; msgIdx < messages.length; msgIdx++) {
     const message = messages[msgIdx];
     // absoluteIdx aligns the slice-relative loop counter with the absolute
     // message index used as the key in messageKindRegistry and messageLineRegistry.
     const absoluteIdx = msgIndexOffset + msgIdx;
-    messageLineRegistry[absoluteIdx] = renderContext.history.getLineCount();
+    const membership = toolGroupMembership.get(absoluteIdx);
+    const currentLine = groupedContext.history.getLineCount();
+    if (membership?.isFirst) groupHeaderLines.set(membership.groupKey, currentLine);
+    // A folded (non-first, currently collapsed) group member renders zero
+    // lines of its own — `currentLine` here is just wherever the buffer
+    // happens to sit after the last member that DID render, which is the
+    // position the NEXT real content starts at, not this message's own
+    // position. Anchor it at the group's header line instead, so
+    // transcript-event navigation lands on the group rather than skipping
+    // past it to the following message.
+    messageLineRegistry[absoluteIdx] = isFoldedGroupMember(membership, groupedContext.collapseState)
+      ? (groupHeaderLines.get(membership!.groupKey) ?? currentLine)
+      : currentLine;
     if (message.role === 'user') {
-      renderConversationUserMessage(renderContext, message, width, absoluteIdx);
+      renderConversationUserMessage(groupedContext, message, width, absoluteIdx);
     } else if (message.role === 'assistant') {
-      renderConversationAssistantMessage(renderContext, message, width, lineNumberMode, collapseThreshold, absoluteIdx);
+      renderConversationAssistantMessage(groupedContext, message, width, lineNumberMode, collapseThreshold, absoluteIdx);
     } else if (message.role === 'system') {
-      renderConversationSystemMessage(renderContext, message, width, absoluteIdx);
+      renderConversationSystemMessage(groupedContext, message, width, absoluteIdx);
     } else if (message.role === 'tool') {
-      renderConversationToolMessage(renderContext, message, width, absoluteIdx);
+      renderConversationToolMessage(groupedContext, message, width, absoluteIdx);
+    }
+    if (!isFoldedGroupMember(membership, groupedContext.collapseState)) {
+      groupedContext.history.addLine(createEmptyLine(width));
     }
-    renderContext.history.addLine(createEmptyLine(width));
   }
 }
 

package/src/core/conversation-tool-groups.ts

@@ -0,0 +1,152 @@
+/**
+ * conversation-tool-groups.ts — detects runs of consecutive tool-result
+ * messages that belong to one assistant turn, so the transcript can fold them
+ * under a single collapsible group header instead of rendering one
+ * "tool result" header per call. Before this module, an assistant turn with
+ * N tool calls produced N independent header+body blocks in a row — visual
+ * spam once N is more than one or two.
+ *
+ * A run only counts as a group when it has >= 2 matched tool-result messages:
+ * a single result renders exactly as it always has (see
+ * renderConversationToolMessage in conversation-rendering.ts, which only
+ * consults this module's output when a membership entry exists).
+ *
+ * Pure function of the message slice — no rendering, no width, no side
+ * effects. Called once per render pass (appendConversationMessages /
+ * MessageLineCache.renderInto) over the currently-visible message slice, with
+ * the absolute index of the slice's first message so group keys and member
+ * indexes line up with the same collapseKey / blockRegistry indices a cold
+ * render would produce (messages may be a post-clearDisplay slice, not the
+ * full snapshot — see appendConversationMessages's msgIndexOffset doc).
+ */
+
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
+import { renderExpandedToolResultLines } from '../renderer/tool-result-expanded-lines.ts';
+
+type Message = ConversationMessageSnapshot;
+
+/** One consolidated run of tool-result messages sharing one assistant turn. */
+export interface ToolGroup {
+  /** Absolute index of the assistant message that owns this group. */
+  readonly assistantIdx: number;
+  /** Absolute indexes of the matched tool-result messages, in order. */
+  readonly toolMessageIndexes: readonly number[];
+}
+
+/**
+ * Per-tool-message membership, keyed by the ABSOLUTE index of the tool-result
+ * message (the owning assistant message is never a key — only its tool-result
+ * children are). `isFirst` marks the member whose render site owns the
+ * group's header line and BlockMeta; every other member renders nothing while
+ * the group is collapsed (see renderConversationToolMessage).
+ */
+export interface ToolGroupMembership {
+  readonly groupKey: string;
+  readonly isFirst: boolean;
+  /** Matched tool-result messages in the group (the header's "N tools"). */
+  readonly toolCount: number;
+  /** Sum of each member's EXPANDED render line count (the header's "N lines") —
+   *  the same post-render count each member's own "N lines" badge shows, so
+   *  the group total matches what expanding every member actually reveals,
+   *  not a raw-content estimate (a folded JSON result can pretty-print to far
+   *  more lines than its raw content has). */
+  readonly totalLines: number;
+  /** Each member's tool name, in order (falls back to 'tool' when a result
+   *  carries no name) — the header dedupes these into e.g. "read×3 exec". */
+  readonly toolNames: readonly string[];
+  /**
+   * Absolute indexes of every tool-result message in the group, in order —
+   * the same list for every member. Carried onto the group's BlockMeta so a
+   * single expand pass can also open each member's own collapse key
+   * (`msg_<idx>`), since a folded member pushes no BlockMeta of its own to
+   * toggle individually (see local-runtime.ts's toggleBlocks).
+   */
+  readonly memberIndexes: readonly number[];
+}
+
+/**
+ * Scan `messages` for assistant-message runs of >=2 consecutive matching
+ * tool-result messages. A run breaks on the first message that isn't a
+ * matching tool result: any non-tool message (interleaved user/system/
+ * assistant content), or a tool message whose callId isn't one of the
+ * assistant's own toolCalls ids (a result belonging to a different turn never
+ * gets folded into a group it doesn't belong to).
+ */
+export function detectToolGroups(
+  messages: readonly Message[],
+  indexOffset = 0,
+): ToolGroup[] {
+  const groups: ToolGroup[] = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role !== 'assistant' || !message.toolCalls || message.toolCalls.length === 0) continue;
+    const callIds = new Set(
+      message.toolCalls
+        .map((tc) => tc.id)
+        .filter((id): id is string => id !== undefined),
+    );
+    if (callIds.size === 0) continue;
+
+    const toolMessageIndexes: number[] = [];
+    let j = i + 1;
+    while (j < messages.length) {
+      const next = messages[j];
+      if (next.role !== 'tool' || !next.callId || !callIds.has(next.callId)) break;
+      toolMessageIndexes.push(indexOffset + j);
+      j++;
+    }
+
+    if (toolMessageIndexes.length >= 2) {
+      groups.push({ assistantIdx: indexOffset + i, toolMessageIndexes });
+    }
+  }
+
+  return groups;
+}
+
+/** Build the per-tool-message membership lookup used by the renderer/cache.
+ *  `width` must match the width the transcript is actually rendered at — it
+ *  feeds the same expanded-render line count each member's own badge uses
+ *  (see renderExpandedToolResultLines), so the group total is never computed
+ *  against a different width than what the member badges show. */
+export function buildToolGroupMembership(
+  groups: readonly ToolGroup[],
+  messages: readonly Message[],
+  indexOffset: number,
+  width: number,
+): ReadonlyMap<number, ToolGroupMembership> {
+  const membership = new Map<number, ToolGroupMembership>();
+  for (const group of groups) {
+    const groupKey = `group_${group.assistantIdx}`;
+    let totalLines = 0;
+    const toolNames: string[] = [];
+    for (const absIdx of group.toolMessageIndexes) {
+      const message = messages[absIdx - indexOffset];
+      if (message && message.role === 'tool') {
+        totalLines += renderExpandedToolResultLines(message.content, width).length;
+        toolNames.push(message.toolName ?? 'tool');
+      }
+    }
+    group.toolMessageIndexes.forEach((absIdx, idx) => {
+      membership.set(absIdx, {
+        groupKey,
+        isFirst: idx === 0,
+        toolCount: group.toolMessageIndexes.length,
+        totalLines,
+        toolNames,
+        memberIndexes: group.toolMessageIndexes,
+      });
+    });
+  }
+  return membership;
+}
+
+/** Convenience wrapper: detect groups, then build the membership map in one call. */
+export function computeToolGroupMembership(
+  messages: readonly Message[],
+  indexOffset = 0,
+  width = 80,
+): ReadonlyMap<number, ToolGroupMembership> {
+  return buildToolGroupMembership(detectToolGroups(messages, indexOffset), messages, indexOffset, width);
+}