@esso0428/pi-subagents 0.15.5 → 0.15.6

package/src/index.ts

@@ -24,7 +24,8 @@ import { isModelInScope, readEnabledModels, resolveEnabledModels } from "./enabl
 import { GroupJoinManager } from "./group-join.js";
 import { resolveAgentInvocationConfig, resolveJoinMode } from "./invocation-config.js";
 import { type ModelRegistry, resolveModel } from "./model-resolver.js";
-import { agentHistoryLocator, createAgentHistoryPath, ensureSubagentsGitignore, hasAgentHistory, readAgentHistory } from "./agent-history.js";
+import { agentHistoryLocator, createAgentHistoryPath, readAgentHistory } from "./agent-history.js";
+import { buildAgentStatusMenuEntries, canOpenActiveAgent, canOpenAgentHistory, formatAgentHistoryOption, splitAgentRecords } from "./agent-history-list.js";
 import { createOutputFilePath, streamToOutputFile, writeInitialEntry } from "./output-file.js";
 import { SubagentScheduler } from "./schedule.js";
 import { resolveStorePath, ScheduleStore } from "./schedule-store.js";
@@ -49,7 +50,6 @@ import {
   type UICtx,
 } from "./ui/agent-widget.js";
 import { FleetList, type FleetUICtx } from "./ui/fleet-list.js";
-import { createMarkdownResult } from "./ui/markdown-result.js";
 import { showSchedulesMenu } from "./ui/schedule-menu.js";
 import { addUsage, getLifetimeTotal, getSessionContextPercent, type LifetimeUsage } from "./usage.js";
 
@@ -242,9 +242,6 @@ function buildDetails(
   };
 }
 
