@esso0428/pi-subagents 0.15.14 → 0.15.16

package/test/ui/agent-widget.test.ts

@@ -0,0 +1,161 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AgentManager } from "../../src/agent-manager.js";
+import {
+  AgentWidget,
+  getWidgetLineBudget,
+  MAX_WIDGET_LINES,
+  type AgentActivity,
+  type Theme,
+} from "../../src/ui/agent-widget.js";
+import type { AgentRecord } from "../../src/types.js";
+
+const theme: Theme = {
+  fg: (_color, text) => text,
+  bold: (text) => text,
+};
+
+const managers: AgentManager[] = [];
+
+afterEach(() => {
+  for (const manager of managers.splice(0)) manager.dispose();
+});
+
+function makeRecord(overrides: Partial<AgentRecord> = {}): AgentRecord {
+  return {
+    id: "agent-1",
+    type: "Explore",
+    description: "Inspect the repository",
+    status: "completed",
+    toolUses: 0,
+    startedAt: 1_000,
+    completedAt: 2_000,
+    lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
+    compactionCount: 0,
+    ...overrides,
+  };
+}
+
+function renderWidget(
+  records: AgentRecord[],
+  rows = 24,
+  activity = new Map<string, AgentActivity>(),
+  mode: "all" | "background" | "off" = "all",
+) {
+  const manager = { listAgents: () => records } as unknown as AgentManager;
+  const widget = new AgentWidget(manager, activity, () => mode);
+  const tui = { terminal: { columns: 200, rows } };
+  const render = () => (widget as any).renderWidget(tui, theme) as string[];
+  return { render, widget };
+}
+
+function createWidgetHarness(records: AgentRecord[]) {
+  const manager = { listAgents: () => records } as unknown as AgentManager;
+  let factory: ((tui: any, theme: Theme) => { render(): string[]; invalidate(): void }) | undefined;
+  const tui = {
+    terminal: { columns: 120, rows: 24 },
+    requestRender: vi.fn(),
+  };
+  const ui = {
+    setStatus: vi.fn(),
+    setWidget: vi.fn((_key: string, content: any) => { factory = content; }),
+  };
+  const widget = new AgentWidget(manager, new Map(), () => "all");
+  widget.setUICtx(ui);
+  widget.update();
+  factory?.(tui, theme).render();
+  tui.requestRender.mockClear();
+  return { records, tui, ui, widget, render: () => factory?.(tui, theme).render() ?? [] };
+}
+
+describe("AgentWidget live records", () => {
+  it("keeps restored history in the live widget and manager history", () => {
+    const manager = new AgentManager();
+    managers.push(manager);
+    manager.restoreCompleted([makeRecord({ id: "history", description: "restored history" })]);
+
+    const widget = new AgentWidget(manager, new Map(), () => "all");
+    const tui = { terminal: { columns: 120, rows: 24 } };
+
+    expect((widget as any).renderWidget(tui, theme).join("\n")).toContain("restored history");
+    expect(manager.listAgents().map(record => record.id)).toEqual(["history"]);
+    expect(manager.getRecord("history")).toBeDefined();
+  });
+
+  it("keeps a live completed record visible after markFinished", () => {
+    const record = makeRecord({ id: "live", description: "live completion" });
+    const { render, widget } = renderWidget([record]);
+
+    widget.markFinished(record.id);
+
+    expect(render().join("\n")).toContain("live completion");
+  });
+
+  it("normalizes multiline rows and bounds output by the responsive ceiling", () => {
+    const running = makeRecord({
+      id: "running",
+      status: "running",
+      completedAt: undefined,
+      description: "running\nsecond line",
+    });
+    const finished = makeRecord({
+      id: "finished",
+      description: "finished\nsecond line",
+    });
+    const extraFinished = Array.from({ length: 10 }, (_, i) => makeRecord({
+      id: `finished-${i}`,
+      description: `extra ${i}`,
+    }));
+    const activity = new Map<string, AgentActivity>([
+      [running.id, {
+        activeTools: new Map(),
+        toolUses: 0,
+        responseText: "activity\nsecond line",
+        turnCount: 1,
+        lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
+      }],
+    ]);
+    const rows = 9;
+    const { render } = renderWidget([running, finished, ...extraFinished], rows, activity);
+    const lines = render();
+
+    expect(lines.every(line => !/[\r\n]/.test(line))).toBe(true);
+    expect(lines.length).toBeLessThanOrEqual(getWidgetLineBudget(rows));
+    expect(lines.length).toBeLessThanOrEqual(MAX_WIDGET_LINES);
+    expect(lines.join("\n")).toContain("running second line");
+    expect(lines.some(line => line.includes("more"))).toBe(true);
+  });
+
+  it("counts queued records in the overflow indicator on short terminals", () => {
+    const running = makeRecord({ id: "running", status: "running", completedAt: undefined });
+    const queued = makeRecord({ id: "queued", status: "queued", completedAt: undefined });
+    const { render } = renderWidget([running, queued], 6);
+
+    const output = render().join("\\n");
+    expect(output).toContain("+2 more");
+    expect(output).toContain("1 queued");
+  });
+
+  it("reserves editor space on short terminals while retaining the widget ceiling", () => {
+    expect(getWidgetLineBudget(9)).toBe(5);
+    expect(getWidgetLineBudget(100)).toBe(MAX_WIDGET_LINES);
+  });
+
+  it("does not request a render when a live snapshot is unchanged", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(10_000);
+    try {
+      const running = makeRecord({ id: "running", status: "running", completedAt: undefined });
+      const { widget, tui } = createWidgetHarness([running]);
+
+      widget.update();
+      expect(tui.requestRender).not.toHaveBeenCalled();
+
+      running.description = "changed description";
+      widget.update();
+      expect(tui.requestRender).toHaveBeenCalledTimes(1);
+      widget.dispose();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

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

@@ -4,7 +4,7 @@ import {
   renderEditDiffResult,
   renderWriteDiffResult,
 } from "../../src/ui/ccstyle/diff/diff-renderer.js";
-import { createViewerCcstyleResult, renderRichToolResult } from "../../src/ui/ccstyle/tool-result.js";
+import { renderRichToolResult } from "../../src/ui/ccstyle/tool-result.js";
 import { DEFAULT_TOOL_DISPLAY_CONFIG } from "../../src/ui/ccstyle/diff/types.js";
 
 const theme = {
@@ -66,52 +66,6 @@ describe("viewer-local ccstyle diff renderer", () => {
     expect(rendered).not.toContain("later");
   });
 
-  it("matches the pi-cc Input/Output tree style and hover affordance", () => {
-    const component = createViewerCcstyleResult("read", {
-      content: [{ type: "text", text: "one\ntwo\nthree" }],
-    }, { expanded: true }, theme, {
-      args: { path: "file.txt", offset: 2 },
-      diffConfig: { expandedPreviewMaxLines: 2 },
-    }) as any;
-
-    const initial = component.render(100).join("\n");
-    expect(initial).toContain("<accent><bold>Input</bold></accent>");
-    expect(initial).toContain("<dim>path: </dim><muted>file.txt</muted>");
-    expect(initial).toContain("<accent><bold>Output</bold></accent>");
-    expect(initial).toContain("click to show more");
-    const outputHintLine = component.showMoreLine("output");
-    expect(outputHintLine).toEqual(expect.any(Number));
-    component.setHoveredSection("output");
-    expect(component.render(100).join("\n")).toContain("<text> click to show more</text>");
-  });
-
-  it("reads tool-hint hover state at render time", () => {
-    let hovered = false;
-    const component = createViewerCcstyleResult("read", {
-      content: [{ type: "text", text: "one\ntwo" }],
-    }, { expanded: false, isHovered: () => hovered }, theme, {
-      args: { path: "file.txt" },
-      isHovered: () => hovered,
-    });
-
-    expect(component?.render(100).join("\n")).not.toContain("<text>click to show more</text>");
-    hovered = true;
-    expect(component?.render(100).join("\n")).toContain("<text>click to show more</text>");
-  });
-
-  it("labels persisted overwrites correctly without reading the current file", () => {
-    const component = renderRichToolResult("write", {
-      content: [{ type: "text", text: "Successfully wrote" }],
-      details: {
-        diff: "-1 old\n+1 new",
-        patch: "--- file.txt\n+++ file.txt\n@@ -1,1 +1,1 @@\n-old\n+new\n",
-      },
-    }, { expanded: false }, theme, { args: { path: "file.txt", content: "new\n" } });
-
-    expect(component?.render(100).join("\\n")).toContain("overwritten");
-    expect(component?.render(100).join("\\n")).toContain("click to show more");
-  });
-
   it("returns an explicit unavailable row instead of an empty success card", () => {
     const component = renderRichToolResult("write", {
       content: [{ type: "text", text: "Successfully wrote" }],

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

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
+import type { TuiMouseEvent } from "@earendil-works/pi-tui";
 import { ConversationViewer, createStaticConversationSource } from "../../src/ui/conversation-viewer.js";
 
 const theme = {
@@ -28,6 +29,28 @@ function tui() {
   } as any;
 }
 
+function mouse(type: TuiMouseEvent["type"], y: number, overrides: Partial<TuiMouseEvent> = {}): TuiMouseEvent {
+  return {
+    type,
+    button: "left",
+    x: 2,
+    y,
+    screenX: 2,
+    screenY: y,
+    width: 120,
+    height: 30,
+    shift: false,
+    alt: false,
+    ctrl: false,
+    ...overrides,
+  };
+}
+
+// The test record has the default invocation row, so timeline line 0 is viewer row 4.
+function viewerY(timelineLine: number): number {
+  return 4 + timelineLine;
+}
+
 describe("ConversationViewer", () => {
   it("renders assistant fenced code through the Markdown renderer", () => {
     const ui = tui();
@@ -85,8 +108,6 @@ describe("ConversationViewer", () => {
     expect(liveFooter).toContain("j/k scroll · J/K messages · [/] tools · w preview · g/G   t   M o O   /n N   q");
     expect(liveFooter).toContain("e steer");
     expect(liveFooter).toContain("x stop");
-    live.handleInput("\r");
-    expect(live.render(120).join("\n")).not.toContain("Enter send");
     live.handleInput("e");
     expect(live.render(120).join("\n")).toContain("Enter send");
     live.handleInput("\x1b");
@@ -152,78 +173,62 @@ describe("ConversationViewer", () => {
       vi.fn(),
     );
 
-    const initial = viewer.render(120).join("\n");
-    expect(initial).not.toContain("six");
-    expect(initial).not.toContain("READ");
+    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 J/K on user and assistant blocks while j/k remain line scrolling", () => {
+  it("toggles mouse expansion only on the normalized click event", () => {
     const viewer = new ConversationViewer(
       tui(),
       createStaticConversationSource([
-        { role: "assistant", content: [{ type: "text", text: "first" }, { type: "toolCall", name: "read", arguments: { path: "x" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "tool output" }] },
-        { role: "assistant", content: [{ type: "text", text: "second" }] },
+        { 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(),
     );
-    viewer.render(120);
-    viewer.handleInput("J");
-    expect((viewer as any).currentBlock().role).toBe("assistant");
-    expect((viewer as any).currentBlock().markdown).toBe("second");
-    viewer.handleInput("K");
-    expect((viewer as any).currentBlock().markdown).toBe("first");
+    expect(viewer.render(120).join("\n")).not.toContain("six");
+    const span = (viewer as any).timeline.getSnapshot().toolSpans[0];
+    expect(span.clickStartLine).toEqual(expect.any(Number));
+    const hintY = viewerY(span.clickStartLine);
+    expect(viewer.handleMouse(mouse("press", hintY))?.handled).toBe(true);
+    expect(viewer.render(120).join("\n")).not.toContain("six");
+    viewer.handleMouse(mouse("click", hintY, { clickCount: 1 }));
+    expect(viewer.render(120).join("\n")).toContain("six");
   });
 
-  it("focuses nearby tools with [ and ] without changing line-scroll keys", () => {
+  it("focuses USER and ASSISTANT blocks from their rendered spans", () => {
     const viewer = new ConversationViewer(
       tui(),
       createStaticConversationSource([
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "first" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "first output" }] },
-        { role: "assistant", content: [{ type: "text", text: "between" }, { type: "toolCall", name: "read", arguments: { path: "second" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "second output" }] },
+        { role: "user", content: "user text" },
+        { role: "assistant", content: [{ type: "text", text: "assistant text" }] },
       ] as any),
       record(),
       undefined,
       theme,
       vi.fn(),
     );
-    viewer.render(120);
-    const timeline = (viewer as any).timeline;
-    const ids = timeline.getSnapshot().interactiveToolIds;
-    expect(ids).toHaveLength(2);
 
-    viewer.handleInput("]");
-    expect(timeline.getFocusedToolCallId()).toBe(ids[0]);
     viewer.render(120);
-    expect((viewer as any).currentBlock().toolCallId).toBe(ids[0]);
-    viewer.handleInput("]");
-    expect(timeline.getFocusedToolCallId()).toBe(ids[1]);
-    viewer.render(120);
-    expect((viewer as any).currentBlock().toolCallId).toBe(ids[1]);
-    viewer.handleInput("[");
-    expect(timeline.getFocusedToolCallId()).toBe(ids[0]);
+    const timeline = (viewer as any).timeline;
+    const spans = timeline.getSnapshot().blockSpans;
+    expect(spans).toHaveLength(2);
+    viewer.handleMouse(mouse("click", viewerY(spans[1].startLine), { clickCount: 1 }));
+    expect((viewer as any).selectedMessageIdx).toBe(1);
+    expect(timeline.getFocusedToolCallId()).toBeUndefined();
+    viewer.handleMouse(mouse("click", viewerY(spans[0].startLine), { clickCount: 1 }));
+    expect((viewer as any).selectedMessageIdx).toBe(0);
+    expect(timeline.getFocusedToolCallId()).toBeUndefined();
   });
 
-  it("opens a complete read-only tool preview with w for the focused tool", () => {
-    const ui = tui();
-    const custom = vi.fn((factory: any) => {
-      const preview = factory(ui, theme, undefined, vi.fn());
-      const rendered = preview.render(100).join("\\n");
-      expect(rendered).toContain("Input");
-      expect(rendered).toContain("Output");
-      expect(rendered).toContain("one");
-      expect(rendered).toContain("six");
-      return Promise.resolve(undefined);
-    });
+  it("focuses normal tool rows without expanding, while hint clicks expand", () => {
     const viewer = new ConversationViewer(
-      ui,
+      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" }] },
@@ -232,81 +237,92 @@ describe("ConversationViewer", () => {
       undefined,
       theme,
       vi.fn(),
-      undefined,
-      undefined,
-      undefined,
-      { pi: {} as any, ctx: { ui: { custom } } as any, readOnly: true },
     );
-    viewer.render(120);
-    viewer.handleInput("]");
-    viewer.handleInput("w");
-    expect(custom).toHaveBeenCalledWith(expect.any(Function), expect.objectContaining({ overlay: true }));
+
+    expect(viewer.render(120).join("\n")).not.toContain("six");
+    const timeline = (viewer as any).timeline;
+    const initialSpan = timeline.getSnapshot().toolSpans[0];
+    const toolId = initialSpan.toolCallId;
+    const hintLine = initialSpan.clickStartLine as number;
+    const normalOutputLine = hintLine - 1;
+
+    const press = viewer.handleMouse(mouse("press", viewerY(hintLine)));
+    expect(press).toMatchObject({ handled: true, capture: true });
+    expect(timeline.getFocusedToolCallId()).toBeUndefined();
+    expect(viewer.render(120).join("\n")).not.toContain("six");
+
+    viewer.handleMouse(mouse("click", viewerY(normalOutputLine), { clickCount: 1 }));
+    expect(timeline.getFocusedToolCallId()).toBe(toolId);
+    expect((viewer as any).selectedMessageIdx).toBe(initialSpan.blockIndex);
+    expect(viewer.render(120).join("\n")).not.toContain("six");
+
+    const collapsedSpan = timeline.getSnapshot().toolSpans[0];
+    viewer.handleMouse(mouse("click", viewerY(collapsedSpan.clickStartLine as number), { clickCount: 1 }));
+    expect(timeline.getFocusedToolCallId()).toBe(toolId);
+    expect(viewer.render(120).join("\n")).toContain("six");
   });
 
-  it("uses a distinct focus rail for tool cards", () => {
-    const railTheme = {
-      fg: (name: string, text: string) => `<${name}>${text}</${name}>`,
-      bold: (text: string) => `<bold>${text}</bold>`,
-    };
+  it("synchronizes J/K message focus and anchors [/] around the selected message", () => {
     const viewer = new ConversationViewer(
       tui(),
       createStaticConversationSource([
-        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "x" } }] },
-        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "done" }] },
+        { role: "user", content: "user one" },
+        { role: "assistant", content: [{ type: "text", text: "assistant one" }] },
+        { role: "assistant", content: [{ type: "toolCall", id: "tool-1", name: "read", arguments: { path: "one" } }] },
+        { role: "toolResult", toolCallId: "tool-1", toolName: "read", content: [{ type: "text", text: "one" }] },
+        { role: "assistant", content: [{ type: "text", text: "assistant two" }] },
+        { role: "assistant", content: [{ type: "toolCall", id: "tool-2", name: "read", arguments: { path: "two" } }] },
+        { role: "toolResult", toolCallId: "tool-2", toolName: "read", content: [{ type: "text", text: "two" }] },
       ] as any),
       record(),
       undefined,
-      railTheme,
-      vi.fn(),
-    );
-    expect(viewer.render(120).join("\\n")).toContain("<toolTitle>▌</toolTitle>");
-  });
-
-  it("scrolls the transcript with a normalized mouse wheel event", () => {
-    const longText = Array.from({ length: 80 }, (_, index) => `line-${index}`).join("\n");
-    const viewer = new ConversationViewer(
-      tui(),
-      createStaticConversationSource([{ role: "assistant", content: [{ type: "text", text: longText }] }] as any),
-      record(),
-      undefined,
       theme,
       vi.fn(),
     );
+
     viewer.render(120);
-    const before = (viewer as any).scrollOffset;
-    const event = { type: "wheel", button: "none", x: 2, y: 5, screenX: 2, screenY: 5, width: 120, height: 30, shift: false, alt: false, ctrl: false, wheelDelta: -3 };
-    expect(viewer.handleMouse(event as any)?.handled).toBe(true);
-    expect((viewer as any).scrollOffset).toBeLessThan(before);
+    const timeline = (viewer as any).timeline;
+    const snapshot = timeline.getSnapshot();
+    viewer.handleInput("]");
+    expect((viewer as any).selectedMessageIdx).toBe(snapshot.toolSpans[0].blockIndex);
+    expect(timeline.getFocusedToolCallId()).toBe("tool-1");
+
+    viewer.handleInput("J");
+    expect((viewer as any).selectedMessageIdx).toBe(3);
+    expect(timeline.getFocusedToolCallId()).toBeUndefined();
+    viewer.handleInput("]");
+    expect((viewer as any).selectedMessageIdx).toBe(snapshot.toolSpans[1].blockIndex);
+    expect(timeline.getFocusedToolCallId()).toBe("tool-2");
+
+    viewer.handleInput("K");
+    expect((viewer as any).selectedMessageIdx).toBe(3);
+    expect(timeline.getFocusedToolCallId()).toBeUndefined();
+    viewer.handleInput("[");
+    expect((viewer as any).selectedMessageIdx).toBe(snapshot.toolSpans[0].blockIndex);
+    expect(timeline.getFocusedToolCallId()).toBe("tool-1");
   });
 
-  it("expands on the first click and collapses only on the second click", () => {
-    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");
-    const span = (viewer as any).timeline.getSnapshot().toolSpans[0];
-    expect(span.clickStartLine).toEqual(expect.any(Number));
-    const hintY = 4 + span.clickStartLine;
-    const mouse = { button: "left", x: 1, screenX: 1, screenY: hintY, width: 120, height: 30, shift: false, alt: false, ctrl: false };
-    expect(viewer.handleMouse({ ...mouse, type: "press", y: hintY } as any)?.handled).toBe(true);
-    expect(viewer.render(120).join("\n")).not.toContain("six");
-    viewer.handleMouse({ ...mouse, type: "click", y: hintY, clickCount: 1 } as any);
-    expect(viewer.render(120).join("\n")).toContain("six");
-    viewer.handleMouse({ ...mouse, type: "click", y: hintY, clickCount: 1 } as any);
-    expect(viewer.render(120).join("\n")).toContain("six");
-    viewer.handleMouse({ ...mouse, type: "click", y: hintY, clickCount: 2 } as any);
-    expect(viewer.render(120).join("\n")).not.toContain("six");
+  it("uses the first or last tool for initial [/], before an explicit focus exists", () => {
+    const source = createStaticConversationSource([
+      { role: "assistant", content: [{ type: "toolCall", id: "tool-1", name: "read", arguments: { path: "one" } }] },
+      { role: "toolResult", toolCallId: "tool-1", toolName: "read", content: [{ type: "text", text: "one" }] },
+      { role: "assistant", content: [{ type: "toolCall", id: "tool-2", name: "read", arguments: { path: "two" } }] },
+      { role: "toolResult", toolCallId: "tool-2", toolName: "read", content: [{ type: "text", text: "two" }] },
+    ] as any);
+    const makeViewer = () => new ConversationViewer(tui(), source, record(), undefined, theme, vi.fn());
+
+    const left = makeViewer();
+    left.render(120);
+    left.handleInput("[");
+    expect((left as any).timeline.getFocusedToolCallId()).toBe("tool-2");
+
+    const right = makeViewer();
+    right.render(120);
+    right.handleInput("]");
+    expect((right as any).timeline.getFocusedToolCallId()).toBe("tool-1");
   });
 
-  it("highlights the tool hint on hover and closes from the viewer [esc] button", () => {
+  it("highlights the collapsed tool hint and the viewer close control independently", () => {
     const semanticTheme = {
       fg: (name: string, text: string) => `<${name}>${text}</${name}>`,
       bold: (text: string) => `<bold>${text}</bold>`,
@@ -325,21 +341,74 @@ describe("ConversationViewer", () => {
     );
     const initial = viewer.render(120).join("\n");
     const span = (viewer as any).timeline.getSnapshot().toolSpans[0];
-    expect(span.clickStartLine).toEqual(expect.any(Number));
-    const hintY = 4 + span.clickStartLine;
+    const hintY = viewerY(span.clickStartLine);
     expect(initial).not.toContain("<text>click to show more</text>");
-    viewer.handleMouse({ type: "move", button: "none", x: 2, y: hintY, screenX: 2, screenY: hintY, width: 120, height: 30, shift: false, alt: false, ctrl: false } as any);
+    viewer.handleMouse(mouse("move", hintY, { button: "none" }));
     expect(viewer.render(120).join("\n")).toContain("<text>click to show more</text>");
-
-    expect(viewer.render(120).join("\n")).toContain("[esc]");
-    viewer.handleMouse({ type: "move", button: "none", x: 114, y: 1, screenX: 114, screenY: 1, width: 120, height: 30, shift: false, alt: false, ctrl: false } as any);
+    viewer.handleMouse(mouse("move", 1, { button: "none", x: 114, screenX: 114, screenY: 1 }));
     expect(viewer.render(120).join("\n")).toContain("<text><bold>[esc]</bold></text>");
-    const close = { button: "left", x: 114, screenX: 114, screenY: 1, y: 1, width: 120, height: 30, shift: false, alt: false, ctrl: false };
-    expect(viewer.handleMouse({ ...close, type: "press" } as any)?.handled).toBe(true);
-    expect(viewer.handleMouse({ ...close, type: "click", clickCount: 1 } as any)?.handled).toBe(true);
+    expect(viewer.handleMouse(mouse("press", 1, { x: 114, screenX: 114 }))?.handled).toBe(true);
+    expect(viewer.handleMouse(mouse("click", 1, { x: 114, screenX: 114, clickCount: 1 }))?.handled).toBe(true);
     expect(done).toHaveBeenCalledTimes(1);
   });
 
+  it("focuses nearby tools with [ and ] and opens a complete read-only preview with w", () => {
+    const ui = tui();
+    let preview: any;
+    const previewDone = vi.fn();
+    const custom = vi.fn((factory: any) => {
+      preview = factory(ui, theme, undefined, previewDone);
+      const initial = preview.render(100).join("\\n");
+      expect(initial).toContain("Input");
+      expect(initial).toContain("Output");
+      expect(initial).toContain("line 1");
+      expect(initial).not.toContain("line 40");
+      preview.handleInput("G");
+      expect(preview.render(100).join("\\n")).toContain("line 40");
+      preview.handleInput("k");
+      preview.handleInput("j");
+      preview.handleInput("g");
+      preview.handleInput("g");
+      expect(preview.render(100).join("\\n")).toContain("line 1");
+      preview.handleInput("q");
+      expect(previewDone).toHaveBeenCalledTimes(1);
+      return Promise.resolve(undefined);
+    });
+    const viewer = new ConversationViewer(
+      ui,
+      createStaticConversationSource([
+        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "first" } }] },
+        { role: "toolResult", toolName: "read", content: [{ type: "text", text: Array.from({ length: 40 }, (_, index) => `line ${index + 1}`).join("\n") }] },
+        { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "second" } }] },
+        { role: "toolResult", toolName: "read", content: [{ type: "text", text: "second output" }] },
+      ] as any),
+      record(),
+      undefined,
+      theme,
+      vi.fn(),
+      undefined,
+      undefined,
+      undefined,
+      { pi: {} as any, ctx: { ui: { custom } } as any, readOnly: true },
+    );
+    viewer.render(120);
+    const timeline = (viewer as any).timeline;
+    const ids = timeline.getSnapshot().interactiveToolIds;
+    viewer.handleInput("]");
+    expect(timeline.getFocusedToolCallId()).toBe(ids[0]);
+    viewer.render(120);
+    viewer.handleInput("w");
+    expect(custom).toHaveBeenCalledWith(expect.any(Function), expect.objectContaining({ overlay: true }));
+    preview.handleInput("G");
+    preview.handleInput("g");
+    preview.handleInput("g");
+    preview.handleInput("q");
+    viewer.handleInput("]");
+    expect(timeline.getFocusedToolCallId()).toBe(ids[1]);
+    viewer.handleInput("[");
+    expect(timeline.getFocusedToolCallId()).toBe(ids[0]);
+  });
+
   it("keeps historical viewers read-only and closes on Escape", () => {
     const ui = tui();
     const steer = vi.fn();

package/test/ui/fleet-list.test.ts

@@ -114,12 +114,16 @@ describe("FleetList bounded window", () => {
     expect(last.some(line => /↓ \d+ more/.test(line))).toBe(false);
   });
 
-  it("forces a full render once when the active roster changes", () => {
+  it("skips unchanged timer updates but redraws once when the active roster changes", () => {
     const { manager, fleet, tui } = createFleetHarness(makeAgents(5));
     tui.requestRender.mockClear();
+    fleet.update();
+    expect(tui.requestRender).not.toHaveBeenCalled();
+
     manager.records.pop();
     fleet.update();
     expect(tui.requestRender).toHaveBeenCalledWith(true);
+    fleet.dispose();
   });
 
   it("clears the widget when the active roster becomes empty", () => {

package/test/write-execution.test.ts

@@ -31,7 +31,6 @@ describe("executeWriteWithMetadata", () => {
 
     expect(await readFile(join(cwd, "nested/file.txt"), "utf8")).toBe("new\n");
     expect(result.content[0]?.text).toContain("Successfully wrote to nested/file.txt");
-    expect(result.details?.fileExistedBeforeWrite).toBe(false);
     expect(result.details?.diff).toContain("+1 new");
     expect(result.details?.patch).toContain("+new");
     expect(store.get("call-new")?.diff).toBe(result.details?.diff);
@@ -49,7 +48,6 @@ describe("executeWriteWithMetadata", () => {
 
     await writeFile(join(cwd, "file.txt"), "later\n", "utf8");
 
-    expect(persisted.fileExistedBeforeWrite).toBe(true);
     expect(persisted.diff).toContain("-1 old");
     expect(persisted.diff).toContain("+1 new");
     expect(persisted.patch).toContain("-old");