@pellux/goodvibes-tui 0.28.0 → 0.29.0

package/src/input/panel-integration-actions.ts

@@ -6,6 +6,10 @@ import { FileExplorerPanel } from '../panels/file-explorer-panel.ts';
 import { FilePreviewPanel } from '../panels/file-preview-panel.ts';
 import { SymbolOutlinePanel } from '../panels/symbol-outline-panel.ts';
 import { ApprovalPanel } from '../panels/approval-panel.ts';
+import { TasksPanel } from '../panels/tasks-panel.ts';
+import { OrchestrationPanel } from '../panels/orchestration-panel.ts';
+import { AgentInspectorPanel } from '../panels/agent-inspector-panel.ts';
+import { DiffPanel } from '../panels/diff-panel.ts';
 
 function ensurePreviewPanel(panelManager: PanelManager): FilePreviewPanel | null {
   const existing = panelManager.getPanel('preview');
@@ -24,7 +28,29 @@ function ensurePreviewPanel(panelManager: PanelManager): FilePreviewPanel | null
   return opened instanceof FilePreviewPanel ? opened : null;
 }
 
-function syncSymbolOutlineFromPreview(panelManager: PanelManager, previewPanel: FilePreviewPanel): void {
+// WO-133: shared by explorer's and preview's 'd' (diff) key — same
+// open/focus bridge as ensurePreviewPanel above.
+function ensureDiffPanel(panelManager: PanelManager): DiffPanel | null {
+  const existing = panelManager.getPanel('diff');
+  if (existing instanceof DiffPanel) {
+    const pane = panelManager.getPaneOf('diff');
+    panelManager.activateById('diff');
+    if (pane) panelManager.focusPane(pane);
+    return existing;
+  }
+  const targetPane: 'top' | 'bottom' = panelManager.isBottomPaneVisible()
+    ? (panelManager.getFocusedPane() === 'top' ? 'bottom' : 'top')
+    : 'bottom';
+  const opened = panelManager.open('diff', targetPane);
+  panelManager.show();
+  panelManager.focusPane(targetPane);
+  return opened instanceof DiffPanel ? opened : null;
+}
+
+// Exported so a future preview-reload action (e.g. an explicit "r" reload
+// key) can re-sync the outline against the same file without duplicating
+// this lookup — the panel-integration wiring for that key lands separately.
+export function syncSymbolOutlineFromPreview(panelManager: PanelManager, previewPanel: FilePreviewPanel): void {
   const symbols = panelManager.getPanel('symbols');
   const filePath = previewPanel.getCurrentFilePath();
   const source = previewPanel.getSource();
@@ -61,6 +87,44 @@ export function handlePanelIntegrationAction(
     return true;
   }
 
+  // WO-133: 'd' on the explorer diffs the currently focused file, and 'd' on
+  // the preview diffs whatever file is currently open — both against HEAD,
+  // both via the same DiffPanel.showFileDiffs entry point.
+  if (key === 'd' && activePanel instanceof FileExplorerPanel) {
+    const filePath = activePanel.getFocusedFilePath();
+    if (!filePath) return false;
+    const diffPanel = ensureDiffPanel(panelManager);
+    if (!diffPanel) return false;
+    void diffPanel.showFileDiffs([filePath], 'HEAD').catch((err) => {
+      logger.debug('explorer diff dispatch failed', { err });
+    });
+    return true;
+  }
+
+  if (key === 'd' && activePanel instanceof FilePreviewPanel) {
+    const filePath = activePanel.getCurrentFilePath();
+    if (!filePath) return false;
+    const diffPanel = ensureDiffPanel(panelManager);
+    if (!diffPanel) return false;
+    void diffPanel.showFileDiffs([filePath], 'HEAD').catch((err) => {
+      logger.debug('preview diff dispatch failed', { err });
+    });
+    return true;
+  }
+
+  // WO-133: 'r' on the preview reloads the open file from disk, then
+  // re-syncs the symbol outline against the refreshed content (WO-126's
+  // async tree-sitter loadFile via syncSymbolOutlineFromPreview above) once
+  // the reload actually settles.
+  if (key === 'r' && activePanel instanceof FilePreviewPanel) {
+    const reloaded = activePanel.consumePendingReload();
+    if (!reloaded) return false;
+    void reloaded.then(() => syncSymbolOutlineFromPreview(panelManager, activePanel)).catch((err) => {
+      logger.debug('preview reload dispatch failed', { err });
+    });
+    return true;
+  }
+
   if ((key === 'enter' || key === 'return') && activePanel instanceof SymbolOutlinePanel) {
     const location = activePanel.getSelectedLocation();
     if (!location) return false;
@@ -84,5 +148,47 @@ export function handlePanelIntegrationAction(
     return true;
   }
 
+  // WO-131: Enter on a Tasks row — agent-kind tasks jump straight to the Agent
+  // Inspector (which owns the deep per-agent timeline); everything else's
+  // advertised worktree follow-up is dispatched for real via ctx.executeCommand
+  // instead of being printed as a static "/worktree task <task-id>" signpost.
+  // w dispatches the task-family posture review the header line advertises.
+  if ((key === 'enter' || key === 'return' || key === 'w') && activePanel instanceof TasksPanel) {
+    const followUp = activePanel.consumePendingFollowUp();
+    if (!followUp) return false;
+    if (followUp.kind === 'agent-jump') {
+      const inspector = panelManager.open('inspector');
+      if (!(inspector instanceof AgentInspectorPanel)) return false;
+      inspector.inspectAgent(followUp.agentId);
+      return true;
+    }
+    if (!commandContext?.executeCommand) return false;
+    if (followUp.kind === 'teamwork-review') {
+      void commandContext.executeCommand('teamwork', ['review']).catch((err) => {
+        logger.debug('tasks panel teamwork review dispatch failed', { err });
+      });
+      return true;
+    }
+    void commandContext.executeCommand('worktree', ['task', followUp.taskId]).catch((err) => {
+      logger.debug('tasks panel worktree review dispatch failed', { err });
+    });
+    return true;
+  }
+
+  // WO-131: Enter on a node-focused Orchestration row jumps to the Agent
+  // Inspector (agent-backed nodes) or the Tasks panel (task-backed nodes).
+  if ((key === 'enter' || key === 'return') && activePanel instanceof OrchestrationPanel) {
+    const jump = activePanel.consumePendingNodeJump();
+    if (!jump) return false;
+    if (jump.kind === 'agent-jump') {
+      const inspector = panelManager.open('inspector');
+      if (!(inspector instanceof AgentInspectorPanel)) return false;
+      inspector.inspectAgent(jump.id);
+      return true;
+    }
+    panelManager.open('tasks');
+    return true;
+  }
+
   return false;
 }

package/src/main.ts

@@ -36,6 +36,7 @@ import {
   checkRecoveryFile,
   deleteRecoveryFile,
   loadRecoveryConversation,
+  readLastSessionPointer,
   writeRecoveryFile,
 } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
@@ -58,7 +59,7 @@ import { formatUserFacingErrorLine } from './core/format-user-error.ts';
 import { wireStreamEventMetrics, type StreamMetrics, type WireStreamEventMetricsResult } from './core/stream-event-wiring.ts';
 import { wireTurnEventHandlers } from './core/turn-event-wiring.ts';
 import { buildContextStatusHint } from './renderer/context-status-hint.ts';
-import { evaluateSessionMaintenance } from './panels/session-maintenance.ts';
+import { evaluateSessionMaintenance } from '@/runtime/index.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h'; const ALT_SCREEN_EXIT  = '\x1b[?1049l';
 const MOUSE_ENABLE     = '\x1b[?1000h\x1b[?1002h\x1b[?1006h'; const MOUSE_DISABLE    = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
@@ -428,6 +429,7 @@ async function main() {
     model: runtime.model,
     provider: runtime.provider,
     toolCount,
+    lastSessionId: readLastSessionPointer({ workingDirectory: workingDir, homeDirectory, surfaceRoot: 'tui' }) ?? undefined,
   };
 
   const render = () => {
@@ -490,6 +492,8 @@ async function main() {
       provider: runtime.provider,
       contextWindow,
       contextStatusHint,
+      // Compact footer posture on short terminals so the shell stays usable.
+      compact: height < 30,
       // behavior.autoCompactThreshold is stored as a percent integer (e.g. 80);
       // the meter expects a fraction [0..1]. Clamp to [0,1] to guard nonsense values.
       compactThreshold: Math.min(1, Math.max(0, (configManager.get('behavior.autoCompactThreshold') as number) / 100)),

package/src/panels/agent-inspector-panel.ts

@@ -1,6 +1,7 @@
 // ---------------------------------------------------------------------------
 // AgentInspectorPanel — detailed view of a specific agent's messages and tool
-// calls, with expandable tool call details, scroll, and agent selector.
+// calls. WO-110: merged agent-logs-panel.ts in (pause/filter/follow/auto-
+// select/stall-fix) on top of this panel's correct JSONL parser + cancel.
 // ---------------------------------------------------------------------------
 
 import { join } from 'node:path';
@@ -10,6 +11,8 @@ import { createEmptyLine } from '../types/grid.ts';
 import { BasePanel } from './base-panel.ts';
 import type { AgentManager, AgentRecord } from '@pellux/goodvibes-sdk/platform/tools';
 import type { AgentMessageBus } from '@pellux/goodvibes-sdk/platform/agents';
+import type { AgentEvent } from '@/runtime/index.ts';
+import type { UiEventFeed } from '../runtime/ui-events.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import {
   buildEmptyState,
@@ -20,22 +23,29 @@ import {
   buildPanelWorkspace,
   resolveScrollablePanelSection,
   DEFAULT_PANEL_PALETTE,
+  extendPalette,
 } from './polish.ts';
 import {
   type ConfirmState,
   handleConfirmInput,
 } from './confirm-state.ts';
 import { truncateDisplay } from '../utils/terminal-width.ts';
+import { abbreviateCount } from '../utils/format-number.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import {
   type AgentDisplayRow as DisplayRow,
   type AgentInspectorEntryKind as EntryKind,
   type AgentTimelineEntry as TimelineEntry,
+  type AgentInspectorFilterType as FilterType,
   agentKindStyle,
-  agentStatusColor,
   formatAgentDuration as formatMs,
   formatAgentTime as shortTime,
   jsonlToTimeline,
+  matchesInspectorFilter,
+  buildWrfcCostSegments,
+  subscribeAgentActivity,
+  AGENT_INSPECTOR_FILTER_CYCLE,
+  AGENT_INSPECTOR_FILTER_LABELS,
   AGENT_TERMINAL_STATUSES,
   AGENT_STALL_THRESHOLD_MS,
 } from './agent-inspector-shared.ts';
@@ -47,12 +57,12 @@ import {
 const REFRESH_MS = 500;
 const MAX_JSONL_ENTRIES = 200;
 
-const COLOR = {
-  // Header / chrome
-  headerBg:    '#1a1a2e',
-  headerFg:    '#ffffff',
+// Domain accents only — base chrome (header/headerBg/label/value/dim/selectBg/
+// warn) comes from DEFAULT_PANEL_PALETTE via extendPalette; the title band is
+// the one canonical UI_TONES.bg.title, not a per-panel override.
+const COLOR = extendPalette(DEFAULT_PANEL_PALETTE, {
+  // Agent selector chrome
   statusBar:   '#222233',
-  statusFg:    '#aaaaaa',
   separator:   '#333355',
 
   // Timeline roles
@@ -64,22 +74,10 @@ const COLOR = {
   system:      '#888888',   // dim grey
   timestamp:   '#555577',
 
-  // Status badges
-  pending:     '#ffcc44',
-  running:     '#44ffcc',
-  completed:   '#44ff88',
-  failed:      '#ff4444',
-  cancelled:   '#888888',
-
   // Selector / labels
-  label:       '#8888bb',
-  value:       '#ccccdd',
   selected:    '#ffee88',
-  dimmed:      '#555566',
   expandHint:  '#445566',
-  stalled:     '#f59e0b',   // amber — stalled-agent warning
-  cursorBg:    '#1a2233',   // timeline cursor row background
-} as const;
+} as const);
 
 // ---------------------------------------------------------------------------
 // AgentInspectorPanel
@@ -93,6 +91,8 @@ export interface AgentInspectorPanelDeps {
   readonly workingDirectory: string;
   /** Cancel the agent by id. Uses the same orphan-free path as WRFC. Returns true if cancelled. */
   readonly cancelAgent: (agentId: string) => boolean;
+  /** Agent lifecycle feed; drives auto-select-on-spawn + event-driven stall detection (WO-110). */
+  readonly agentEvents: UiEventFeed<AgentEvent>;
   /**
    * Request a compositor repaint. The 500ms refresh timer and other async
    * update paths call this (via markDirty) so live agent output is painted
@@ -129,8 +129,19 @@ export class AgentInspectorPanel extends BasePanel {
   /** True while this panel is the active view — gates async repaint requests. */
   private _active = false;
 
+  // ---- ported from agent-logs (WO-110 merge) -------------------------------
+  /** Freezes the 500ms JSONL refresh tick while true; manual navigation still works. */
+  private paused = false;
+  /** When true, cursor snaps to the newest row on every render (tail -f style). */
+  private autoFollow = true;
+  private filter: FilterType = 'all';
+  /** Per-agent last-activity timestamp derived from AGENT_* events — stall detection uses this, not startedAt. */
+  private readonly lastActivityByAgent = new Map<string, number>();
+  private unsubs: Array<() => void> = [];
+
   constructor(private readonly deps: AgentInspectorPanelDeps) {
     super('inspector', 'Inspector', 'I', 'agent');
+    this._subscribeAgentEvents();
   }
 
   // -------------------------------------------------------------------------
@@ -161,6 +172,7 @@ export class AgentInspectorPanel extends BasePanel {
     this.scrollOffset = 0;
     this.cursorIndex = 0;
     this.timeline = [];
+    this.autoFollow = true;
     this.markDirty();
     this._refreshTimeline().catch((err) => { logger.debug('agent inspector timeline refresh failed', { err }); });
   }
@@ -182,6 +194,8 @@ export class AgentInspectorPanel extends BasePanel {
 
   override onDestroy(): void {
     this._stopRefresh();
+    for (const unsub of this.unsubs) unsub();
+    this.unsubs = [];
     super.onDestroy();
   }
 
@@ -220,6 +234,10 @@ export class AgentInspectorPanel extends BasePanel {
       case 'return':   this._toggleExpand();          return true;
       case 'tab':      this._nextAgent();             return true;
       case 'c':        this._beginCancelConfirm();    return true;
+      case ' ':        this._togglePause();           return true;
+      case 'f':        this._cycleFilter();           return true;
+      case 'g':        this._jumpTop();               return true;
+      case 'G':        this._jumpBottom();            return true;
       default:         return false;
     }
   }
@@ -243,6 +261,10 @@ export class AgentInspectorPanel extends BasePanel {
         [String(agents.length), DEFAULT_PANEL_PALETTE.value],
         ['   Selected ', DEFAULT_PANEL_PALETTE.label],
         [this.selectedAgentId ? this.selectedAgentId.slice(-8) : 'none', this.selectedAgentId ? DEFAULT_PANEL_PALETTE.info : DEFAULT_PANEL_PALETTE.dim],
+        ['   Filter ', DEFAULT_PANEL_PALETTE.label],
+        [AGENT_INSPECTOR_FILTER_LABELS[this.filter], DEFAULT_PANEL_PALETTE.info],
+        ['   Mode ', DEFAULT_PANEL_PALETTE.label],
+        [this.paused ? 'paused' : this.autoFollow ? 'auto-follow' : 'manual', this.paused ? DEFAULT_PANEL_PALETTE.warn : this.autoFollow ? DEFAULT_PANEL_PALETTE.good : DEFAULT_PANEL_PALETTE.dim],
       ]),
     ];
 
@@ -275,10 +297,12 @@ export class AgentInspectorPanel extends BasePanel {
     }
 
     summaryLines.push(this._renderAgentInfoSummary(width, rec));
+    const wrfcCostLine = this._renderWrfcCostLine(width, rec);
+    if (wrfcCostLine) summaryLines.push(wrfcCostLine);
     const now = Date.now();
     const isStalled = this._isAgentStalled(rec, now);
     if (isStalled) {
-      summaryLines.push(buildPanelLine(width, [['  STALLED', COLOR.stalled], [' — no activity for 5+ minutes', DEFAULT_PANEL_PALETTE.dim]]));
+      summaryLines.push(buildPanelLine(width, [['  STALLED', COLOR.warn], [' — no activity for 5+ minutes', DEFAULT_PANEL_PALETTE.dim]]));
     }
     const allRows = this._getCachedRows();
     if (allRows.length === 0) {
@@ -303,13 +327,23 @@ export class AgentInspectorPanel extends BasePanel {
           },
         ],
         footerLines: [
-          buildPanelLine(width, [[' Tab', DEFAULT_PANEL_PALETTE.info], [' cycle agents', DEFAULT_PANEL_PALETTE.dim], ['   Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim], ['   Enter', DEFAULT_PANEL_PALETTE.info], [' expand', DEFAULT_PANEL_PALETTE.dim]]),
+          buildPanelLine(width, [
+            [' Tab', DEFAULT_PANEL_PALETTE.info], [' cycle agents', DEFAULT_PANEL_PALETTE.dim],
+            ['   Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim],
+            ['   Enter', DEFAULT_PANEL_PALETTE.info], [' expand', DEFAULT_PANEL_PALETTE.dim],
+            ['   Space', DEFAULT_PANEL_PALETTE.info], [this.paused ? ' resume' : ' pause', DEFAULT_PANEL_PALETTE.dim],
+            ['   f', DEFAULT_PANEL_PALETTE.info], [' filter', DEFAULT_PANEL_PALETTE.dim],
+          ]),
         ],
         palette: DEFAULT_PANEL_PALETTE,
       });
     }
 
-    this.cursorIndex = Math.max(0, Math.min(this.cursorIndex, allRows.length - 1));
+    if (this.autoFollow) {
+      this.cursorIndex = allRows.length - 1;
+    } else {
+      this.cursorIndex = Math.max(0, Math.min(this.cursorIndex, allRows.length - 1));
+    }
     const selectedRec = this.selectedAgentId
       ? this.deps.agentManager.getStatus(this.selectedAgentId)
       : null;
@@ -340,6 +374,9 @@ export class AgentInspectorPanel extends BasePanel {
       ['   Tab', DEFAULT_PANEL_PALETTE.info], [' cycle agents', DEFAULT_PANEL_PALETTE.dim],
       ['   Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim],
       ['   Enter', DEFAULT_PANEL_PALETTE.info], [' expand', DEFAULT_PANEL_PALETTE.dim],
+      ['   Space', DEFAULT_PANEL_PALETTE.info], [this.paused ? ' resume' : ' pause', DEFAULT_PANEL_PALETTE.dim],
+      ['   f', DEFAULT_PANEL_PALETTE.info], [' filter', DEFAULT_PANEL_PALETTE.dim],
+      ['   g/G', DEFAULT_PANEL_PALETTE.info], [this.autoFollow ? ' top/follow' : ' top/bottom', DEFAULT_PANEL_PALETTE.dim],
       ['   c', cancelHintFg], [cancellable ? ' cancel' : ' cancel (n/a)', DEFAULT_PANEL_PALETTE.dim],
     ]);
 
@@ -381,17 +418,17 @@ export class AgentInspectorPanel extends BasePanel {
   ): Line {
     if (agents.length === 0) {
       return buildStyledPanelLine(width, [
-        { text: ' (no agents)', fg: COLOR.dimmed, bg: COLOR.statusBar, dim: true },
+        { text: ' (no agents)', fg: COLOR.dim, bg: COLOR.statusBar, dim: true },
       ]);
     }
-    const segments: StyledPanelSegment[] = [{ text: ' ', fg: COLOR.statusFg, bg: COLOR.statusBar }];
+    const segments: StyledPanelSegment[] = [{ text: ' ', fg: COLOR.dim, bg: COLOR.statusBar }];
     for (const agent of agents) {
       const isSelected = agent.id === this.selectedAgentId;
       const shortId = agent.id.slice(-8);
       const badge = ` ${shortId} `;
       segments.push({
         text: badge,
-        fg: isSelected ? COLOR.selected : COLOR.dimmed,
+        fg: isSelected ? COLOR.selected : COLOR.dim,
         bg: COLOR.statusBar,
         bold: isSelected,
       });
@@ -422,6 +459,12 @@ export class AgentInspectorPanel extends BasePanel {
     ]);
   }
 
+  /** WRFC badge + per-agent tokens/cost (WO-110); null when neither applies. */
+  private _renderWrfcCostLine(width: number, rec: AgentRecord): Line | null {
+    const segments = buildWrfcCostSegments(rec, DEFAULT_PANEL_PALETTE, abbreviateCount);
+    return segments ? buildPanelLine(width, segments) : null;
+  }
+
   // -------------------------------------------------------------------------
   // Timeline row rendering
   // -------------------------------------------------------------------------
@@ -431,7 +474,7 @@ export class AgentInspectorPanel extends BasePanel {
     row: DisplayRow,
     isCursor: boolean,
   ): Line {
-    const bg = isCursor ? COLOR.cursorBg : '';
+    const bg = isCursor ? COLOR.selectBg : '';
     const ts = shortTime(row.timestamp);
     const { fg, prefix } = agentKindStyle(row.kind, COLOR);
     const hint = row.hasDetail ? (row.expanded ? ' ▾' : ' ▸') : '';
@@ -456,10 +499,7 @@ export class AgentInspectorPanel extends BasePanel {
   // Private — data
   // -------------------------------------------------------------------------
 
-  /**
-   * Build the flat list of DisplayRow items from timeline + expanded detail
-   * sub-rows. This is what the renderer walks.
-   */
+  /** Flat DisplayRow list from timeline + expanded detail sub-rows, filtered by `this.filter`. */
   private _buildVisibleRows(): DisplayRow[] {
     const rows: DisplayRow[] = [];
 
@@ -481,10 +521,10 @@ export class AgentInspectorPanel extends BasePanel {
 
     merged.sort((a, b) => a.timestamp - b.timestamp);
 
-    // Deduplicate: bus messages that already appear in JSONL will have
-    // approximate timestamps. We just show all — bus msgs tend to have
-    // unique content.
+    // Entries are filtered against `this.filter` here (WO-110).
     for (const entry of merged) {
+      if (!matchesInspectorFilter(entry.kind, this.filter)) continue;
+
       rows.push({
         kind: entry.kind,
         timestamp: entry.timestamp,
@@ -614,6 +654,9 @@ export class AgentInspectorPanel extends BasePanel {
   private _startRefresh(): void {
     if (this.refreshTimerId) return;
     this.refreshTimerId = this.registerTimer(setInterval(() => {
+      // WO-110: Space pause/resume freezes the JSONL tail (ported from
+      // agent-logs); manual navigation and agent switching still work.
+      if (this.paused) return;
       this._refreshTimeline().catch((err) => { logger.debug('agent inspector timeline refresh tick failed', { err }); });
     }, REFRESH_MS));
   }
@@ -625,6 +668,51 @@ export class AgentInspectorPanel extends BasePanel {
     }
   }
 
+  // -------------------------------------------------------------------------
+  // Private — agent lifecycle event subscriptions (WO-110 merge)
+  // -------------------------------------------------------------------------
+
+  /** Auto-select-on-spawn + real event-driven last-activity (stall fix), ported from agent-logs. */
+  private _subscribeAgentEvents(): void {
+    this.unsubs.push(...subscribeAgentActivity(this.deps.agentEvents, {
+      onActivity: (agentId) => {
+        this.lastActivityByAgent.set(agentId, Date.now());
+        if (!this.paused && agentId === this.selectedAgentId) this.markDirty();
+      },
+      onSpawn: (agentId) => {
+        const current = this.selectedAgentId ? this.deps.agentManager.getStatus(this.selectedAgentId) : null;
+        if (!current || AGENT_TERMINAL_STATUSES.has(current.status)) this.inspectAgent(agentId);
+      },
+      onTerminal: (agentId) => {
+        this.lastActivityByAgent.delete(agentId);
+        this.markDirty();
+      },
+    }));
+  }
+
+  private _togglePause(): void {
+    this.paused = !this.paused;
+    this.markDirty();
+  }
+
+  private _cycleFilter(): void {
+    const idx = AGENT_INSPECTOR_FILTER_CYCLE.indexOf(this.filter);
+    this.filter = AGENT_INSPECTOR_FILTER_CYCLE[(idx + 1) % AGENT_INSPECTOR_FILTER_CYCLE.length]!;
+    this.cursorIndex = 0;
+    this.markDirty();
+  }
+
+  private _jumpTop(): void {
+    this.autoFollow = false;
+    this.cursorIndex = 0;
+    this.markDirty();
+  }
+
+  private _jumpBottom(): void {
+    this.autoFollow = true;
+    this.markDirty();
+  }
+
   // -------------------------------------------------------------------------
   // Private — navigation
   // -------------------------------------------------------------------------
@@ -679,10 +767,11 @@ export class AgentInspectorPanel extends BasePanel {
     this.markDirty();
   }
 
-  /** Returns whether an agent is considered stalled (non-terminal, running past threshold). */
+  /** Stalled = non-terminal + no AGENT_* activity for AGENT_STALL_THRESHOLD_MS (not just elapsed-since-start). */
   private _isAgentStalled(rec: AgentRecord, now: number): boolean {
     if (AGENT_TERMINAL_STATUSES.has(rec.status)) return false;
-    return (now - rec.startedAt) >= AGENT_STALL_THRESHOLD_MS;
+    const lastActivity = this.lastActivityByAgent.get(rec.id) ?? rec.startedAt;
+    return (now - lastActivity) >= AGENT_STALL_THRESHOLD_MS;
   }
 
   /**

package/src/panels/agent-inspector-shared.ts

@@ -1,4 +1,7 @@
 import { formatDuration } from '../utils/format-duration.ts';
+import { calcSessionCost } from '../export/cost-utils.ts';
+import type { AgentEvent } from '@/runtime/index.ts';
+import type { UiEventFeed } from '../runtime/ui-events.ts';
 
 export type AgentInspectorEntryKind = 'user' | 'assistant' | 'tool_call' | 'tool_result' | 'session' | 'error';
 
@@ -121,3 +124,144 @@ export function agentKindStyle(kind: AgentInspectorEntryKind, colors: Record<str
     default: return { fg: colors.dimmed ?? colors.system, prefix: '[?]        ' };
   }
 }
+
+// ---------------------------------------------------------------------------
+// Inspector filter modes (ported from the merged agent-logs console — WO-110)
+// ---------------------------------------------------------------------------
+
+export type AgentInspectorFilterType = 'all' | 'assistant' | 'tool' | 'error';
+
+export const AGENT_INSPECTOR_FILTER_CYCLE: readonly AgentInspectorFilterType[] = ['all', 'assistant', 'tool', 'error'];
+
+export const AGENT_INSPECTOR_FILTER_LABELS: Record<AgentInspectorFilterType, string> = {
+  all: 'All',
+  assistant: 'Assistant',
+  tool: 'Tool',
+  error: 'Error',
+};
+
+/**
+ * True when a timeline entry's kind should be visible under the given filter.
+ * Mapped against the REAL row kinds jsonlToTimeline() produces (tool_call /
+ * tool_result), not the legacy agent-logs-shared schema (assistant/tool_call/
+ * tool_result vs. the writer-emitted tool_execution/llm_response) that never
+ * matched anything.
+ */
+export function matchesInspectorFilter(kind: AgentInspectorEntryKind, filter: AgentInspectorFilterType): boolean {
+  switch (filter) {
+    case 'all': return true;
+    case 'assistant': return kind === 'assistant';
+    case 'tool': return kind === 'tool_call' || kind === 'tool_result';
+    case 'error': return kind === 'error';
+    default: return true;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Per-agent cost/token summary (calcSessionCost, cost-utils.ts)
+// ---------------------------------------------------------------------------
+
+export function formatAgentCost(usd: number): string {
+  if (usd === 0) return '$0.00';
+  if (usd < 0.0001) return '<$0.0001';
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(3)}`;
+}
+
+export interface AgentUsageSummary {
+  readonly tokens: number;
+  readonly cost: number;
+}
+
+interface AgentUsageLike {
+  readonly usage?: {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+  } | null;
+  readonly model?: string | null;
+}
+
+/**
+ * Total token count + cost for an agent record's usage, or null when no usage
+ * data has landed yet (honest-UX: never fabricate a $0.00/0-token reading for
+ * an agent that simply hasn't reported usage).
+ */
+export function summarizeAgentUsage(rec: AgentUsageLike): AgentUsageSummary | null {
+  if (!rec.usage) return null;
+  const inputTokens = rec.usage.inputTokens + (rec.usage.cacheReadTokens ?? 0) + (rec.usage.cacheWriteTokens ?? 0);
+  const cost = calcSessionCost(
+    rec.usage.inputTokens,
+    rec.usage.outputTokens,
+    rec.usage.cacheReadTokens ?? 0,
+    rec.usage.cacheWriteTokens ?? 0,
+    rec.model ?? 'unknown',
+  );
+  return { tokens: inputTokens + rec.usage.outputTokens, cost };
+}
+
+// ---------------------------------------------------------------------------
+// WRFC badge segments (AgentRecord.wrfcId/wrfcRole)
+// ---------------------------------------------------------------------------
+
+interface WrfcLike {
+  readonly wrfcId?: string | null;
+  readonly wrfcRole?: string | null;
+}
+
+/** Segments for the WRFC chain badge + token/cost line, or null when neither applies. */
+export function buildWrfcCostSegments(
+  rec: WrfcLike & AgentUsageLike,
+  palette: { readonly label: string; readonly info: string },
+  formatTokens: (n: number) => string,
+): Array<[string, string]> | null {
+  const segments: Array<[string, string]> = [];
+  if (rec.wrfcId) {
+    segments.push([' WRFC ', palette.label]);
+    segments.push([`${rec.wrfcRole ?? 'agent'} · ${rec.wrfcId.slice(-8)}`, palette.info]);
+  }
+  const usage = summarizeAgentUsage(rec);
+  if (usage) {
+    segments.push([segments.length > 0 ? '   Tokens ' : ' Tokens ', palette.label]);
+    segments.push([formatTokens(usage.tokens), palette.info]);
+    segments.push(['   Cost ', palette.label]);
+    segments.push([formatAgentCost(usage.cost), palette.info]);
+  }
+  return segments.length > 0 ? segments : null;
+}
+
+// ---------------------------------------------------------------------------
+// Agent lifecycle event subscriptions (ported from agent-logs — WO-110)
+// ---------------------------------------------------------------------------
+
+export interface AgentActivityHooks {
+  /** Any AGENT_* activity event for this agent (running/progress/stream/awaiting/finalizing/spawning). */
+  readonly onActivity: (agentId: string) => void;
+  /** AGENT_SPAWNING only — used for auto-select-newest-agent. */
+  readonly onSpawn: (agentId: string) => void;
+  /** AGENT_COMPLETED/FAILED/CANCELLED. */
+  readonly onTerminal: (agentId: string) => void;
+}
+
+/** Wires the standard set of agent lifecycle listeners; returns their unsubscribe functions. */
+export function subscribeAgentActivity(agentEvents: UiEventFeed<AgentEvent>, hooks: AgentActivityHooks): Array<() => void> {
+  const unsubs: Array<() => void> = [];
+  const activityTypes = [
+    'AGENT_RUNNING', 'AGENT_PROGRESS', 'AGENT_STREAM_DELTA',
+    'AGENT_AWAITING_MESSAGE', 'AGENT_AWAITING_TOOL', 'AGENT_FINALIZING',
+  ] as const;
+  for (const type of activityTypes) {
+    unsubs.push(agentEvents.on(type, (payload: { agentId: string }) => hooks.onActivity(payload.agentId)));
+  }
+  unsubs.push(agentEvents.on('AGENT_SPAWNING', (payload) => {
+    hooks.onActivity(payload.agentId);
+    hooks.onSpawn(payload.agentId);
+  }));
+  unsubs.push(
+    agentEvents.on('AGENT_COMPLETED', (payload) => hooks.onTerminal(payload.agentId)),
+    agentEvents.on('AGENT_FAILED', (payload) => hooks.onTerminal(payload.agentId)),
+    agentEvents.on('AGENT_CANCELLED', (payload) => hooks.onTerminal(payload.agentId)),
+  );
+  return unsubs;
+}