-/** Maximum expanded notification body retained in message details. */
-const MAX_NOTIFICATION_RESULT_TEXT_LENGTH = 20_000;
-
 /** Build notification details for the custom message renderer. */
 function buildNotificationDetails(record: AgentRecord, resultMaxLen: number, activity?: AgentActivity): NotificationDetails {
   const totalTokens = getLifetimeTotal(record.lifetimeUsage);
@@ -260,11 +257,6 @@ function buildNotificationDetails(record: AgentRecord, resultMaxLen: number, act
     durationMs: record.completedAt ? record.completedAt - record.startedAt : 0,
     outputFile: record.outputFile,
     error: record.error,
-    resultText: record.result
-      ? record.result.length > MAX_NOTIFICATION_RESULT_TEXT_LENGTH
-        ? record.result.slice(0, MAX_NOTIFICATION_RESULT_TEXT_LENGTH) + "…"
-        : record.result
-      : undefined,
     resultPreview: record.result
       ? record.result.length > resultMaxLen
         ? record.result.slice(0, resultMaxLen) + "…"
@@ -281,7 +273,7 @@ export default function (pi: ExtensionAPI) {
       const d = message.details;
       if (!d) return undefined;
 
-      function renderOne(d: NotificationDetails): string | Container {
+      function renderOne(d: NotificationDetails): string {
         const isError = d.status === "error" || d.status === "stopped" || d.status === "aborted";
         const icon = isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
         const statusText = isError ? d.status
@@ -301,34 +293,25 @@ export default function (pi: ExtensionAPI) {
           line += "\n  " + parts.map(p => theme.fg("dim", p)).join(" " + theme.fg("dim", "·") + " ");
         }
 
-        if (!expanded) {
-          // Collapsed previews intentionally remain compact plain text.
+        // Line 3: result preview (collapsed) or full (expanded)
+        if (expanded) {
+          const lines = d.resultPreview.split("\n").slice(0, 30);
+          for (const l of lines) line += "\n" + theme.fg("dim", `  ${l}`);
+        } else {
           const preview = d.resultPreview.split("\n")[0]?.slice(0, 80) ?? "";
           line += "\n  " + theme.fg("dim", `⎿  ${preview}`);
-          if (d.outputFile) {
-            line += "\n  " + theme.fg("muted", `transcript: ${d.outputFile}`);
-          }
-          return line;
         }
 
-        const container = new Container();
-        container.addChild(new Text(line, 0, 0));
-        container.addChild(createMarkdownResult(d.resultText ?? d.resultPreview, theme, 30));
+        // Line 4: output file link (if present)
         if (d.outputFile) {
-          container.addChild(new Text(theme.fg("muted", `  transcript: ${d.outputFile}`), 0, 0));
+          line += "\n  " + theme.fg("muted", `transcript: ${d.outputFile}`);
         }
-        return container;
+
+        return line;
       }
 
       const all = [d, ...(d.others ?? [])];
-      if (!expanded) return new Text(all.map(renderOne).join("\n"), 0, 0);
-
-      const container = new Container();
-      all.forEach((item, index) => {
-        if (index > 0) container.addChild(new Spacer(1));
-        container.addChild(renderOne(item) as Container);
-      });
-      return container;
+      return new Text(all.map(renderOne).join("\n"), 0, 0);
     }
   );
 
@@ -463,9 +446,7 @@ export default function (pi: ExtensionAPI) {
       pi.events.emit("subagents:completed", eventData);
     }
 
-    // Persist final record for cross-extension history reconstruction. Keep
-    // the transcript body in a project-local file rather than inflating the
-    // parent session JSONL; only its project-relative locator is persisted.
+    // Persist final record for cross-extension history reconstruction
     pi.appendEntry("subagents:record", {
       id: record.id, type: record.type, description: record.description,
       status: record.status, result: record.result, error: record.error,
@@ -574,22 +555,11 @@ export default function (pi: ExtensionAPI) {
   // bound session_start, so a filtered-out activation never advertises (#142).
   pi.on("session_start", async (_event, ctx) => {
     currentCtx = ctx;
-    try {
-      ensureSubagentsGitignore(ctx.cwd);
-    } catch (err) {
-      console.warn("[pi-subagents] Failed to protect project-local history:", err);
-    }
     manager.clearCompleted(true);
-    const historicalRecords = ctx.sessionManager
-      .getBranch()
-      .filter((entry: any) => entry?.type === "custom" && entry.customType === "subagents:record")
-      .map((entry: any) => entry.data);
-    manager.restoreCompleted(historicalRecords);
-    // Bind the UI here as well as on tool execution so rehydrated terminal
-    // records are immediately visible and openable from FleetView after reload.
-    widget.setUICtx(ctx.ui as UICtx);
-    fleet.setUICtx(ctx.ui as unknown as FleetUICtx);
-    fleet.update();
+    const branch = ctx.sessionManager?.getBranch?.() ?? [];
+    manager.restoreCompleted(branch
+      .filter((entry: any) => entry?.type === "custom" && entry?.customType === "subagents:record")
+      .map((entry: any) => entry.data));
     // Guard mirrors the `!scheduler.isActive()` pattern below: session_start
     // fires once per activation, but a double-bind must not leak listeners.
     if (!rpcHandle) {
@@ -640,11 +610,11 @@ export default function (pi: ExtensionAPI) {
   // everything else; "off" = hide the widget entirely. Read live at render time.
   let widgetMode: WidgetMode = "background";
   function getWidgetMode(): WidgetMode { return widgetMode; }
-  const widget = new AgentWidget(manager, agentActivity, getWidgetMode, () => currentCtx?.cwd);
+  const widget = new AgentWidget(manager, agentActivity, getWidgetMode);
   function setWidgetMode(m: WidgetMode): void { widgetMode = m; widget.update(); }
 
   // Claude Code-style FleetView: navigable list of main + subagents below the editor.
-  const fleet = new FleetList(manager, agentActivity, () => currentCtx?.cwd);
+  const fleet = new FleetList(manager, agentActivity, () => currentCtx?.cwd, pi, () => currentCtx);
   let fleetViewEnabled = true;
   function isFleetViewEnabled(): boolean { return fleetViewEnabled; }
   function setFleetViewEnabled(b: boolean): void { fleetViewEnabled = b; fleet.setEnabled(b); }
@@ -1061,15 +1031,15 @@ Terse command-style prompts produce shallow, generic work.
 
         if (expanded) {
           const resultText = result.content[0]?.type === "text" ? result.content[0].text : "";
-          const container = new Container();
-          container.addChild(new Text(line, 0, 0));
           if (resultText) {
-            container.addChild(createMarkdownResult(resultText, theme, 50));
+            const lines = resultText.split("\n").slice(0, 50);
+            for (const l of lines) {
+              line += "\n" + theme.fg("dim", `  ${l}`);
+            }
             if (resultText.split("\n").length > 50) {
-              container.addChild(new Text(theme.fg("muted", "  ... (use get_subagent_result with verbose for full output)"), 0, 0));
+              line += "\n" + theme.fg("muted", "  ... (use get_subagent_result with verbose for full output)");
             }
           }
-          return container;
         } else {
           const doneText = isSteered ? "Wrapped up (turn limit)" : "Done";
           line += "\n" + theme.fg("dim", `  ⎿  ${doneText}`);
@@ -1176,17 +1146,17 @@ Terse command-style prompts produce shallow, generic work.
         rec.outputFile = createOutputFilePath(ctx.cwd, agentId, ctx.sessionManager.getSessionId());
         writeInitialEntry(rec.outputFile, agentId, params.prompt, ctx.cwd);
 
-        // Keep the existing /tmp output for compatibility, while also writing a
-        // durable project-local copy for reload-safe, read-only history viewing.
         try {
-          rec.historyFile = createAgentHistoryPath(ctx.cwd, agentId, subagentType);
+          rec.historyFile = createAgentHistoryPath(ctx.cwd, agentId);
           rec.transcriptPath = agentHistoryLocator(ctx.cwd, rec.historyFile);
           writeInitialEntry(rec.historyFile, agentId, params.prompt, ctx.cwd);
         } catch (err) {
-          // History is best effort; never disable the existing output transcript.
           rec.historyFile = undefined;
           rec.transcriptPath = undefined;
-          console.warn("[pi-subagents] Failed to create durable transcript:", err);
+          ctx.ui.notify(
+            `Could not create durable transcript for agent ${agentId}: ${err instanceof Error ? err.message : String(err)}`,
+            "warning",
+          );
         }
       };
 
@@ -1667,17 +1637,10 @@ Terse command-style prompts produce shallow, generic work.
     // Build select options
     const options: string[] = [];
 
-    // Only advertise agents that can actually be opened. Reload-restored
-    // metadata without a live session or durable transcript is intentionally
-    // invisible here, matching FleetView and showRunningAgents below.
-    const agents = manager.listAgents().filter((record) =>
-      record.session !== undefined || hasAgentHistory(ctx.cwd, record.transcriptPath),
-    );
-    if (agents.length > 0) {
-      const running = agents.filter(a => a.status === "running" || a.status === "queued").length;
-      const done = agents.filter(a => a.status === "completed" || a.status === "steered").length;
-      options.push(`Running agents (${agents.length}) — ${running} running, ${done} done`);
-    }
+    // Keep active agents and terminal history in separate menu entries.
+    const records = manager.listAgents();
+    const { active, history } = splitAgentRecords(records, ctx.cwd);
+    options.push(...buildAgentStatusMenuEntries(records, ctx.cwd));
 
     // Agent types list
     if (allNames.length > 0) {
@@ -1694,7 +1657,7 @@ Terse command-style prompts produce shallow, generic work.
     options.push("Create new agent");
     options.push("Settings");
 
-    const noAgentsMsg = allNames.length === 0 && agents.length === 0
+    const noAgentsMsg = allNames.length === 0 && active.length === 0 && history.length === 0
       ? "No agents found. Create specialized subagents that can be delegated to.\n\n" +
         "Each subagent has its own context window, custom system prompt, and specific tools.\n\n" +
         "Try creating: Code Reviewer, Security Auditor, Test Writer, or Documentation Writer.\n\n"
@@ -1710,6 +1673,9 @@ Terse command-style prompts produce shallow, generic work.
     if (choice.startsWith("Running agents (")) {
       await showRunningAgents(ctx);
       await showAgentsMenu(ctx);
+    } else if (choice.startsWith("Agent history (")) {
+      await showAgentHistory(ctx);
+      await showAgentsMenu(ctx);
     } else if (choice.startsWith("Agent types (")) {
       await showAllAgentsList(ctx);
       await showAgentsMenu(ctx);
@@ -1793,9 +1759,7 @@ Terse command-style prompts produce shallow, generic work.
   }
 
   async function showRunningAgents(ctx: ExtensionCommandContext) {
-    const agents = manager.listAgents().filter((record) =>
-      record.session !== undefined || hasAgentHistory(ctx.cwd, record.transcriptPath),
-    );
+    const { active: agents } = splitAgentRecords(manager.listAgents(), ctx.cwd);
     if (agents.length === 0) {
       ctx.ui.notify("No agents.", "info");
       return;
@@ -1815,31 +1779,61 @@ Terse command-style prompts produce shallow, generic work.
     if (idx < 0) return;
     const record = agents[idx];
 
-    await viewAgentConversation(ctx, record);
+    await viewAgentConversation(ctx, record, "live");
     // Back-navigation: re-show the list
     await showRunningAgents(ctx);
   }
 
-  async function viewAgentConversation(ctx: ExtensionCommandContext, record: AgentRecord) {
-    if (!record.session) {
-      ctx.ui.notify(`Agent is ${record.status === "queued" ? "queued" : "expired"} — no session available.`, "info");
+  async function showAgentHistory(ctx: ExtensionCommandContext) {
+    const { history } = splitAgentRecords(manager.listAgents(), ctx.cwd);
+    if (history.length === 0) {
+      ctx.ui.notify("No agent history.", "info");
+      return;
+    }
+
+    const options = history.map(record => formatAgentHistoryOption(record, Date.now()));
+    const choice = await ctx.ui.select("Agent history", options);
+    if (!choice) return;
+    const record = history[options.indexOf(choice)];
+    if (!record) return;
+
+    await viewAgentConversation(ctx, record, "history");
+  }
+
+  async function viewAgentConversation(
+    ctx: ExtensionCommandContext,
+    record: AgentRecord,
+    mode: "live" | "history",
+  ) {
+    if (mode === "live" && !canOpenActiveAgent(record)) {
+      ctx.ui.notify(`Agent is ${record.status === "queued" ? "queued" : "expired"} — no history available.`, "info");
+      return;
+    }
+    if (mode === "history" && !canOpenAgentHistory(record, ctx.cwd)) {
+      ctx.ui.notify("No agent history.", "info");
       return;
     }
 
     const { ConversationViewer, VIEWPORT_HEIGHT_PCT, createStaticConversationSource } = await import("./ui/conversation-viewer.js");
-    const session = record.session ?? (record.transcriptPath
-      ? (() => {
-          const messages = readAgentHistory(ctx.cwd, record.transcriptPath!);
-          return messages ? createStaticConversationSource(messages) : undefined;
-        })()
-      : undefined);
+    const session = mode === "live"
+      ? record.session
+      : (() => {
+          const messages = record.transcriptPath
+            ? readAgentHistory(ctx.cwd, record.transcriptPath)
+            : undefined;
+          return messages
+            ? createStaticConversationSource(messages)
+            : record.session
+              ? createStaticConversationSource(record.session.messages)
+              : undefined;
+        })();
     if (!session) {
-      ctx.ui.notify(`Agent is ${record.status === "queued" ? "queued" : "expired"} — no history available.`, "info");
+      ctx.ui.notify("No agent history.", "info");
       return;
     }
-    const activity = agentActivity.get(record.id);
-    const isLive = record.session !== undefined;
 
+    const activity = agentActivity.get(record.id);
+    const isLive = mode === "live";
     await ctx.ui.custom<undefined>(
       (tui, theme, keybindings, done) => {
         return new ConversationViewer(tui, session, record, activity, theme, done,
@@ -1849,7 +1843,8 @@ Terse command-style prompts produce shallow, generic work.
             }
           } : undefined,
           keybindings,
-          isLive ? (message: string) => manager.steer(record.id, message) : undefined);
+          isLive ? (message: string) => manager.steer(record.id, message) : undefined,
+          mode === "history" ? { pi, ctx, readOnly: true } : { pi, ctx });
       },
       {
         overlay: true,

package/src/output-file.ts

@@ -65,8 +65,8 @@ export function streamToOutputFile(
   cwd: string,
   historyPath?: string,
 ): () => void {
-  const outputPaths = historyPath && historyPath !== path ? [path, historyPath] : [path];
   let writtenCount = 1; // initial user prompt already written
+  const outputPaths = historyPath && historyPath !== path ? [path, historyPath] : [path];
 
   const flush = () => {
     const messages = session.messages;

package/src/types.ts

@@ -158,7 +158,6 @@ export interface NotificationDetails {
   outputFile?: string;
   error?: string;
   resultPreview: string;
-  resultText?: string;
   /** Additional agents in a group notification. */
   others?: NotificationDetails[];
 }

package/src/ui/agent-widget.ts

@@ -6,7 +6,6 @@
  */
 
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { hasAgentHistory } from "../agent-history.js";
 import type { AgentManager } from "../agent-manager.js";
 import { getConfig } from "../agent-types.js";
 import type { AgentInvocation, SubagentType, WidgetMode } from "../types.js";
@@ -238,8 +237,6 @@ export class AgentWidget {
      * extension supplies one defaulting to `"background"`.
      */
     private mode: () => WidgetMode = () => "all",
-    /** Current project cwd used to validate reload-restored transcripts. */
-    private getCwd: () => string | undefined = () => undefined,
   ) {}
 
   /**
@@ -254,11 +251,7 @@ export class AgentWidget {
    *   - `all`: every agent.
    */
   private widgetAgents() {
-    const all = this.manager.listAgents().filter((record) => {
-      if (record.status === "running" || record.status === "queued") return true;
-      const cwd = this.getCwd();
-      return cwd !== undefined && hasAgentHistory(cwd, record.transcriptPath);
-    });
+    const all = this.manager.listAgents();
     switch (this.mode()) {
       case "off": return [];
       case "background": return all.filter(a => a.isBackground !== false);

package/src/ui/conversation-blocks.ts

@@ -0,0 +1,270 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+
+export type ConversationBlockKind = "text" | "tool" | "meta";
+export type ConversationBlockRole = "user" | "assistant" | "tool" | "custom" | "meta";
+
+export interface ConversationBlock {
+  id: string;
+  kind: ConversationBlockKind;
+  role: ConversationBlockRole;
+  header: string;
+  markdown: string;
+  copyText: string;
+  fullText: string;
+  toolLine?: string;
+}
+
+export interface ConversationFormatOptions {
+  maxEntryChars?: number;
+  maxToolResultChars?: number;
+}
+
+const DEFAULT_MAX_CHARS = 16_000;
+const TRUNCATION_NOTICE = "\n… [truncated in subagent viewer]";
+
+type UnknownMessage = {
+  role?: unknown;
+  content?: unknown;
+  summary?: unknown;
+  command?: unknown;
+  output?: unknown;
+  toolName?: unknown;
+  isError?: unknown;
+  customType?: unknown;
+  display?: unknown;
+};
+
+function charLimit(value: number | undefined, fallback: number): number {
+  if (value === undefined || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+
+/** Normalize terminal/platform line endings, then keep the result bounded. */
+function bound(value: string, limit: number): string {
+  const text = value.replace(/\r\n?/g, "\n");
+  if (text.length <= limit) return text;
+  if (limit <= 0) return "";
+  if (limit <= TRUNCATION_NOTICE.length) return TRUNCATION_NOTICE.slice(0, limit);
+  return text.slice(0, limit - TRUNCATION_NOTICE.length) + TRUNCATION_NOTICE;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+/** Extract displayable text without leaking provider-specific or unknown parts. */
+function contentText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+
+  const parts: string[] = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const item = part as Record<string, unknown>;
+    if (item.type === "text" && typeof item.text === "string") {
+      parts.push(item.text);
+    } else if (item.type === "image") {
+      parts.push("[image]");
+    }
+  }
+  return parts.join("\n");
+}
+
+function firstNonEmptyLine(text: string): string {
+  const line = text.split("\n").find((candidate) => candidate.trim().length > 0);
+  if (!line) return "(no output)";
+  return line.trim().replace(/\s+/g, " ");
+}
+
+function toolSummary(name: string, call: Record<string, unknown>): string {
+  const args = call.arguments && typeof call.arguments === "object"
+    ? call.arguments as Record<string, unknown>
+    : call.input && typeof call.input === "object"
+      ? call.input as Record<string, unknown>
+      : {};
+
+  const path = asString(args.path) ?? asString(args.filePath) ?? asString(args.filename);
+  if (["read", "edit", "write"].includes(name) && path) return path;
+  if (asString(args.command)) return asString(args.command)!;
+  if (path) return path;
+  try {
+    const encoded = JSON.stringify(args);
+    return encoded === "{}" ? "" : encoded;
+  } catch {
+    return "";
+  }
+}
+
+function blockId(messageIndex: number, emitted: number, toolIndex?: number): string {
+  if (emitted === 0) return `message-${messageIndex}`;
+  return `message-${messageIndex}-tool-${toolIndex ?? emitted}`;
+}
+
+function textBlock(
+  id: string,
+  role: "user" | "assistant",
+  markdown: string,
+): ConversationBlock {
+  return {
+    id,
+    kind: "text",
+    role,
+    header: role === "user" ? "User" : "Assistant",
+    markdown,
+    copyText: markdown,
+    fullText: markdown,
+  };
+}
+
+function toolCallBlock(
+  id: string,
+  name: string,
+  summary: string,
+): ConversationBlock {
+  const toolLine = `· ${name} → ${summary || "(no details)"}`;
+  return {
+    id,
+    kind: "tool",
+    role: "assistant",
+    header: "Assistant tool call",
+    markdown: "",
+    copyText: toolLine,
+    fullText: toolLine,
+    toolLine,
+  };
+}
+
+function toolResultBlock(
+  id: string,
+  message: UnknownMessage,
+  maxChars: number,
+): ConversationBlock | undefined {
+  const name = asString(message.toolName) ?? "tool";
+  const output = contentText(message.content);
+  const normalized = output.replace(/\r\n?/g, "\n");
+  if (!normalized.trim() && maxChars === 0) return undefined;
+  const success = message.isError === true ? "✗" : "✓";
+  const lineCount = normalized.length === 0 ? 0 : normalized.split("\n").length;
+  const charCount = normalized.length;
+  const summary = firstNonEmptyLine(normalized);
+  const toolLine = `· ${name} ${success} ${summary} ${lineCount}L/${charCount}c`;
+  const fullText = bound(`${name} ${success}\n${normalized}`, maxChars);
+  return {
+    id,
+    kind: "tool",
+    role: "tool",
+    header: `${name} result`,
+    markdown: "",
+    copyText: fullText,
+    fullText,
+    toolLine,
+  };
+}
+
+function bashBlock(
+  id: string,
+  message: UnknownMessage,
+  maxChars: number,
+): ConversationBlock | undefined {
+  const command = asString(message.command) ?? "";
+  const output = asString(message.output) ?? contentText(message.content);
+  const body = command ? `$ ${command}${output ? `\n${output}` : ""}` : output;
+  if (!body.trim() && maxChars === 0) return undefined;
+  const toolLine = `· bash → ${command || "(no command)"}`;
+  const fullText = bound(body, maxChars);
+  return {
+    id,
+    kind: "tool",
+    role: "tool",
+    header: "bash",
+    markdown: "",
+    copyText: fullText,
+    fullText,
+    toolLine,
+  };
+}
+
+function metaBlock(
+  id: string,
+  header: string,
+  value: unknown,
+  maxChars: number,
+): ConversationBlock | undefined {
+  const text = typeof value === "string" ? value : contentText(value);
+  const markdown = bound(text, maxChars);
+  if (!markdown.trim()) return undefined;
+  return {
+    id,
+    kind: "meta",
+    role: "meta",
+    header,
+    markdown,
+    copyText: markdown,
+    fullText: markdown,
+  };
+}
+
+export function formatConversationMessages(
+  messages: AgentSession["messages"],
+  options?: ConversationFormatOptions,
+): ConversationBlock[] {
+  const maxEntryChars = charLimit(options?.maxEntryChars, DEFAULT_MAX_CHARS);
+  const maxToolResultChars = charLimit(options?.maxToolResultChars, DEFAULT_MAX_CHARS);
+  const blocks: ConversationBlock[] = [];
+
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = messages[messageIndex] as unknown as UnknownMessage;
+    const role = message?.role;
+    let emitted = 0;
+
+    if (role === "user") {
+      const text = bound(contentText(message.content), maxEntryChars);
+      if (text.trim()) blocks.push(textBlock(blockId(messageIndex, emitted++), "user", text));
+      continue;
+    }
+
+    if (role === "assistant") {
+      const parts = Array.isArray(message.content) ? message.content : [];
+      const text = bound(contentText(parts), maxEntryChars);
+      if (text.trim()) blocks.push(textBlock(blockId(messageIndex, emitted++), "assistant", text));
+
+      let toolIndex = 0;
+      for (const part of parts) {
+        if (!part || typeof part !== "object" || (part as any).type !== "toolCall") continue;
+        const call = part as Record<string, unknown>;
+        const name = asString(call.name) ?? asString(call.toolName) ?? "unknown";
+        blocks.push(toolCallBlock(blockId(messageIndex, emitted++, toolIndex), name, toolSummary(name, call)));
+        toolIndex++;
+      }
+      continue;
+    }
+
+    if (role === "toolResult") {
+      const block = toolResultBlock(blockId(messageIndex, emitted), message, maxToolResultChars);
+      if (block) blocks.push(block);
+      continue;
+    }
+
+    if (role === "bashExecution") {
+      const block = bashBlock(blockId(messageIndex, emitted), message, maxToolResultChars);
+      if (block) blocks.push(block);
+      continue;
+    }
+
+    if (role === "custom") {
+      if (message.display === false) continue;
+      const header = asString(message.customType) || "Custom";
+      const block = metaBlock(blockId(messageIndex, emitted), header, message.content, maxEntryChars);
+      if (block) blocks.push({ ...block, role: "custom" });
+      continue;
+    }
+
+    if (role === "compactionSummary" || role === "branchSummary" || role === "summary") {
+      const header = role === "summary" ? "Summary" : role === "compactionSummary" ? "Compaction summary" : "Branch summary";
+      const block = metaBlock(blockId(messageIndex, emitted), header, message.summary, maxEntryChars);
+      if (block) blocks.push(block);
+    }
+  }
+
+  return blocks;
+}