@esso0428/pi-subagents 0.15.15 → 0.15.17

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.15.17] - 2026-09-14
+
+### Fixed
+- **FleetView preserves the selected row while navigating** by maintaining a bounded viewport over the full roster; `j`/`k`, arrow keys, and normalized wheel input share one directional transition and consume handled wheel events without stealing input from other focused components.
+- **Structural Fleet/widget changes refresh the text-input viewport after a short defer** instead of requiring a manual redraw; refreshes coalesce, respect a maximum wait, cancel on session switch, and dispose before shutdown cleanup.
+
+## [0.15.16] - 2026-09-13
+
+### Added
+- **Live panel rendering now coalesces refreshes and avoids rebuilding unchanged rows**, keeping FleetView, the conversation timeline, and tool hover interactions responsive during frequent agent updates.
+
+### Fixed
+- Same-name tool results remain paired with their originating tool calls when a conversation is refreshed.
+
 ## [0.15.15] - 2026-09-13
 
 ### Added

package/README.md

@@ -15,7 +15,7 @@ https://github.com/user-attachments/assets/8685261b-9338-4fea-8dfe-1c590d5df543
 - **Claude Code look & feel** — same tool names, calling conventions, and UI patterns (`Agent`, `get_subagent_result`, `steer_subagent`) — feels native
 - **Parallel background agents** — spawn multiple agents that run concurrently with automatic queuing (configurable concurrency limit, default 4) and smart group join (consolidated notifications)
 - **Live widget UI** — persistent above-editor widget with animated spinners, live tool activity, token counts, and colored status icons. Configurable via `/agents → Settings → Widget`: `all` (every agent), `background` (default — hides foreground runs, which already render inline as the `Agent` tool result), or `off`
-- **FleetView** — Claude Code-style navigable list of `main` + every running subagent rendered below the editor (earliest-launched first). Press `↓` (or `←`) at an empty prompt to jump in, `↑`/`↓` to move the selection, `Enter` to open the selected agent's live, auto-updating conversation, `Esc` to return. Finished agents linger briefly before dropping out, and a viewer stays open through completion so you can read the final output. Toggle via `/agents → Settings → Fleet view`
+- **FleetView** — Claude Code-style navigable list of `main` + every running subagent rendered below the editor (earliest-launched first). Press `↓` (or `←`) at an empty prompt to jump in, `↑`/`↓`/wheel to move the selection, `Enter` to open the selected agent's live, auto-updating conversation, `Esc` to return. The selected row stays visible while the bounded list window moves through the full roster. Finished agents linger briefly before dropping out, and a viewer stays open through completion so you can read the final output. Toggle via `/agents → Settings → Fleet view`
 - **Conversation viewer** — select any agent in `/agents` to open a live-scrolling overlay of its full conversation (auto-follows new content, scroll up to pause). Steer a running agent inline by pressing `Enter` to open a composer, typing, then `Enter` to send (`Esc` or an empty submit returns) — the message appears as a user message and redirects the agent after its current tool. Stop a still-running agent by pressing `x` (then `x` again to confirm) — both work for background agents too
 - **Custom agent types** — define agents in `.pi/agents/<name>.md` or `.agents/agents/<name>.md` (project) or globally, with YAML frontmatter: custom system prompts, model selection, thinking levels, tool restrictions
 - **Mid-run steering** — inject messages into running agents to redirect their work without restarting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esso0428/pi-subagents",
-  "version": "0.15.15",
+  "version": "0.15.17",
   "description": "A pi extension that brings smart Claude Code-style autonomous sub-agents to pi, with npm:pi-subagents-style JSON agent overrides.",
   "author": "ESSO0428",
   "repository": {

package/src/index.ts

@@ -50,6 +50,7 @@ import {
   type UICtx,
 } from "./ui/agent-widget.js";
 import { FleetList, type FleetUICtx } from "./ui/fleet-list.js";
+import { createDeferredUiRefresh } from "./ui/deferred-ui-refresh.js";
 import { showSchedulesMenu } from "./ui/schedule-menu.js";
 import { addUsage, getLifetimeTotal, getSessionContextPercent, type LifetimeUsage } from "./usage.js";
 
@@ -374,6 +375,7 @@ export default function (pi: ExtensionAPI) {
     fleet.onAgentFinished(record.id);
     scheduleNudge(record.id, () => emitIndividualNudge(record));
     widget.update();
+    scheduleUiRefresh();
   }
 
   // ---- Group join manager ----
@@ -385,7 +387,11 @@ export default function (pi: ExtensionAPI) {
       scheduleNudge(groupKey, () => {
         // Re-check at send time
         const unconsumed = records.filter(r => !r.resultConsumed);
-        if (unconsumed.length === 0) { widget.update(); return; }
+        if (unconsumed.length === 0) {
+          widget.update();
+          scheduleUiRefresh();
+          return;
+        }
 
         const notifications = unconsumed.map(r => formatTaskNotification(r, 300)).join('\n\n');
         const label = partial
@@ -406,6 +412,7 @@ export default function (pi: ExtensionAPI) {
         }, { deliverAs: "followUp", triggerTurn: true });
       });
       widget.update();
+      scheduleUiRefresh();
     },
     30_000,
   );
