@esso0428/pi-subagents 0.15.16 → 0.16.0

package/src/ui/fleet-list.ts

@@ -2,7 +2,7 @@
  * fleet-list.ts — Claude Code-style "FleetView" list rendered below the editor.
  *
  * Shows `main` + each running/queued subagent as a navigable list. Pressing ↓ (or
- * ←) at an empty prompt activates the list; ↑/↓ move the selection (filled ● marker),
+ * `j`) at an empty prompt activates the list; ↑/↓ move the selection (filled ● marker),
  * Enter opens the selected agent's live conversation overlay, Esc returns to the prompt.
  * A viewer stays open when its agent finishes so the final output remains readable.
  *
@@ -11,10 +11,10 @@
  * can `consume` keys — gated on `getEditorText() === ""` so normal typing is untouched.
  */
 
-import { Editor, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { AgentManager } from "../agent-manager.js";
+import { Editor, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { canOpenActiveAgent } from "../agent-history-list.js";
+import type { AgentManager } from "../agent-manager.js";
 import type { AgentRecord } from "../types.js";
 import { getLifetimeTotal } from "../usage.js";
 import { type AgentActivity, getDisplayName, type Theme } from "./agent-widget.js";
@@ -28,11 +28,23 @@ const FLEET_BASE_ROWS = 2; // hint + main
 const FLEET_BODY_ROWS = FLEET_MAX_RENDER_ROWS - FLEET_BASE_ROWS;
 /** Re-render cadence so elapsed/token stats tick while agents run. */
 const TICK_MS = 200;
+/** Normalized mouse input accepted by FleetView's widget surface. */
+export type FleetMouseEvent = { type: string; wheelDelta?: number };
+
+type FleetMouseResult = { handled: true; render: true };
+
+type FleetWidgetContent = {
+  render(width: number): string[];
+  invalidate(): void;
+  dispose?(): void;
+  handleMouse?(event: FleetMouseEvent): FleetMouseResult | undefined;
+};
+
 /** Minimal UI surface the FleetView needs from `ctx.ui` (structural subset). */
 export type FleetUICtx = {
   setWidget(
     key: string,
-    content: undefined | ((tui: any, theme: Theme) => { render(width: number): string[]; invalidate(): void; dispose?(): void }),
+    content: undefined | ((tui: any, theme: Theme) => FleetWidgetContent),
     options?: { placement?: "aboveEditor" | "belowEditor" },
   ): void;
   onTerminalInput(handler: (data: string) => { consume?: boolean; data?: string } | undefined): () => void;
@@ -62,30 +74,70 @@ export function formatFleetTokens(count: number): string {
   return `↓ ${compact} tokens`;
 }
 
+/** A bounded slice of the agent-only roster rendered by FleetView. */
+export type FleetAgentWindow = {
+  start: number;
+  end: number;
+  hiddenAbove: number;
+  hiddenBelow: number;
+};
+
 /**
- * Calculate a bounded agent slice for the complete logical roster.
- * `selectedRosterIndex` includes main at index 0; `end` is exclusive.
+ * Calculate a bounded agent slice from an agent-only viewport start.
+ * `end` is exclusive; `main` is rendered separately and is not part of this
+ * window. Marker rows are reserved only when the corresponding side is hidden.
  */
 export function calculateFleetAgentWindow(
   agentCount: number,
-  selectedRosterIndex: number,
-): { start: number; end: number; hiddenAbove: number; hiddenBelow: number } {
+  viewportStart: number,
+): FleetAgentWindow {
   const count = Math.max(0, Math.floor(agentCount));
   if (count === 0) return { start: 0, end: 0, hiddenAbove: 0, hiddenBelow: 0 };
 
-  const selectedAgent = Math.min(
+  const maxStart = Math.max(0, count - (FLEET_BODY_ROWS - 1));
+  const start = Math.min(maxStart, Math.max(0, Math.floor(viewportStart)));
+  const hasAbove = start > 0;
+  const agentBudget = Math.max(1, FLEET_BODY_ROWS - (hasAbove ? 1 : 0));
+  let end = Math.min(count, start + agentBudget);
+  if (end < count) end -= 1; // reserve the ↓ marker row
+
+  return {
+    start,
+    end,
+    hiddenAbove: start,
+    hiddenBelow: count - end,
+  };
+}
+
+/**
+ * Return the smallest viewport adjustment that makes an agent visible. The
+ * selected index is 0-based within the agent-only roster; `main` is handled by
+ * FleetList rather than this pure helper.
+ */
+export function ensureFleetSelectionVisible(
+  agentCount: number,
+  selectedAgentIndex: number,
+  viewportStart: number,
+): number {
+  const count = Math.max(0, Math.floor(agentCount));
+  if (count === 0) return 0;
+
+  const selected = Math.min(
     count - 1,
-    Math.max(0, Math.floor(selectedRosterIndex) - 1),
+    Math.max(0, Math.floor(selectedAgentIndex)),
   );
-  const reserveAbove = selectedAgent > 0 ? 1 : 0;
-  const reserveBelow = selectedAgent < count - 1 ? 1 : 0;
-  const visibleCount = Math.max(1, FLEET_BODY_ROWS - reserveAbove - reserveBelow);
-  const start = Math.min(
-    Math.max(0, selectedAgent - visibleCount + 1),
-    Math.max(0, count - visibleCount),
-  );
-  const end = Math.min(count, start + visibleCount);
-  return { start, end, hiddenAbove: start, hiddenBelow: count - end };
+  const maxStart = Math.max(0, count - (FLEET_BODY_ROWS - 1));
+  let start = Math.min(maxStart, Math.max(0, Math.floor(viewportStart)));
+  const current = calculateFleetAgentWindow(count, start);
+
+  if (selected < current.start) {
+    return Math.min(maxStart, selected);
+  }
+  if (selected < current.end) return start;
+
+  // With a possible ↓ marker, selected - 1 is the least forward shift that
+  // exposes the selected row while preserving the marker row budget.
+  return Math.min(maxStart, Math.max(start, selected - 1));
 }
 
 /**
@@ -115,14 +167,15 @@ export class FleetList {
   private active = false;
   /** 0 = `main`, 1..N = subagents. */
   private selectedIndex = 0;
+  /** 0-based start in the agent-only roster; main is rendered separately. */
+  private viewportStart = 0;
   /** Set while a conversation overlay is open; calling it closes the overlay. */
   private viewerClose: (() => void) | undefined;
   private viewingAgentId: string | undefined;
 
   constructor(
     private manager: AgentManager,
-    private agentActivity: Map<string, AgentActivity>,
-    private getCwd: () => string | undefined = () => undefined,
+    private agentActivity: Map<string, AgentActivity>,_getCwd: () => string | undefined = () => undefined,
     private pi?: ExtensionAPI,
     private getCtx: () => ExtensionContext | undefined = () => undefined,
   ) {}
@@ -137,8 +190,8 @@ export class FleetList {
   }
 
   /** Capture the UI context and (re)register the global input handler. */
-  setUICtx(ui: FleetUICtx): void {
-    if (ui === this.ui) return;
+  setUICtx(ui: FleetUICtx): boolean {
+    if (ui === this.ui) return false;
     this.inputUnsub?.();
     this.ui = ui;
     this.widgetRegistered = false;
@@ -146,6 +199,14 @@ export class FleetList {
     this.lastRenderKey = undefined;
     this.tui = undefined;
     this.inputUnsub = ui.onTerminalInput(data => this.handleKey(data));
+    return true;
+  }
+
+  /** Request a render on the currently registered TUI without touching input. */
+  requestUiRefresh(force = true): boolean {
+    if (!this.tui) return false;
+    this.tui.requestRender(force);
+    return true;
   }
 
   /** Ensure the re-render timer is running (called when an agent spawns). */
@@ -173,6 +234,8 @@ export class FleetList {
     this.lastRenderKey = undefined;
     this.tui = undefined;
     this.active = false;
+    this.selectedIndex = 0;
+    this.viewportStart = 0;
     // Null last so a `viewerClose()` microtask above can't re-register the widget.
     this.ui = undefined;
   }
@@ -195,12 +258,14 @@ export class FleetList {
       if (this.timer) { clearInterval(this.timer); this.timer = undefined; }
       this.active = false;
       this.selectedIndex = 0;
+      this.viewportStart = 0;
       this.lastRosterKey = undefined;
       this.lastRenderKey = undefined;
       return;
     }
 
     this.clampSelection();
+    this.ensureSelectionVisible();
     this.ensureTimer(); // keep stats ticking whenever the list is shown (e.g. after a re-enable)
     const renderKey = this.renderKey(records);
 
@@ -210,6 +275,7 @@ export class FleetList {
         return {
           render: (w: number) => this.renderBar(w, theme),
           invalidate: () => { this.widgetRegistered = false; this.tui = undefined; },
+          handleMouse: (event: FleetMouseEvent) => this.handleMouse(event),
         };
       }, { placement: "belowEditor" });
       this.widgetRegistered = true;
@@ -243,7 +309,13 @@ export class FleetList {
         Math.round(((record.completedAt ?? now) - record.startedAt) / 1000),
       ].join("\u001f");
     });
-    return [this.enabled ? "1" : "0", this.active ? "1" : "0", String(this.selectedIndex), ...agentState].join("\u001e");
+    return [
+      this.enabled ? "1" : "0",
+      this.active ? "1" : "0",
+      String(this.selectedIndex),
+      String(this.viewportStart),
+      ...agentState,
+    ].join("\u001e");
   }
 
   // ---- Roster ----
@@ -270,8 +342,84 @@ export class FleetList {
     if (this.selectedIndex < 0) this.selectedIndex = 0;
   }
 
+  /** Keep the selected agent visible without recentering an already-valid window. */
+  private ensureSelectionVisible(): void {
+    const agents = this.agentRecords();
+    if (agents.length === 0) {
+      this.viewportStart = 0;
+      return;
+    }
+    if (this.selectedIndex > 0) {
+      this.viewportStart = ensureFleetSelectionVisible(
+        agents.length,
+        this.selectedIndex - 1,
+        this.viewportStart,
+      );
+      return;
+    }
+    // `main` does not constrain the agent window, but a roster shrink can make
+    // its previous start invalid. Use the same pure clamp as renderBar.
+    this.viewportStart = calculateFleetAgentWindow(agents.length, this.viewportStart).start;
+  }
+
   // ---- Key handling ----
 
+  /**
+   * Move the selection while keeping keyboard and wheel input on one path.
+   * Returns whether the direction was handled; inactive upward input and input
+   * that cannot activate the list are left for the editor/transcript.
+   */
+  private moveSelection(direction: -1 | 1): boolean {
+    const max = this.roster().length - 1;
+    if (max < 0) return false;
+
+    if (!this.active) {
+      // Match ↓ activation: only a downward direction at an empty prompt with
+      // the editor focused enters the list. Upward input remains a no-op.
+      if (direction !== 1 || !this.editorHasFocus() || this.agentRecords().length === 0 || this.ui?.getEditorText() !== "") {
+        return false;
+      }
+      this.active = true;
+      this.selectedIndex = 0;
+      this.viewportStart = 0;
+      this.update();
+      return true;
+    }
+
+    this.clampSelection();
+    if (direction === -1 && this.selectedIndex === 0) {
+      this.deactivate();
+      return true;
+    }
+    this.selectedIndex = direction === 1
+      ? Math.min(max, this.selectedIndex + 1)
+      : Math.max(0, this.selectedIndex - 1);
+    this.ensureSelectionVisible();
+    this.update();
+    return true;
+  }
+
+  /** Handle normalized wheel input from the registered widget. */
+  handleMouse(event: FleetMouseEvent): FleetMouseResult | undefined {
+    if (!this.enabled || !this.ui || this.viewerClose) return undefined;
+    if (event.type !== "wheel") return undefined;
+
+    const wheelDelta = event.wheelDelta;
+    const direction: -1 | 1 | undefined = wheelDelta == null
+      ? undefined
+      : wheelDelta < 0
+        ? -1
+        : wheelDelta > 0
+          ? 1
+          : undefined;
+    if (!direction || !this.moveSelection(direction)) return undefined;
+
+    // The widget handled the normalized wheel, including at selection
+    // boundaries; explicitly request a redraw so it never falls through to
+    // Pi's transcript fallback.
+    return { handled: true, render: true };
+  }
+
   /** Returns `{consume:true}` to swallow a key, or undefined to let it through. */
   handleKey(data: string): { consume?: boolean; data?: string } | undefined {
     if (!this.enabled || !this.ui) return undefined;
@@ -290,31 +438,17 @@ export class FleetList {
       return undefined;
     }
 
-    if (!this.active) {
-      // Activate: ↓ or ← at an empty prompt moves focus into the list.
-      const isActivator = matchesKey(data, "down") || matchesKey(data, "left");
-      if (isActivator && this.agentRecords().length > 0 && this.ui.getEditorText() === "") {
-        this.active = true;
-        this.selectedIndex = 0;
-        this.update();
-        return { consume: true };
-      }
-      return undefined;
-    }
+    const direction: -1 | 1 | undefined = matchesKey(data, "down") || matchesKey(data, "j")
+      || (!this.active && matchesKey(data, "left"))
+      ? 1
+      : matchesKey(data, "up") || matchesKey(data, "k")
+        ? -1
+        : undefined;
+    if (direction && this.moveSelection(direction)) return { consume: true };
 
-    // Active — arrows navigate, Enter opens, Esc / Up-past-top exits.
-    if (matchesKey(data, "down")) {
-      const max = this.roster().length - 1;
-      this.selectedIndex = Math.min(max, this.selectedIndex + 1);
-      this.update();
-      return { consume: true };
-    }
-    if (matchesKey(data, "up")) {
-      if (this.selectedIndex === 0) { this.deactivate(); return { consume: true }; }
-      this.selectedIndex -= 1;
-      this.update();
-      return { consume: true };
-    }
+    if (!this.active) return undefined;
+
+    // Active — Enter opens, Esc / Up-past-top exits.
     if (matchesKey(data, "escape")) { this.deactivate(); return { consume: true }; }
     if (matchesKey(data, Key.enter)) { this.openSelected(); return { consume: true }; }
 
@@ -339,6 +473,7 @@ export class FleetList {
   private deactivate(): void {
     this.active = false;
     this.selectedIndex = 0;
+    this.viewportStart = 0;
     this.update();
   }
 
@@ -416,12 +551,12 @@ export class FleetList {
 
     const hint = this.active
       ? "↑↓ select · enter view · esc back"
-      : "esc to interrupt · ← for agents · ↓ to manage";
+      : "esc to interrupt · ↓ to manage";
     const lines: string[] = [];
     lines.push(truncateToWidth("  " + theme.fg("dim", hint), width));
     lines.push(truncateToWidth(`  ${this.bullet(0, sel, theme)} main`, width));
 
-    const window = calculateFleetAgentWindow(agents.length, sel);
+    const window = calculateFleetAgentWindow(agents.length, this.viewportStart);
     if (window.hiddenAbove > 0) {
       lines.push(rightAlign("", theme.fg("dim", `↑ ${window.hiddenAbove} more`), width));
     }

package/src/write-execution.ts

@@ -1,6 +1,6 @@
-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";
+import { createWriteToolDefinition, type ExtensionContext, generateDiffString, generateUnifiedPatch, type ToolDefinition, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 
 /** Maximum UTF-8 size of the durable display diff plus unified patch. */
 export const MAX_DURABLE_DIFF_BYTES = 4 * 1024 * 1024;
@@ -58,7 +58,7 @@ function resolveWritePath(path: string, cwd: string): string {
 }
 
 async function capturePreviousContent(absolutePath: string): Promise<WriteExecutionMeta> {
-  let info;
+  let info: Awaited<ReturnType<typeof lstat>>;
   try {
     info = await lstat(absolutePath);
   } catch (error: any) {

package/test/agent-history-list.test.ts

@@ -1,121 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  buildAgentStatusMenuEntries,
-  canOpenActiveAgent,
-  canOpenAgentHistory,
-  formatAgentHistoryOption,
-  isTerminalAgentStatus,
-  splitAgentRecords,
-} from "../src/agent-history-list.js";
-
-type TestRecord = {
-  status: string;
-  session?: object;
-  transcriptPath?: string;
-  type?: string;
-  description?: string;
-  startedAt?: number;
-  completedAt?: number;
-};
-
-const tempDirectories: string[] = [];
-
-afterEach(() => {
-  for (const directory of tempDirectories.splice(0)) {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-function record(overrides: TestRecord): any {
-  return {
-    id: "agent-1",
-    type: "Explore",
-    description: "Inspect the repository",
-    status: "completed",
-    toolUses: 0,
-    startedAt: 1_000,
-    lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-    compactionCount: 0,
-    ...overrides,
-  };
-}
-
-describe("agent history list helpers", () => {
-  it("recognizes exactly the five terminal statuses", () => {
-    for (const status of ["completed", "steered", "stopped", "aborted", "error"]) {
-      expect(isTerminalAgentStatus(status)).toBe(true);
-    }
-    for (const status of ["running", "queued", "unknown", ""]) {
-      expect(isTerminalAgentStatus(status)).toBe(false);
-    }
-  });
-
-  it("separates active and terminal records without mutating input", () => {
-    const done = record({ status: "completed", session: {} });
-    const running = record({ status: "running", session: {} });
-    const stopped = record({ status: "stopped", session: {} });
-    const queued = record({ status: "queued", session: {} });
-    const input = [done, running, stopped, queued];
-    const before = [...input];
-
-    const result = splitAgentRecords(input, undefined);
-
-    expect(result.active).toEqual([running, queued]);
-    expect(result.history).toEqual([done, stopped]);
-    expect(input).toEqual(before);
-    expect(input).toEqual([done, running, stopped, queued]);
-  });
-
-  it("requires a session or existing transcript for history", () => {
-    expect(canOpenAgentHistory(record({ session: undefined }), undefined)).toBe(false);
-    expect(canOpenAgentHistory(record({ session: {} }), undefined)).toBe(true);
-    expect(canOpenAgentHistory(record({ status: "running", session: {} }), undefined)).toBe(false);
-    expect(canOpenActiveAgent(record({ status: "running", session: {} }))).toBe(true);
-    expect(canOpenActiveAgent(record({ status: "queued", session: undefined }))).toBe(false);
-    expect(canOpenActiveAgent(record({ status: "completed", session: {} }))).toBe(false);
-  });
-
-  it("opens history only for an existing project-local transcript", () => {
-    const cwd = mkdtempSync(join(tmpdir(), "pi-subagents-history-list-"));
-    tempDirectories.push(cwd);
-    const transcriptPath = ".pi-subagents/agent-transcripts/agent.jsonl";
-    mkdirSync(join(cwd, ".pi-subagents", "agent-transcripts"), { recursive: true });
-    const historical = record({ session: undefined, transcriptPath });
-
-    expect(canOpenAgentHistory(historical, cwd)).toBe(false);
-    writeFileSync(join(cwd, transcriptPath), "{}\n");
-    expect(canOpenAgentHistory(historical, cwd)).toBe(true);
-    expect(canOpenAgentHistory(historical, undefined)).toBe(false);
-  });
-
-  it("builds separate menu entries with openable records only", () => {
-    const entries = buildAgentStatusMenuEntries([
-      record({ status: "running", session: {} }),
-      record({ status: "queued", session: undefined }),
-      record({ status: "completed", session: {} }),
-      record({ status: "error", session: {} }),
-      record({ status: "stopped", session: undefined }),
-    ], undefined);
-
-    expect(entries).toEqual(["Running agents (1)", "Agent history (2)"]);
-    expect(buildAgentStatusMenuEntries([record({ status: "queued", session: undefined })], undefined)).toEqual([]);
-  });
-
-  it("formats a bounded history option using the display name and duration", () => {
-    const option = formatAgentHistoryOption(record({
-      status: "completed",
-      type: "Explore",
-      description: "A very long description ".repeat(20),
-      startedAt: 1_000,
-      completedAt: 3_000,
-    }), 9_000);
-
-    expect(option).toContain("[completed]");
-    expect(option).toContain("Explore");
-    expect(option).toContain("2.0s");
-    expect(option.length).toBeLessThanOrEqual(140);
-  });
-});

package/test/agent-manager-history.test.ts

@@ -1,88 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { AgentManager } from "../src/agent-manager.js";
-
-const managers: AgentManager[] = [];
-
-afterEach(() => {
-  for (const manager of managers.splice(0)) manager.dispose();
-});
-
-function makeManager(): AgentManager {
-  const manager = new AgentManager();
-  managers.push(manager);
-  return manager;
-}
-
-function record(overrides: Record<string, unknown> = {}) {
-  return {
-    id: "agent-1",
-    type: "Explore",
-    description: "Inspect the repository",
-    status: "completed",
-    result: "done",
-    toolUses: 2,
-    startedAt: 1_000,
-    completedAt: 2_000,
-    ...overrides,
-  };
-}
-
-describe("AgentManager.restoreCompleted", () => {
-  it("restores all five terminal statuses without sessions", () => {
-    const manager = makeManager();
-    manager.restoreCompleted(["completed", "steered", "stopped", "aborted", "error"].map((status, i) =>
-      record({ id: `agent-${i}`, status }),
-    ));
-
-    expect(manager.listAgents()).toHaveLength(5);
-    for (const restored of manager.listAgents()) {
-      expect(["completed", "steered", "stopped", "aborted", "error"]).toContain(restored.status);
-      expect(restored.session).toBeUndefined();
-      expect(restored.abortController).toBeUndefined();
-      expect(restored.promise).toBeUndefined();
-      expect(restored.lifetimeUsage).toEqual({ input: 0, output: 0, cacheWrite: 0 });
-      expect(restored.compactionCount).toBe(0);
-    }
-  });
-
-  it("ignores running, queued, and invalid records", () => {
-    const manager = makeManager();
-    manager.restoreCompleted([
-      record({ id: "running", status: "running" }),
-      record({ id: "queued", status: "queued" }),
-      { id: "invalid" },
-    ]);
-
-    expect(manager.listAgents()).toEqual([]);
-  });
-
-  it("keeps the last valid duplicate input", () => {
-    const manager = makeManager();
-    manager.restoreCompleted([
-      record({ result: "first", startedAt: 1_000, completedAt: 1_100 }),
-      record({ result: "last", startedAt: 2_000, completedAt: 2_100 }),
-    ]);
-
-    expect(manager.getRecord("agent-1")?.result).toBe("last");
-    expect(manager.getRecord("agent-1")?.startedAt).toBe(2_000);
-  });
-
-  it("does not replace a live record and rejects unsafe persisted data", () => {
-    const manager = makeManager();
-    // Exercise the public map through a restored terminal, then make it live
-    // without starting an LLM session.
-    manager.restoreCompleted([record({ id: "live", result: "original" })]);
-    const liveRecord = manager.getRecord("live")!;
-    liveRecord.status = "running";
-
-    manager.restoreCompleted([
-      record({ id: "live", result: "replacement" }),
-      record({ id: "bad-time", startedAt: Number.NaN }),
-      record({ id: "bad-path", transcriptPath: "../../outside.jsonl" }),
-    ]);
-
-    expect(manager.getRecord("live")?.result).toBe("original");
-    expect(manager.getRecord("bad-time")).toBeUndefined();
-    expect(manager.getRecord("bad-path")).toBeUndefined();
-  });
-});

package/test/agent-menu-history-navigation.test.ts

@@ -1,86 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import extension from "../src/index.js";
-import { agentHistoryLocator } from "../src/agent-history.js";
-
-const tempDirectories: string[] = [];
-
-afterEach(() => {
-  for (const directory of tempDirectories.splice(0)) rmSync(directory, { recursive: true, force: true });
-});
-
-describe("/agents history navigation", () => {
-  it("returns to the Agents menu after closing a history viewer", async () => {
-    const cwd = mkdtempSync(join(tmpdir(), "pi-subagents-menu-test-"));
-    tempDirectories.push(cwd);
-    const transcript = ".pi-subagents/agent-transcripts/agent-1.jsonl";
-    mkdirSync(join(cwd, ".pi-subagents/agent-transcripts"), { recursive: true });
-    writeFileSync(join(cwd, transcript), JSON.stringify({ message: { role: "user", content: "hello" } }) + "\n");
-
-    const eventHandlers = new Map<string, Set<(...args: any[]) => any>>();
-    const events = {
-      on: (name: string, handler: (...args: any[]) => any) => {
-        const handlersForEvent = eventHandlers.get(name) ?? new Set<(...args: any[]) => any>();
-        handlersForEvent.add(handler);
-        eventHandlers.set(name, handlersForEvent);
-        return () => handlersForEvent.delete(handler);
-      },
-      emit: (name: string, ...args: any[]) => {
-        for (const handler of eventHandlers.get(name) ?? []) handler(...args);
-      },
-    };
-    const handlers = new Map<string, (...args: any[]) => any>();
-    let command: { handler: (_args: unknown, ctx: any) => Promise<void> } | undefined;
-    const pi: any = {
-      events,
-      registerMessageRenderer: () => {},
-      registerTool: () => {},
-      registerCommand: (_name: string, definition: typeof command) => { command = definition; },
-      on: (name: string, handler: (...args: any[]) => any) => { handlers.set(name, handler); },
-      appendEntry: () => {},
-      sendMessage: () => {},
-    };
-    extension(pi);
-
-    const titles: string[] = [];
-    let historySelections = 0;
-    const ui = {
-      notify: () => {},
-      setWidget: () => {},
-      setStatus: () => {},
-      onTerminalInput: () => () => {},
-      select: async (title: string, options: string[]) => {
-        titles.push(title);
-        if (title === "Agents" && titles.filter(item => item === "Agents").length === 1) {
-          return options.find(option => option.startsWith("Agent history ("));
-        }
-        if (title === "Agent history" && historySelections++ === 0) return options[0];
-        return undefined;
-      },
-      custom: async () => undefined,
-    };
-    const ctx = {
-      cwd,
-      ui,
-      sessionManager: {
-        getSessionId: () => undefined,
-        getBranch: () => [{
-          type: "custom",
-          customType: "subagents:record",
-          data: {
-            id: "agent-1", type: "Explore", description: "Inspect", status: "completed",
-            startedAt: 1, completedAt: 2, transcriptPath: agentHistoryLocator(cwd, join(cwd, transcript)),
-          },
-        }],
-      },
-    };
-
-    await handlers.get("session_start")?.({}, ctx);
-    await command?.handler({}, ctx);
-    await handlers.get("session_shutdown")?.();
-
-    expect(titles).toEqual(["Agents", "Agent history", "Agents"]);
-  });
-});