@esso0428/pi-subagents 0.15.6 → 0.15.7

package/src/ui/conversation-viewer.ts

@@ -6,13 +6,15 @@
  */
 
 import type { ExtensionAPI, ExtensionContext, AgentSession } from "@earendil-works/pi-coding-agent";
-import { copyToClipboard, getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { type Component, Input, Key, Markdown, matchesKey, Text, type TUI, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { copyToClipboard } from "@earendil-works/pi-coding-agent";
+import { type Component, Input, Key, matchesKey, type TUI, type TuiMouseEvent, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { AgentRecord } from "../types.js";
 import { getLifetimeTotal, getSessionContextPercent } from "../usage.js";
 import type { Theme } from "./agent-widget.js";
 import { type AgentActivity, buildInvocationTags, describeActivity, fgPreservingNestedStyles, formatDuration, formatSessionTokens, getDisplayName, getPromptModeLabel } from "./agent-widget.js";
 import { formatConversationMessages, type ConversationBlock } from "./conversation-blocks.js";
+import { ConversationTimeline, type TimelineRenderLine } from "./conversation-timeline.js";
+import { renderConversationRoleHeader } from "./conversation-role.js";
 import { editLiveAssistantBlockInNvim, viewConversationBlockInNvim } from "./conversation-nvim.js";
 import { findConversationMatches, highlightConversationLine, nearestConversationMatchAfter, nearestConversationMatchBefore, stripAnsi, type ConversationMatch } from "./conversation-search.js";
 import { createViewerKeys, type ViewerKeybindings, type ViewerKeys } from "./viewer-keys.js";
@@ -35,12 +37,7 @@ export function createStaticConversationSource(
   return { messages, subscribe: () => () => {} };
 }
 
-type RenderLine = {
-  text: string;
-  plain: string;
-  blockIndex: number;
-  railable?: boolean;
-};
+type RenderLine = TimelineRenderLine;
 
 /** Optional operations are appended so all existing constructor call sites stay valid. */
 export interface ConversationViewerOperations {
@@ -71,6 +68,7 @@ export class ConversationViewer implements Component {
   private searchQuery = "";
   private searchMatches: ConversationMatch[] = [];
   private currentMatchIdx = -1;
+  private timeline: ConversationTimeline;
 
   constructor(
     private tui: TUI,
@@ -90,9 +88,20 @@ export class ConversationViewer implements Component {
   ) {
     this.keys = createViewerKeys(keybindings);
     this.blocks = formatConversationMessages(session.messages);
+    this.timeline = new ConversationTimeline(tui, theme, {
+      cwd: operations?.ctx.cwd,
+      record,
+      onChange: () => {
+        this.cacheVersion++;
+        this.invalidate();
+        this.tui.requestRender();
+      },
+    });
+    this.timeline.setBlocks(this.blocks);
     this.unsubscribe = session.subscribe(() => {
       if (this.closed) return;
       this.blocks = formatConversationMessages(this.session.messages);
+      this.timeline.setBlocks(this.blocks);
       this.cacheVersion++;
       this.invalidate();
       this.tui.requestRender();
@@ -114,10 +123,17 @@ export class ConversationViewer implements Component {
       this.done(undefined);
       return;
     }
-    if (matchesKey(data, "enter") && this.canSteer()) {
-      this.stopArmed = false;
-      this.openComposer();
-      return;
+    if (matchesKey(data, "enter")) {
+      this.buildContentLines(this.lastInnerW || 80);
+      if (this.timeline.isToolFocused()) {
+        this.timeline.toggleFocusedTool();
+        return;
+      }
+      if (this.canSteer()) {
+        this.stopArmed = false;
+        this.openComposer();
+        return;
+      }
     }
     if (matchesKey(data, "x")) {
       if (this.isStoppable()) {
@@ -140,6 +156,15 @@ export class ConversationViewer implements Component {
 
     if (data === "t") {
       this.showTools = !this.showTools;
+      this.timeline.setShowTools(this.showTools);
+      this.invalidate();
+      this.tui.requestRender();
+    } else if (data === "\t") {
+      this.timeline.moveFocus(1);
+      this.invalidate();
+      this.tui.requestRender();
+    } else if (matchesKey(data, Key.shift("tab"))) {
+      this.timeline.moveFocus(-1);
       this.invalidate();
       this.tui.requestRender();
     } else if (data === "J" || matchesKey(data, Key.shift("j"))) {
@@ -183,6 +208,25 @@ export class ConversationViewer implements Component {
     void maxScroll;
   }
 
+  handleMouse(event: TuiMouseEvent): { handled?: boolean; render?: boolean } | undefined {
+    if (this.composer || this.searchMode) return undefined;
+    const innerW = Math.max(1, this.lastInnerW || event.width - 4);
+    const contentLines = this.buildContentLines(innerW);
+    const viewportHeight = this.viewportHeight();
+    const maxScroll = Math.max(0, contentLines.length - viewportHeight);
+    const visibleStart = Math.min(this.scrollOffset, maxScroll);
+    const contentOrigin = 3 + (this.invocationLine() ? 1 : 0);
+    const contentY = event.y - contentOrigin + visibleStart;
+    if (contentY < 0 || contentY >= contentLines.length) return undefined;
+    const result = this.timeline.handleMouse({ ...event, y: contentY });
+    if (result?.handled) {
+      this.cacheVersion++;
+      this.invalidate();
+      this.tui.requestRender();
+    }
+    return result;
+  }
+
   render(width: number): string[] {
     if (width < 6) return [];
     const th = this.theme;
@@ -226,7 +270,10 @@ export class ConversationViewer implements Component {
     const displayed = visible.slice();
     if (showSticky) {
       const block = this.cachedMessageBlocks[this.currentMessageIndex()];
-      if (block) displayed[0] = { text: ` ${block.header}`, plain: block.header, blockIndex: currentBlockIdx, railable: true };
+      if (block) {
+        const header = renderConversationRoleHeader(block, this.theme);
+        displayed[0] = { text: ` ${header}`, plain: header, blockIndex: currentBlockIdx, railable: true };
+      }
     }
     for (let i = 0; i < displayed.length; i++) {
       const line = displayed[i];
@@ -248,6 +295,13 @@ export class ConversationViewer implements Component {
       const hint = th.fg("dim", "Enter send · Esc cancel");
       const label = th.fg("accent", "✎ steer");
       lines.push(row(label + " ".repeat(Math.max(1, innerW - visibleWidth(label) - visibleWidth(hint))) + hint));
+    } else if (this.searchMode) {
+      const query = `/${this.searchQuery}`;
+      const matchCount = this.searchMatches.length > 0
+        ? ` · ${this.searchMatches.length} match${this.searchMatches.length === 1 ? "" : "es"}`
+        : "";
+      const hints = th.fg("dim", " · Enter apply · Esc cancel");
+      lines.push(row(truncateToWidth(th.fg("accent", query) + th.fg("dim", matchCount) + hints, innerW, "...", true)));
     } else {
       const actions: string[] = [];
       if (this.canSteer()) actions.push(th.fg("dim", "Enter steer"));
@@ -306,52 +360,35 @@ export class ConversationViewer implements Component {
   }
 
   private invocationLine(): string | undefined {
-    const { modelName, tags } = buildInvocationTags(this.record.invocation);
-    const parts = modelName ? [modelName, ...tags] : tags;
-    return parts.length === 0 ? undefined : this.theme.fg("dim", `  ↳ ${parts.join(" · ")}`);
+    const liveModel = this.isLive() ? this.record.session?.model : undefined;
+    const invocation = this.record.invocation
+      ? {
+          ...this.record.invocation,
+          ...(liveModel && { effectiveModelName: liveModel.name ?? liveModel.id }),
+          ...(this.isLive() && { effectiveThinking: this.record.session?.thinkingLevel }),
+        }
+      : liveModel || (this.isLive() && this.record.session?.thinkingLevel)
+        ? {
+            effectiveModelName: liveModel?.name ?? liveModel?.id,
+            effectiveThinking: this.record.session?.thinkingLevel,
+          }
+        : undefined;
+    if (!invocation) return this.theme.fg("dim", "  ↳ model: unknown · thinking: unknown");
+    const { modelName, tags } = buildInvocationTags(invocation);
+    const effectiveModelName = invocation.effectiveModelName ?? modelName;
+    const parts = effectiveModelName ? [`model: ${effectiveModelName}`, ...tags] : ["model: inherit", ...tags];
+    return this.theme.fg("dim", `  ↳ ${parts.join(" · ")}`);
   }
 
   private buildContentLines(width: number): RenderLine[] {
     if (width <= 0) return [];
     if (this.cachedVersion === this.cacheVersion && this.cachedWidth === width) return this.cachedLines;
-    const visibleBlocks = this.blocks.filter((block) => this.showTools || block.kind !== "tool");
-    const lines: RenderLine[] = [];
-    this.cachedMessageStarts = [];
-    this.cachedMessageBlocks = [];
-    if (visibleBlocks.length === 0) {
-      const empty = this.blocks.length === 0 ? "(waiting for first message...)" : "(tools hidden)";
-      lines.push({ text: this.theme.fg("dim", empty), plain: empty, blockIndex: -1 });
-    }
-    for (const block of visibleBlocks) {
-      const blockIndex = this.blocks.indexOf(block);
-      if (block.kind === "tool") {
-        const raw = (block.toolLine ?? block.copyText).replace(/^·\s*/, "");
-        const line = this.theme.fg("dim", `   └─ ${raw}`);
-        lines.push({ text: truncateToWidth(line, width), plain: stripAnsi(line), blockIndex });
-        continue;
-      }
-      if (lines.length > 0) {
-        const separator = this.theme.fg("border", `   ${"─ ".repeat(Math.max(1, Math.floor((width - 6) / 2)))}`.trimEnd());
-        lines.push({ text: truncateToWidth(separator, width), plain: stripAnsi(separator), blockIndex });
-      }
-      this.cachedMessageStarts.push(lines.length);
-      this.cachedMessageBlocks.push(block);
-      const header = ` ${block.header}`;
-      lines.push({ text: truncateToWidth(header, width), plain: block.header, blockIndex, railable: true });
-      try {
-        const markdown = new Markdown(block.markdown || "∅", 2, 0, getMarkdownTheme(), {
-          color: (text) => this.theme.fg(block.role === "meta" ? "muted" : "text", text),
-        });
-        for (const text of markdown.render(Math.max(1, width))) lines.push({ text: truncateToWidth(text, width), plain: stripAnsi(text), blockIndex, railable: true });
-      } catch {
-        try {
-          for (const text of new Text(block.markdown || "∅").render(Math.max(1, width))) lines.push({ text: truncateToWidth(text, width), plain: stripAnsi(text), blockIndex, railable: true });
-        } catch {
-          const text = block.markdown || "∅";
-          for (const line of text.split("\n")) lines.push({ text: truncateToWidth(line, width), plain: line, blockIndex, railable: true });
-        }
-      }
-    }
+    this.timeline.setShowTools(this.showTools);
+    this.timeline.render(width);
+    const timelineSnapshot = this.timeline.getSnapshot();
+    const lines: RenderLine[] = timelineSnapshot.lines.map((line) => ({ ...line }));
+    this.cachedMessageStarts = [...timelineSnapshot.messageStarts];
+    this.cachedMessageBlocks = [...timelineSnapshot.messageBlocks];
     if (this.record.status === "running" && this.activity) {
       const act = describeActivity(this.activity.activeTools, this.activity.responseText);
       const text = `▍ ${act}`;

package/src/write-execution.ts

@@ -0,0 +1,180 @@
+import { createWriteToolDefinition, generateDiffString, generateUnifiedPatch, type ExtensionContext, type ToolDefinition, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+
+/** Maximum UTF-8 size of the durable display diff plus unified patch. */
+export const MAX_DURABLE_DIFF_BYTES = 4 * 1024 * 1024;
+/** Avoid retaining arbitrarily large previous files in the live-only store. */
+export const MAX_COMPARABLE_WRITE_BYTES = 512_000;
+export const MAX_WRITE_METADATA_ENTRIES = 100;
+
+export interface DurableWriteDetails {
+  diff?: string;
+  patch?: string;
+  firstChangedLine?: number;
+  diffUnavailableReason?: string;
+}
+
+/** Ephemeral execution metadata used by the live renderer. Never persisted as a before/after pair. */
+export interface WriteExecutionMeta extends DurableWriteDetails {
+  fileExistedBeforeWrite: boolean;
+  previousContent?: string;
+}
+
+export class WriteExecutionMetadataStore {
+  readonly entries = new Map<string, WriteExecutionMeta>();
+
+  set(toolCallId: string, metadata: WriteExecutionMeta): void {
+    this.entries.delete(toolCallId);
+    this.entries.set(toolCallId, metadata);
+    while (this.entries.size > MAX_WRITE_METADATA_ENTRIES) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === undefined) break;
+      this.entries.delete(oldest);
+    }
+  }
+
+  get(toolCallId: unknown): WriteExecutionMeta | undefined {
+    return typeof toolCallId === "string" ? this.entries.get(toolCallId) : undefined;
+  }
+
+  delete(toolCallId: string): void {
+    this.entries.delete(toolCallId);
+  }
+
+  clear(): void {
+    this.entries.clear();
+  }
+}
+
+type WriteParams = { path: string; content: string };
+
+function resolveWritePath(path: string, cwd: string): string {
+  if (path === "~") return process.env.HOME ?? cwd;
+  if (path.startsWith("~/") || path.startsWith("~\\")) {
+    return resolve(process.env.HOME ?? cwd, path.slice(2));
+  }
+  return isAbsolute(path) ? path : resolve(cwd, path);
+}
+
+async function capturePreviousContent(absolutePath: string): Promise<WriteExecutionMeta> {
+  let info;
+  try {
+    info = await lstat(absolutePath);
+  } catch (error: any) {
+    if (error?.code === "ENOENT") return { fileExistedBeforeWrite: false, previousContent: "" };
+    return {
+      fileExistedBeforeWrite: true,
+      diffUnavailableReason: "unable to inspect the previous file",
+    };
+  }
+
+  if (!info.isFile()) {
+    return {
+      fileExistedBeforeWrite: true,
+      diffUnavailableReason: "previous path is not a regular file",
+    };
+  }
+  if (info.size > MAX_COMPARABLE_WRITE_BYTES) {
+    return {
+      fileExistedBeforeWrite: true,
+      diffUnavailableReason: `previous file exceeds ${MAX_COMPARABLE_WRITE_BYTES} bytes`,
+    };
+  }
+
+  try {
+    const bytes = await readFile(absolutePath);
+    if (bytes.byteLength > MAX_COMPARABLE_WRITE_BYTES) {
+      return {
+        fileExistedBeforeWrite: true,
+        diffUnavailableReason: `previous file exceeds ${MAX_COMPARABLE_WRITE_BYTES} bytes`,
+      };
+    }
+    const previousContent = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return { fileExistedBeforeWrite: true, previousContent };
+  } catch {
+    return {
+      fileExistedBeforeWrite: true,
+      diffUnavailableReason: "previous file is not comparable UTF-8 text",
+    };
+  }
+}
+
+function durableDetails(
+  metadata: WriteExecutionMeta,
+  path: string,
+  content: string,
+): DurableWriteDetails {
+  if (metadata.diffUnavailableReason) {
+    return { diffUnavailableReason: metadata.diffUnavailableReason };
+  }
+  const previousContent = metadata.previousContent ?? "";
+  const diffResult = generateDiffString(previousContent, content);
+  const patch = generateUnifiedPatch(path, previousContent, content);
+  const totalBytes = Buffer.byteLength(diffResult.diff, "utf8") + Buffer.byteLength(patch, "utf8");
+  if (totalBytes > MAX_DURABLE_DIFF_BYTES) {
+    return { diffUnavailableReason: `durable diff exceeds ${MAX_DURABLE_DIFF_BYTES} bytes` };
+  }
+  return {
+    diff: diffResult.diff,
+    patch,
+    firstChangedLine: diffResult.firstChangedLine,
+  };
+}
+
+export async function executeWriteWithMetadata(
+  store: WriteExecutionMetadataStore,
+  toolCallId: string,
+  params: WriteParams,
+  signal: AbortSignal | undefined,
+  cwd: string,
+): Promise<{ content: Array<{ type: "text"; text: string }>; details?: DurableWriteDetails }> {
+  const absolutePath = resolveWritePath(params.path, cwd);
+  store.delete(toolCallId);
+
+  return withFileMutationQueue(absolutePath, async () => {
+    const throwIfAborted = () => {
+      if (signal?.aborted) throw new Error("Operation aborted");
+    };
+    throwIfAborted();
+    const metadata = await capturePreviousContent(absolutePath);
+    throwIfAborted();
+    await mkdir(dirname(absolutePath), { recursive: true });
+    throwIfAborted();
+    await writeFile(absolutePath, params.content, "utf8");
+    throwIfAborted();
+
+    const details = durableDetails(metadata, params.path, params.content);
+    store.set(toolCallId, { ...metadata, ...details });
+    return {
+      content: [{ type: "text" as const, text: `Successfully wrote to ${params.path}` }],
+      details,
+    };
+  }).catch((error) => {
+    store.delete(toolCallId);
+    throw error;
+  });
+}
+
+/**
+ * A session-local write definition. It retains Pi's public schema/description
+ * and replaces only execution so the parent registry is never mutated.
+ */
+export function createTrackedWriteTool(
+  cwd: string,
+  store = new WriteExecutionMetadataStore(),
+): ToolDefinition<any, DurableWriteDetails> {
+  const nativeWrite = createWriteToolDefinition(cwd);
+  return {
+    ...nativeWrite,
+    async execute(
+      toolCallId: string,
+      params: WriteParams,
+      signal: AbortSignal | undefined,
+      _onUpdate: unknown,
+      ctx: ExtensionContext,
+    ) {
+      return executeWriteWithMetadata(store, toolCallId, params, signal, ctx.cwd || cwd);
+    },
+  } as ToolDefinition<any, DurableWriteDetails>;
+}

package/test/output-file-history.test.ts

@@ -0,0 +1,50 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { streamToOutputFile, writeInitialEntry } from "../src/output-file.js";
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("streamToOutputFile durable message snapshots", () => {
+  it("writes tool result details to both output and project history files", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "pi-subagents-output-test-"));
+    tempDirs.push(dir);
+    const outputPath = join(dir, "agent.output");
+    const historyPath = join(dir, "history.jsonl");
+    writeInitialEntry(outputPath, "agent-1", "run", dir);
+    writeInitialEntry(historyPath, "agent-1", "run", dir);
+
+    let listener: ((event: any) => void) | undefined;
+    const session = {
+      messages: [
+        { role: "user", content: "run" },
+        {
+          role: "toolResult",
+          toolCallId: "call-1",
+          toolName: "write",
+          content: [{ type: "text", text: "Successfully wrote to file.txt" }],
+          details: { diff: "+1 new", patch: "+new" },
+        },
+      ],
+      subscribe(next: (event: any) => void) {
+        listener = next;
+        return () => { listener = undefined; };
+      },
+    } as any;
+
+    const cleanup = streamToOutputFile(session, outputPath, "agent-1", dir, historyPath);
+    listener?.({ type: "turn_end" });
+    cleanup();
+
+    for (const path of [outputPath, historyPath]) {
+      const entries = (await readFile(path, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
+      expect(entries).toHaveLength(2);
+      expect(entries[1].message.details).toEqual({ diff: "+1 new", patch: "+new" });
+    }
+  });
+});

package/test/ui/conversation-blocks.test.ts

@@ -31,6 +31,37 @@ describe("formatConversationMessages", () => {
     expect(result?.fullText.length).toBeLessThanOrEqual(40);
   });
 
+  it("pairs tool results by id, then same-name source order, and preserves orphans", () => {
+    const blocks = formatConversationMessages([
+      { role: "assistant", content: [
+        { type: "toolCall", id: "call-read", name: "read", arguments: { path: "a.ts" } },
+        { type: "toolCall", id: "call-write", name: "write", arguments: { path: "b.ts", content: "new" } },
+      ] },
+      { role: "toolResult", toolCallId: "call-read", toolName: "read", isError: false, details: { source: "id" }, content: [{ type: "text", text: "read output" }] },
+      { role: "toolResult", toolName: "write", isError: true, details: { source: "name" }, content: [{ type: "text", text: "write failed" }] },
+      { role: "toolResult", toolCallId: "missing", toolName: "bash", isError: true, content: [{ type: "text", text: "orphan" }] },
+    ] as any);
+
+    const tools = blocks.filter((block) => block.kind === "tool");
+    expect(tools).toHaveLength(3);
+    expect(tools[0]?.toolCallId).toBe("call-read");
+    expect(tools[0]?.toolResult?.details).toEqual({ source: "id" });
+    expect(tools[1]?.toolCallId).toBe("call-write");
+    expect(tools[1]?.toolResult?.isError).toBe(true);
+    expect(tools[2]?.toolResult?.content).toEqual([{ type: "text", text: "orphan" }]);
+    expect(tools[2]?.fullText).toContain("orphan");
+  });
+
+  it("uses a stable synthetic id when a tool call omits its id", () => {
+    const blocks = formatConversationMessages([
+      { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "a.ts" } }] },
+      { role: "toolResult", toolName: "read", content: [{ type: "text", text: "ok" }] },
+    ] as any);
+
+    expect(blocks[0]?.toolCallId).toBe("message-0-tool-0");
+    expect(blocks[0]?.toolResult?.content).toEqual([{ type: "text", text: "ok" }]);
+  });
+
   it("normalizes CRLF and bounds text with a deterministic truncation marker", () => {
     const blocks = formatConversationMessages([
       { role: "user", content: "one\r\ntwo\rthree\nfour" },

package/test/ui/conversation-diff.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+  renderEditDiffResult,
+  renderWriteDiffResult,
+} from "../../src/ui/ccstyle/diff/diff-renderer.js";
+import { renderRichToolResult } from "../../src/ui/ccstyle/tool-result.js";
+import { DEFAULT_TOOL_DISPLAY_CONFIG } from "../../src/ui/ccstyle/diff/types.js";
+
+const theme = {
+  fg(color: string, text: string) {
+    return `<${color}>${text}</${color}>`;
+  },
+  bg(color: string, text: string) {
+    return `<bg:${color}>${text}</bg:${color}>`;
+  },
+  bold(text: string) {
+    return `<bold>${text}</bold>`;
+  },
+  getBgAnsi() {
+    return "";
+  },
+  getFgAnsi() {
+    return "";
+  },
+};
+
+const config = {
+  ...DEFAULT_TOOL_DISPLAY_CONFIG,
+  diffViewMode: "unified" as const,
+};
+
+describe("viewer-local ccstyle diff renderer", () => {
+  it("renders persisted write diff after the underlying file changes", () => {
+    const persisted = {
+      diff: "-1 old\n+1 new",
+      patch: "--- file.txt\n+++ file.txt\n@@ -1,1 +1,1 @@\n-old\n+new\n",
+    };
+
+    const first = renderWriteDiffResult(undefined, {
+      expanded: true,
+      filePath: "file.txt",
+      persistedDiff: persisted,
+    }, config, theme, "");
+    const second = renderWriteDiffResult(undefined, {
+      expanded: true,
+      filePath: "file.txt",
+      persistedDiff: persisted,
+    }, config, theme, "");
+
+    expect(second.render(100).join("\n")).toContain("new");
+    expect(second.render(100).join("\n")).toBe(first.render(100).join("\n"));
+  });
+
+  it("prefers persisted write diff over the current content fallback", () => {
+    const component = renderWriteDiffResult("later\n", {
+      expanded: true,
+      filePath: "file.txt",
+      previousContent: "old\n",
+      fileExistedBeforeWrite: true,
+      persistedDiff: { diff: "-1 old\n+1 new", patch: "--- file.txt\n+++ file.txt\n@@ -1,1 +1,1 @@\n-old\n+new\n" },
+    }, config, theme, "");
+
+    const rendered = component.render(100).join("\n");
+    expect(rendered).toContain("new");
+    expect(rendered).not.toContain("later");
+  });
+
+  it("returns an explicit unavailable row instead of an empty success card", () => {
+    const component = renderRichToolResult("write", {
+      content: [{ type: "text", text: "Successfully wrote" }],
+      details: { diffUnavailableReason: "durable diff exceeds limit" },
+    }, { expanded: true }, theme, { args: { path: "large.txt" } });
+
+    expect(component?.render(100).join("\n")).toContain("diff unavailable");
+  });
+
+  it("keeps edit diff and all output rows within the requested width", () => {
+    const component = renderEditDiffResult(
+      { diff: "-1 a very long removed line\n+1 a very long added line" },
+      { expanded: true, filePath: "file.ts" },
+      config,
+      theme,
+      "",
+    );
+
+    for (const width of [20, 40, 100]) {
+      expect(component.render(width).every((line) => visibleWidth(line) <= width)).toBe(true);
+    }
+  });
+});

package/test/ui/conversation-viewer.test.ts

@@ -103,6 +103,56 @@ describe("ConversationViewer", () => {
     expect(historyFooter).not.toContain("M o O");
   });
 
+  it("shows semantic role headers, effective invocation metadata, and the search row", () => {
+    const semanticTheme = {
+      fg: (name: string, text: string) => `<${name}>${text}</${name}>`,
+      bold: (text: string) => `<bold>${text}</bold>`,
+    };
+    const viewer = new ConversationViewer(
+      tui(),
+      createStaticConversationSource([
+        { role: "user", content: "find model" },
+        { role: "assistant", content: [{ type: "text", text: "model found" }] },
+      ] as any),
+      record({ invocation: { effectiveModelName: "claude-sonnet", effectiveThinking: "high" } }),
+      undefined,
+      semanticTheme,
+      vi.fn(),
+    );
+
+    const initial = viewer.render(120).join("\n");
+    expect(initial).toContain("<userMessageText>USER</userMessageText>");
+    expect(initial).toContain("<accent>ASSISTANT</accent>");
+    expect(initial).toContain("model: claude-sonnet");
+    expect(initial).toContain("thinking: high");
+
+    viewer.handleInput("/");
+    const searchRow = viewer.render(120).join("\n");
+    expect(searchRow).toContain("<accent>/</accent>");
+    expect(searchRow).toContain("Enter apply · Esc cancel");
+    for (const character of "model") viewer.handleInput(character);
+    expect(viewer.render(120).join("\n")).toContain("model");
+  });
+
+  it("focuses and expands a bounded fallback tool card", () => {
+    const viewer = new ConversationViewer(
+      tui(),
+      createStaticConversationSource([
+        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "x" } }] },
+        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "one\ntwo\nthree\nfour\nfive\nsix" }] },
+      ] as any),
+      record(),
+      undefined,
+      theme,
+      vi.fn(),
+    );
+
+    expect(viewer.render(120).join("\n")).not.toContain("six");
+    viewer.handleInput("\t");
+    viewer.handleInput("\r");
+    expect(viewer.render(120).join("\n")).toContain("six");
+  });
+
   it("keeps historical viewers read-only and closes on Escape", () => {
     const ui = tui();
     const steer = vi.fn();