@@ -463,6 +470,7 @@ export default function (pi: ExtensionAPI) {
       widget.markFinished(record.id);
       fleet.onAgentFinished(record.id);
       widget.update();
+      scheduleUiRefresh();
       return;
     }
 
@@ -470,6 +478,7 @@ export default function (pi: ExtensionAPI) {
     // don't send an individual nudge — finalizeBatch will pick it up retroactively.
     if (currentBatchAgents.some(a => a.id === record.id)) {
       widget.update();
+      scheduleUiRefresh();
       return;
     }
 
@@ -480,6 +489,7 @@ export default function (pi: ExtensionAPI) {
     // 'held' → do nothing, group will fire later
     // 'delivered' → group callback already fired
     widget.update();
+    scheduleUiRefresh();
   }, undefined, (record) => {
     // Emit started event when agent transitions to running (including from queue)
     pi.events.emit("subagents:started", {
@@ -487,6 +497,11 @@ export default function (pi: ExtensionAPI) {
       type: record.type,
       description: record.description,
     });
+    widget.ensureTimer();
+    widget.update();
+    fleet.ensureTimer();
+    fleet.update();
+    scheduleUiRefresh();
   }, (record, info) => {
     // Emit compacted event when agent's session compacts (preserves count on record).
     pi.events.emit("subagents:compacted", {
@@ -581,6 +596,7 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("session_before_switch", () => {
+    deferredUiRefresh.cancel();
     manager.clearCompleted(true);
     scheduler.stop();
   });
@@ -602,6 +618,7 @@ export default function (pi: ExtensionAPI) {
     manager.abortAll();
     for (const timer of pendingNudges.values()) clearTimeout(timer);
     pendingNudges.clear();
+    deferredUiRefresh.dispose();
     fleet.dispose();
     manager.dispose();
   });
@@ -614,13 +631,34 @@ export default function (pi: ExtensionAPI) {
   let widgetMode: WidgetMode = "background";
   function getWidgetMode(): WidgetMode { return widgetMode; }
   const widget = new AgentWidget(manager, agentActivity, getWidgetMode);
-  function setWidgetMode(m: WidgetMode): void { widgetMode = m; widget.update(); }
+  function setWidgetMode(m: WidgetMode): void {
+    const changed = widgetMode !== m;
+    widgetMode = m;
+    widget.update();
+    if (changed) scheduleUiRefresh();
+  }
 
   // Claude Code-style FleetView: navigable list of main + subagents below the editor.
   const fleet = new FleetList(manager, agentActivity, () => currentCtx?.cwd, pi, () => currentCtx);
+
+  // One render-only scheduler is shared by both widgets. The callback resolves
+  // the live TUI target at fire time because session switches invalidate the
+  // previous widget context; both widgets use the same TUI, so one successful
+  // request is sufficient.
+  const deferredUiRefresh = createDeferredUiRefresh(() => {
+    if (widget.requestUiRefresh(true)) return;
+    fleet.requestUiRefresh(true);
+  });
+  const scheduleUiRefresh = (): void => deferredUiRefresh.schedule();
+
   let fleetViewEnabled = true;
   function isFleetViewEnabled(): boolean { return fleetViewEnabled; }
-  function setFleetViewEnabled(b: boolean): void { fleetViewEnabled = b; fleet.setEnabled(b); }
+  function setFleetViewEnabled(b: boolean): void {
+    const changed = fleetViewEnabled !== b;
+    fleetViewEnabled = b;
+    fleet.setEnabled(b);
+    if (changed) scheduleUiRefresh();
+  }
 
   // Project/global default for writing the subagent .output transcript. A custom
   // agent's `output_transcript` frontmatter overrides this per spawn; when the
@@ -720,8 +758,9 @@ export default function (pi: ExtensionAPI) {
 
   // Grab UI context from first tool execution + clear lingering widget on new turn
   pi.on("tool_execution_start", async (_event, ctx) => {
-    widget.setUICtx(ctx.ui as UICtx);
-    fleet.setUICtx(ctx.ui as unknown as FleetUICtx);
+    const widgetContextChanged = widget.setUICtx(ctx.ui as UICtx);
+    const fleetContextChanged = fleet.setUICtx(ctx.ui as unknown as FleetUICtx);
+    if (widgetContextChanged || fleetContextChanged) scheduleUiRefresh();
     widget.onTurnStart();
   });
 
@@ -1319,6 +1358,7 @@ Terse command-style prompts produce shallow, generic work.
         widget.update();
         fleet.ensureTimer();
         fleet.update();
+        scheduleUiRefresh();
 
         // Emit created event
         pi.events.emit("subagents:created", {
@@ -1379,8 +1419,10 @@ Terse command-style prompts produce shallow, generic work.
             fgId = a.id;
             agentActivity.set(a.id, fgState);
             widget.ensureTimer();
+            widget.update();
             fleet.ensureTimer();
             fleet.update();
+            scheduleUiRefresh();
             break;
           }
         }

package/src/ui/agent-widget.ts

@@ -240,6 +240,8 @@ export class AgentWidget {
   private tui: any | undefined;
   /** Last status bar text, used to avoid redundant setStatus calls. */
   private lastStatusText: string | undefined;
+  /** Snapshot of the state used for the last widget registration/render request. */
+  private lastRenderKey: string | undefined;
 
   constructor(
     private manager: AgentManager,
@@ -273,15 +275,24 @@ export class AgentWidget {
   }
 
   /** Set the UI context (grabbed from first tool execution). */
-  setUICtx(ctx: UICtx) {
-    if (ctx !== this.uiCtx) {
-      // UICtx changed — the widget registered on the old context is gone.
-      // Force re-registration on next update().
-      this.uiCtx = ctx;
-      this.widgetRegistered = false;
-      this.tui = undefined;
-      this.lastStatusText = undefined;
-    }
+  setUICtx(ctx: UICtx): boolean {
+    if (ctx === this.uiCtx) return false;
+
+    // UICtx changed — the widget registered on the old context is gone.
+    // Force re-registration on next update().
+    this.uiCtx = ctx;
+    this.widgetRegistered = false;
+    this.tui = undefined;
+    this.lastStatusText = undefined;
+    this.lastRenderKey = undefined;
+    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;
   }
 
   /**
@@ -297,10 +308,20 @@ export class AgentWidget {
     this.update();
   }
 
-  /** Ensure the widget update timer is running. */
+  /** Keep the spinner/elapsed-time timer alive only while a visible agent runs. */
   ensureTimer() {
+    if (!this.uiCtx || !this.widgetAgents().some(a => a.status === "running")) return;
     if (!this.widgetInterval) {
-      this.widgetInterval = setInterval(() => this.update(), 80);
+      this.widgetInterval = setInterval(() => this.update(true), 80);
+    }
+  }
+
+  private syncTimer(shouldRun: boolean): void {
+    if (shouldRun) {
+      this.ensureTimer();
+    } else if (this.widgetInterval) {
+      clearInterval(this.widgetInterval);
+      this.widgetInterval = undefined;
     }
   }
 
@@ -505,8 +526,43 @@ export class AgentWidget {
     return lines;
   }
 
-  /** Force an immediate widget update. */
-  update() {
+  /** Build a render-relevant snapshot without capturing mutable records. */
+  private renderKey(allAgents: ReturnType<AgentManager["listAgents"]>): string {
+    const activities = allAgents.map(a => {
+      const activity = this.agentActivity.get(a.id);
+      return activity ? {
+        id: a.id,
+        activeTools: [...activity.activeTools.entries()],
+        toolUses: activity.toolUses,
+        responseText: activity.responseText,
+        turnCount: activity.turnCount,
+        maxTurns: activity.maxTurns,
+        lifetimeUsage: activity.lifetimeUsage,
+        contextPercent: getSessionContextPercent(activity.session),
+      } : undefined;
+    });
+    return JSON.stringify({
+      frame: this.widgetFrame,
+      agents: allAgents.map(a => ({
+        id: a.id,
+        type: a.type,
+        description: a.description,
+        status: a.status,
+        toolUses: a.toolUses,
+        startedAt: a.startedAt,
+        completedAt: a.completedAt,
+        error: a.error,
+        lifetimeUsage: a.lifetimeUsage,
+        compactionCount: a.compactionCount,
+        isBackground: a.isBackground,
+      })),
+      activities,
+      finishedTurnAge: [...this.finishedTurnAge.entries()],
+    });
+  }
+
+  /** Force an immediate widget update. `advanceSpinner` is reserved for the timer. */
+  update(advanceSpinner = false) {
     if (!this.uiCtx) return;
     const allAgents = this.widgetAgents();
 
@@ -532,7 +588,8 @@ export class AgentWidget {
         this.uiCtx.setStatus("subagents", undefined);
         this.lastStatusText = undefined;
       }
-      if (this.widgetInterval) { clearInterval(this.widgetInterval); this.widgetInterval = undefined; }
+      this.lastRenderKey = undefined;
+      this.syncTimer(false);
       // Clean up stale entries
       for (const [id] of this.finishedTurnAge) {
         if (!allAgents.some(a => a.id === id)) this.finishedTurnAge.delete(id);
@@ -554,7 +611,12 @@ export class AgentWidget {
       this.lastStatusText = newStatusText;
     }
 
-    this.widgetFrame++;
+    // Spinner animation is driven only by the timer while a visible running
+    // agent exists. Event-driven updates refresh changed stats without making
+    // an otherwise idle widget advance.
+    if (advanceSpinner && runningCount > 0) this.widgetFrame++;
+    this.syncTimer(runningCount > 0);
+    const renderKey = this.renderKey(allAgents);
 
     // Register widget callback once; subsequent updates use requestRender()
     // which re-invokes render() without replacing the component (avoids layout thrashing).
@@ -567,14 +629,17 @@ export class AgentWidget {
             // Theme changed — force re-registration so factory captures fresh theme.
             this.widgetRegistered = false;
             this.tui = undefined;
+            this.lastRenderKey = undefined;
           },
         };
       }, { placement: "aboveEditor" });
       this.widgetRegistered = true;
-    } else {
-      // Widget already registered — just request a re-render of existing components.
+    } else if (renderKey !== this.lastRenderKey) {
+      // Widget already registered — request a re-render only when visible state
+      // changed (or the spinner timer advanced).
       this.tui?.requestRender();
     }
+    this.lastRenderKey = renderKey;
   }
 
   dispose() {
@@ -589,5 +654,8 @@ export class AgentWidget {
     this.widgetRegistered = false;
     this.tui = undefined;
     this.lastStatusText = undefined;
+    this.lastRenderKey = undefined;
+    this.uiCtx = undefined;
+    this.finishedTurnAge.clear();
   }
 }

package/src/ui/conversation-blocks.ts

@@ -300,23 +300,25 @@ export function formatConversationMessages(
   const blocks: ConversationBlock[] = [];
   const usedBlockIds = new Set<string>();
   const callsById = new Map<string, ConversationBlock>();
-  const callsByName = new Map<string, ConversationBlock[]>();
+  const callsByName = new Map<string, { blocks: ConversationBlock[]; next: number }>();
 
   const registerCall = (name: string, block: ConversationBlock) => {
     callsById.set(block.toolCallId!, block);
     const nameKey = name.toLowerCase();
-    const candidates = callsByName.get(nameKey) ?? [];
-    candidates.push(block);
-    callsByName.set(nameKey, candidates);
+    const queue = callsByName.get(nameKey) ?? { blocks: [], next: 0 };
+    queue.blocks.push(block);
+    callsByName.set(nameKey, queue);
   };
   const unregisterCall = (block: ConversationBlock) => {
+    // Calls remain in their name queue as tombstones. Advancing its cursor is
+    // amortized O(1), unlike removing from the middle of a same-name array.
     if (block.toolCallId) callsById.delete(block.toolCallId);
-    const nameKey = (block.toolName ?? "tool").toLowerCase();
-    const candidates = callsByName.get(nameKey);
-    if (!candidates) return;
-    const index = candidates.indexOf(block);
-    if (index >= 0) candidates.splice(index, 1);
-    if (candidates.length === 0) callsByName.delete(nameKey);
+  };
+  const nextCallByName = (name: string): ConversationBlock | undefined => {
+    const queue = callsByName.get(name.toLowerCase());
+    if (!queue) return undefined;
+    while (queue.next < queue.blocks.length && queue.blocks[queue.next]?.toolStatus !== "pending") queue.next++;
+    return queue.blocks[queue.next];
   };
 
   for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
@@ -368,7 +370,7 @@ export function formatConversationMessages(
       const direct = result.toolCallId ? callsById.get(result.toolCallId) : undefined;
       let match = direct;
       if (!match && result.toolName) {
-        match = callsByName.get(result.toolName.toLowerCase())?.[0];
+        match = nextCallByName(result.toolName);
       }
       if (match) {
         applyToolResult(match, result, maxToolResultChars);