@ian-pascoe/pi-minimal-subagents 0.11.0 → 0.13.0

package/src/minimal-subagents-tools.ts

@@ -9,6 +9,7 @@ import {
   type ToolDefinition,
   type ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
 import type { MinimalSubagentsCoordinator } from "./minimal-subagents-coordinator.js";
 import { withTroubleshootingHint } from "./troubleshooting-skill.js";
 import type { MinimalSubagentsModelRole } from "./minimal-subagents-config.js";
@@ -16,13 +17,21 @@ import {
   renderCoordinatorToolCall,
   renderCoordinatorToolResult,
   type CoordinatorToolName,
+  type LiveTurnRenderer,
 } from "./minimal-subagents-rendering.js";
+import {
+  createTranscriptRenderCache,
+  TranscriptRail,
+  type TranscriptRenderCache,
+} from "./minimal-subagents-transcript.js";
 import {
   CoordinatorToolOutputSchemas,
   type CoordinatorToolCallInput,
 } from "./minimal-subagents-render-contract.js";
 import type { createCoordinatorToolSchemas } from "./minimal-subagents-tool-schemas.js";
 import type {
+  ActiveTurnProgress,
+  AgentDetail,
   AgentMessageResult,
   CallerSnapshot,
   CancelResult,
@@ -41,7 +50,15 @@ const ORDINARY_CHILD_COORDINATOR_TOOL_NAMES = new Set([
 /** Coordinator operations consumed by the six public coordinator tool definitions. */
 export type CoordinatorToolOperations = Pick<
   MinimalSubagentsCoordinator,
-  "spawn" | "inspectStatus" | "sendAgentMessage" | "wait" | "status" | "cancel" | "delete"
+  | "spawn"
+  | "inspectStatus"
+  | "previewActiveTurn"
+  | "inspectActiveTurnTranscript"
+  | "sendAgentMessage"
+  | "wait"
+  | "status"
+  | "cancel"
+  | "delete"
 >;
 
 /** Dependencies and caller policy used to create caller-bound coordinator tools. */
@@ -81,37 +98,84 @@ async function runCoordinatorToolActivity<T>(
   }
 }
 
+/** The compact launch result, plus the full agent detail its transcript renderer displays. */
+type SpawnResultDetails = SpawnResult & { agent?: AgentDetail };
+
 type CoordinatorToolResultDetails =
-  | SpawnResult
+  | SpawnResultDetails
   | AgentMessageResult
   | WaitResult
   | StatusResult
   | CancelResult
   | DeleteResult
-  | { agent_id: string; status: "waiting"; elapsed_ms: number };
+  | WaitProgressDetails;
+
+/** Partial `subagent_wait` details: elapsed wait time plus the child's running-turn progress. */
+type WaitProgressDetails = {
+  agent_id: string;
+  status: "waiting";
+  elapsed_ms: number;
+} & Partial<ActiveTurnProgress>;
 
 type CoordinatorToolDefinition = ToolDefinition & {
   readonly outputSchema: (typeof CoordinatorToolOutputSchemas)[keyof typeof CoordinatorToolOutputSchemas];
 };
 
-function createCoordinatorToolRendering(toolName: CoordinatorToolName) {
+/** Native transcript components are re-rendered on each wait update, so their render requests are not needed. */
+const NON_RENDERING_TUI: Pick<TUI, "requestRender"> = { requestRender: () => undefined };
+
+/** Pi's per-call render context; the installed Pi does not export its named type. */
+type CoordinatorToolRenderContext = Parameters<NonNullable<ToolDefinition["renderResult"]>>[3];
+
+/** Renderer state Pi keeps for one tool row across its partial and final renders. */
+interface CoordinatorToolRowState {
+  liveTurnCache?: TranscriptRenderCache;
+}
+
+function createCoordinatorToolRendering(
+  options: CoordinatorToolDefinitionOptions,
+  toolName: CoordinatorToolName,
+) {
   return {
-    renderCall: (args: CoordinatorToolCallInput, theme: Theme) =>
-      renderCoordinatorToolCall(toolName, args, theme),
+    renderCall: (
+      args: CoordinatorToolCallInput,
+      theme: Theme,
+      context: { expanded: boolean } | undefined,
+    ) => renderCoordinatorToolCall(toolName, args, theme, context?.expanded ?? false),
     renderResult: (
       result: AgentToolResult<CoordinatorToolResultDetails>,
       renderOptions: ToolRenderResultOptions,
       theme: Theme,
-      context: { args: CoordinatorToolCallInput; isError: boolean },
-    ) =>
-      renderCoordinatorToolResult(
+      context: CoordinatorToolRenderContext,
+    ) => {
+      const rowState: CoordinatorToolRowState = context.state;
+      const renderLiveTurn: LiveTurnRenderer = (agentId, turnId, expanded) => {
+        const snapshot = options.coordinator.inspectActiveTurnTranscript(
+          options.callerId,
+          agentId,
+          turnId,
+        );
+        if (!snapshot || snapshot.messages.length === 0) return undefined;
+        return new TranscriptRail(
+          snapshot,
+          // SAFETY: Native transcript components only call requestRender on the TUI they receive.
+          NON_RENDERING_TUI as TUI,
+          context.cwd,
+          expanded,
+          (rowState.liveTurnCache ??= createTranscriptRenderCache()),
+          theme,
+        );
+      };
+      return renderCoordinatorToolResult(
         toolName,
         result,
         renderOptions,
         theme,
         context.args,
         context.isError,
-      ),
+        toolName === "subagent_wait" ? renderLiveTurn : undefined,
+      );
+    },
   };
 }
 
@@ -130,13 +194,31 @@ function structuredToolResult<TDetails extends CoordinatorToolResultDetails>(
   };
 }
 
-function failedStructuredOperation(prefix: string, result: DeleteResult): never {
-  const json = JSON.stringify(result);
-  const truncated = truncateHead(json, {
-    maxBytes: DEFAULT_MAX_BYTES,
-    maxLines: DEFAULT_MAX_LINES,
-  });
-  throw new Error(withTroubleshootingHint(`${prefix}: ${truncated.content}`));
+/**
+ * Report a failed operation that still carries declared output: the model sees an error and
+ * codemode scripts receive `structuredContent` instead of a data-less rejection.
+ */
+function failedStructuredToolResult<TDetails extends CoordinatorToolResultDetails>(
+  prefix: string,
+  result: TDetails,
+  options: { troubleshootingHint: boolean },
+): AgentToolResult<TDetails> & { isError: true } {
+  const success = structuredToolResult(result);
+  const text = `${prefix}:\n${textOf(success)}`;
+  return {
+    ...success,
+    content: [
+      {
+        type: "text" as const,
+        text: options.troubleshootingHint ? withTroubleshootingHint(text) : text,
+      },
+    ],
+    isError: true,
+  };
+}
+
+function textOf(result: AgentToolResult<unknown>): string {
+  return result.content.map((part) => (part.type === "text" ? part.text : "")).join("\n");
 }
 
 function callerSourceTurnId(
@@ -160,10 +242,18 @@ export function createCoordinatorToolDefinitions(
     name: "subagent",
     label: "Subagent",
     description:
-      "Create a persistent nested agent asynchronously. Returns its canonical agent ID and active turn ID immediately. Root-child IDs omit the root prefix; nested IDs retain the parent path.",
+      "Create a persistent nested agent asynchronously. Returns its canonical agent ID, active turn ID, and resolved model and tools immediately. Root-child IDs omit the root prefix; nested IDs retain the parent path. Children start without your conversation unless session_context opts in, so the task must be self-contained. Its final response is delivered automatically unless you claim it with subagent_wait. To continue an idle child later, send it agent_message; that starts a new turn you can wait on.",
     promptSnippet: "Spawn a persistent child with a prefix-free root-child ID",
     promptGuidelines: modelRolePromptGuidelines,
     parameters: options.schemas.subagent,
+    // A spawn must finish registering before a wait or message in the same batch can target it.
+    executionMode: "sequential",
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true,
+    },
     async execute(_toolCallId, parameters, _signal, _onUpdate, context) {
       return runCoordinatorToolActivity(options, async () => {
         const result = await options.coordinator.spawn(
@@ -171,26 +261,30 @@ export function createCoordinatorToolDefinitions(
           parameters,
           options.captureCaller(context),
         );
+        // The model and codemode receive the compact launch result; the transcript renderer
+        // additionally receives the full detail it displays.
         const status = options.coordinator.inspectStatus(result.agent_id);
-        const details: SpawnResult & {
-          agent?: import("./minimal-subagents-types.js").AgentDetail;
-        } = {
-          ...result,
-        };
-        if (status && "agent" in status) details.agent = status.agent;
-        return structuredToolResult(details);
+        const details: SpawnResultDetails = { ...result };
+        if ("agent" in status) details.agent = status.agent;
+        return { ...structuredToolResult(result), details };
       });
     },
-    ...createCoordinatorToolRendering("subagent"),
+    ...createCoordinatorToolRendering(options, "subagent"),
   });
 
   const messageTool = defineTool({
     name: "agent_message",
     label: "Agent Message",
     description:
-      "Send one mid-turn coordination message to a direct parent, direct sibling, or direct child. The result says whether it was delivered through an active wait, queued for the recipient, or failed.",
+      "Send one coordination message to a direct parent, direct sibling, or direct child. The result says whether it was delivered through an active wait, queued into the recipient's active turn, started a new turn on an idle child (with its turn_id), or failed.",
     promptSnippet: "Coordinate required mid-turn action with one adjacent agent",
     parameters: options.schemas.agent_message,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+    },
     async execute(toolCallId, parameters) {
       return runCoordinatorToolActivity(options, async () => {
         const result = await options.coordinator.sendAgentMessage(
@@ -201,30 +295,48 @@ export function createCoordinatorToolDefinitions(
           },
           callerSourceTurnId(options.coordinator, options.callerId, toolCallId),
         );
-        return structuredToolResult(result);
+        return result.disposition === "failed"
+          ? failedStructuredToolResult("Minimal subagents message delivery failed", result, {
+              // The coordinator already appends the hint to `error`.
+              troubleshootingHint: false,
+            })
+          : structuredToolResult(result);
       });
     },
-    ...createCoordinatorToolRendering("agent_message"),
+    ...createCoordinatorToolRendering(options, "agent_message"),
   });
 
   const waitTool = defineTool({
     name: "subagent_wait",
     label: "Subagent Wait",
     description:
-      "Wait for one direct child's oldest observable turn, or select an exact retained turn_id. An active child may first return event=message; later unconsumed items still fall back automatically. An already settled turn returns event=turn once with queued messages in messages. Timeout returns event=timeout with detailed child status and never cancels the child.",
+      "Wait for one direct child's oldest observable turn, or select an exact retained turn_id. An active child may first return event=message; later unconsumed items still fall back automatically. A settled turn returns event=turn, with any queued messages in messages; waiting again returns the same result. Timeout returns event=timeout with detailed child status and never cancels the child.",
     promptSnippet: "Wait for one direct child's exact turn",
     parameters: options.schemas.subagent_wait,
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+    },
     async execute(_toolCallId, parameters, signal, onUpdate) {
       const startedAt = Date.now();
-      const updateWaitingResult = () =>
+      const updateWaitingResult = () => {
+        const details: WaitProgressDetails = {
+          agent_id: parameters.agent_id,
+          status: "waiting",
+          elapsed_ms: Date.now() - startedAt,
+          ...options.coordinator.previewActiveTurn(
+            options.callerId,
+            parameters.agent_id,
+            parameters.turn_id,
+          ),
+        };
         onUpdate?.({
           content: [{ type: "text", text: `Waiting for ${parameters.agent_id}` }],
-          details: {
-            agent_id: parameters.agent_id,
-            status: "waiting",
-            elapsed_ms: Date.now() - startedAt,
-          },
+          details,
         });
+      };
       updateWaitingResult();
       const waitingInterval = setInterval(updateWaitingResult, 1_000);
       waitingInterval.unref?.();
@@ -252,22 +364,28 @@ export function createCoordinatorToolDefinitions(
         clearInterval(waitingInterval);
       }
     },
-    ...createCoordinatorToolRendering("subagent_wait"),
+    ...createCoordinatorToolRendering(options, "subagent_wait"),
   });
 
   const statusTool = defineTool({
     name: "subagent_status",
     label: "Subagent Status",
     description:
-      "List direct children when agent_id is omitted, or inspect one direct child's launch contract, result, usage, dependencies, and bounded recent activity including message text and reasoning.",
+      "List direct children when agent_id is omitted, or inspect one direct child's launch contract, result, usage, dependencies, and bounded recent activity including message text and reasoning. The root may inspect any descendant.",
     promptSnippet: "Inspect direct child state",
     parameters: options.schemas.subagent_status,
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
     async execute(_toolCallId, parameters) {
       return runCoordinatorToolActivity(options, () =>
         structuredToolResult(options.coordinator.status(options.callerId, parameters.agent_id)),
       );
     },
-    ...createCoordinatorToolRendering("subagent_status"),
+    ...createCoordinatorToolRendering(options, "subagent_status"),
   });
 
   const cancelTool = defineTool({
@@ -277,6 +395,12 @@ export function createCoordinatorToolDefinitions(
       "Abort active work for one direct child while preserving sessions for later continuation. Recursive cancellation includes its subtree and defaults to true.",
     promptSnippet: "Cancel active subagent turns without deleting sessions",
     parameters: options.schemas.subagent_cancel,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
     async execute(_toolCallId, parameters) {
       return runCoordinatorToolActivity(options, async () =>
         structuredToolResult(
@@ -288,7 +412,7 @@ export function createCoordinatorToolDefinitions(
         ),
       );
     },
-    ...createCoordinatorToolRendering("subagent_cancel"),
+    ...createCoordinatorToolRendering(options, "subagent_cancel"),
   });
 
   const deleteTool = defineTool({
@@ -298,6 +422,12 @@ export function createCoordinatorToolDefinitions(
       "Delete one direct child's persistent session and retain durable ID tombstones. Recursive deletion includes its subtree and defaults to true.",
     promptSnippet: "Delete subagent sessions and tombstone their IDs",
     parameters: options.schemas.subagent_delete,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
     async execute(_toolCallId, parameters) {
       return runCoordinatorToolActivity(options, async () => {
         const result = await options.coordinator.delete(
@@ -309,12 +439,14 @@ export function createCoordinatorToolDefinitions(
           options.onAttention?.(
             `Minimal subagents deletion partially failed for ${parameters.agent_id}`,
           );
-          failedStructuredOperation("Minimal subagents deletion partially failed", result);
+          return failedStructuredToolResult("Minimal subagents deletion partially failed", result, {
+            troubleshootingHint: true,
+          });
         }
         return structuredToolResult(result);
       });
     },
-    ...createCoordinatorToolRendering("subagent_delete"),
+    ...createCoordinatorToolRendering(options, "subagent_delete"),
   });
 
   const coordinatorTools: CoordinatorToolDefinition[] = [

package/src/minimal-subagents-transcript.ts

@@ -0,0 +1,296 @@
+import { stripVTControlCharacters } from "node:util";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { contentText } from "@earendil-works/pi-ai";
+import {
+  AssistantMessageComponent,
+  BashExecutionComponent,
+  BranchSummaryMessageComponent,
+  CompactionSummaryMessageComponent,
+  CustomMessageComponent,
+  ToolExecutionComponent,
+  UserMessageComponent,
+  type TruncationResult,
+} from "@earendil-works/pi-coding-agent";
+import { Container, Text, type Component, type TUI } from "@earendil-works/pi-tui";
+import {
+  ACTIVITY_RAIL_WIDTH,
+  drawActivityRail,
+  renderMinimalSubagentsMessage,
+  renderMinimalSubagentsResult,
+  type MinimalSubagentsRenderTheme,
+} from "./minimal-subagents-rendering.js";
+import type { ChildAgentTranscriptSnapshot } from "./minimal-subagents-types.js";
+
+interface CachedTranscriptMessage {
+  container: Container;
+  tools: Map<string, ToolExecutionComponent>;
+  expanded: boolean;
+  streaming: boolean;
+}
+
+/** Rendered transcript lines and the first line of each message. */
+export interface TranscriptLayout {
+  lines: string[];
+  messageStarts: number[];
+  /** First line of each native component, such as one assistant reply or one tool execution. */
+  itemStarts: number[];
+}
+
+/** Native components reused across renders while their source messages are unchanged. */
+export interface TranscriptRenderCache {
+  messages: WeakMap<AgentMessage, CachedTranscriptMessage>;
+  results: WeakMap<ToolExecutionComponent, AgentMessage>;
+}
+
+/** Render a Child Session Transcript with Pi's native message and tool components. */
+export function renderTranscriptSnapshot(
+  snapshot: ChildAgentTranscriptSnapshot,
+  tui: TUI,
+  cwd: string,
+  expanded: boolean,
+  width: number,
+  cache: TranscriptRenderCache,
+): TranscriptLayout {
+  if (snapshot.messages.length === 0) {
+    return {
+      lines: new Text(snapshot.fallback || "No conversation messages yet.", 3, 0).render(width),
+      messageStarts: [0],
+      itemStarts: [0],
+    };
+  }
+  const blocks: Container[] = [];
+  const tools = new Map(
+    snapshot.toolDefinitions.map((definition) => [definition.name, definition]),
+  );
+  const pendingTools = new Map<string, ToolExecutionComponent>();
+  const currentMessages = new Set(snapshot.messages);
+
+  for (const [messageIndex, message] of snapshot.messages.entries()) {
+    if (message.role === "toolResult") {
+      const paired = pendingTools.get(message.toolCallId);
+      if (paired) {
+        if (cache.results.get(paired) !== message) {
+          paired.updateResult(message);
+          cache.results.set(paired, message);
+        }
+        pendingTools.delete(message.toolCallId);
+        blocks.push(new Container());
+        continue;
+      }
+    }
+    const streaming = messageIndex === snapshot.streamingAssistantIndex;
+    const cached = cache.messages.get(message);
+    const staleResult =
+      cached &&
+      [...cached.tools.values()].some((tool) => {
+        const result = cache.results.get(tool);
+        return result !== undefined && !currentMessages.has(result);
+      });
+    if (cached && !staleResult && cached.expanded === expanded && cached.streaming === streaming) {
+      blocks.push(cached.container);
+      for (const [id, tool] of cached.tools) pendingTools.set(id, tool);
+      continue;
+    }
+    const container = new Container();
+    const messageTools = new Map<string, ToolExecutionComponent>();
+    switch (message.role) {
+      case "user": {
+        const text = contentText(message.content, "\n\n");
+        if (text) container.addChild(new UserMessageComponent(text));
+        break;
+      }
+      case "assistant": {
+        const assistant = new AssistantMessageComponent(message);
+        assistant.updateContent(message, messageIndex === snapshot.streamingAssistantIndex);
+        container.addChild(assistant);
+        for (const content of message.content) {
+          if (content.type !== "toolCall") continue;
+          const tool = new ToolExecutionComponent(
+            content.name,
+            content.id,
+            content.arguments,
+            { showImages: false },
+            tools.get(content.name) ?? {},
+            tui,
+            cwd,
+          );
+          tool.setExpanded(expanded);
+          container.addChild(tool);
+          if (message.stopReason === "aborted" || message.stopReason === "error") {
+            tool.updateResult({
+              content: [
+                {
+                  type: "text",
+                  text:
+                    message.stopReason === "aborted"
+                      ? "Operation aborted"
+                      : (message.errorMessage ?? "Error"),
+                },
+              ],
+              isError: true,
+            });
+          } else {
+            pendingTools.set(content.id, tool);
+            messageTools.set(content.id, tool);
+          }
+        }
+        break;
+      }
+      case "toolResult": {
+        const inherited = new ToolExecutionComponent(
+          message.toolName,
+          message.toolCallId,
+          {},
+          { showImages: false },
+          {},
+          tui,
+          cwd,
+        );
+        inherited.setExpanded(expanded);
+        inherited.updateResult(message);
+        container.addChild(inherited);
+        break;
+      }
+      case "custom": {
+        if (!message.display) break;
+        const renderer =
+          message.customType === "minimal-subagents.message"
+            ? renderMinimalSubagentsMessage
+            : message.customType === "minimal-subagents.result"
+              ? renderMinimalSubagentsResult
+              : undefined;
+        const custom = new CustomMessageComponent(message, renderer);
+        custom.setExpanded(expanded);
+        container.addChild(custom);
+        break;
+      }
+      case "bashExecution": {
+        const bash = new BashExecutionComponent(message.command, tui, message.excludeFromContext);
+        if (message.output) bash.appendOutput(message.output);
+        bash.setComplete(
+          message.exitCode,
+          message.cancelled,
+          // SAFETY: Persisted bash messages retain only the truncation flag; BashExecutionComponent reads that flag here.
+          message.truncated ? ({ truncated: true } as TruncationResult) : undefined,
+          message.fullOutputPath,
+        );
+        bash.setExpanded(expanded);
+        container.addChild(bash);
+        break;
+      }
+      case "branchSummary": {
+        const summary = new BranchSummaryMessageComponent(message);
+        summary.setExpanded(expanded);
+        container.addChild(summary);
+        break;
+      }
+      case "compactionSummary": {
+        const summary = new CompactionSummaryMessageComponent(message);
+        summary.setExpanded(expanded);
+        container.addChild(summary);
+        break;
+      }
+    }
+    cache.messages.set(message, { container, tools: messageTools, expanded, streaming });
+    blocks.push(container);
+  }
+  let length = 0;
+  const messageStarts: number[] = [];
+  const itemStarts: number[] = [];
+  // Containers concatenate their children, so rendering children one by one yields the same lines.
+  const lines = blocks.flatMap((block) => {
+    messageStarts.push(length);
+    return block.children.flatMap((child) => {
+      itemStarts.push(length);
+      // Native user-message prompt zones belong to the main terminal, not an embedded overlay.
+      const rendered = child
+        .render(width)
+        .map((line) =>
+          line
+            .replaceAll("\x1b]133;A\x07", "")
+            .replaceAll("\x1b]133;B\x07", "")
+            .replaceAll("\x1b]133;C\x07", ""),
+        );
+      length += rendered.length;
+      return rendered;
+    });
+  });
+  return { lines, messageStarts, itemStarts };
+}
+
+/** Create an empty cache for {@link renderTranscriptSnapshot}. */
+export function createTranscriptRenderCache(): TranscriptRenderCache {
+  return { messages: new WeakMap(), results: new WeakMap() };
+}
+
+/** Collapsed live views keep at most this many lines of the child's recent work. */
+const COLLAPSED_TRANSCRIPT_RAIL_LINES = 20;
+
+function isSpacerLine(line: string): boolean {
+  // Includes a tool box's coloured padding rows, so each rail connector meets visible content.
+  return stripVTControlCharacters(line).trim().length === 0;
+}
+
+function withoutSpacerEdges(lines: string[]): string[] {
+  const start = lines.findIndex((line) => !isSpacerLine(line));
+  if (start < 0) return [];
+  const end = lines.findLastIndex((line) => !isSpacerLine(line));
+  return lines.slice(start, end + 1);
+}
+
+/**
+ * A child's recent transcript drawn with Pi's native message and tool components, one rail item
+ * per component. Collapsed, it keeps the latest items that fit the line budget.
+ */
+export class TranscriptRail implements Component {
+  constructor(
+    private readonly snapshot: ChildAgentTranscriptSnapshot,
+    private readonly tui: TUI,
+    private readonly cwd: string,
+    private readonly expanded: boolean,
+    private readonly cache: TranscriptRenderCache,
+    private readonly theme: MinimalSubagentsRenderTheme,
+  ) {}
+
+  render(width: number): string[] {
+    const layout = renderTranscriptSnapshot(
+      this.snapshot,
+      this.tui,
+      this.cwd,
+      this.expanded,
+      Math.max(1, width - ACTIVITY_RAIL_WIDTH),
+      this.cache,
+    );
+    const items = layout.itemStarts
+      .map((start, index) =>
+        withoutSpacerEdges(layout.lines.slice(start, layout.itemStarts[index + 1])),
+      )
+      .filter((lines) => lines.length > 0);
+    if (this.expanded) return drawActivityRail(items, this.theme);
+    let shown = 0;
+    let lineCount = 0;
+    for (const item of items.toReversed()) {
+      if (shown > 0 && lineCount + item.length > COLLAPSED_TRANSCRIPT_RAIL_LINES) break;
+      shown++;
+      lineCount += item.length;
+    }
+    const kept = items
+      .slice(items.length - shown)
+      .map((lines) => lines.slice(0, COLLAPSED_TRANSCRIPT_RAIL_LINES));
+    const earlier = items.length - shown;
+    return drawActivityRail(
+      earlier > 0
+        ? [
+            [this.theme.fg("dim", `… ${earlier} earlier ${earlier === 1 ? "step" : "steps"}`)],
+            ...kept,
+          ]
+        : kept,
+      this.theme,
+    );
+  }
+
+  invalidate(): void {
+    this.cache.messages = new WeakMap();
+    this.cache.results = new WeakMap();
+  }
+}