display-pending-tool-call (squashed)

Author: frenchie4111

src/main/hooks.ts

@@ -18,7 +18,12 @@ import { log } from './debug'
 const STATUS_DIR = '/tmp/harness-status'
 const HARNESS_HOOK_MARKER = '__claude_harness__'
 // Bump this when the hook format changes to force reinstallation
-const HARNESS_HOOK_VERSION = 7
+const HARNESS_HOOK_VERSION = 8
+
+export interface PendingTool {
+  name: string
+  input: Record<string, unknown>
+}
 
 // Emit a bash command that appends one NDJSON line per event to the
 // terminal's log file at /tmp/harness-status/<id>.ndjson. The line wraps
@@ -142,18 +147,49 @@ interface HookEvent {
   payload: Record<string, unknown> | null
 }
 
-function deriveStatus(ev: HookEvent): PtyStatus | null {
+// Most recently seen PreToolUse tool info per terminal. Used as a fallback
+// source of `tool_name`/`tool_input` when a permission_prompt Notification
+// arrives without those fields embedded in its own payload.
+const lastPreTool = new Map<string, PendingTool>()
+
+interface StatusUpdate {
+  status: PtyStatus
+  pendingTool: PendingTool | null
+}
+
+function readPendingTool(p: Record<string, unknown> | null): PendingTool | null {
+  if (!p) return null
+  const name = p.tool_name
+  if (typeof name !== 'string' || !name) return null
+  const rawInput = p.tool_input
+  const input =
+    rawInput && typeof rawInput === 'object' && !Array.isArray(rawInput)
+      ? (rawInput as Record<string, unknown>)
+      : {}
+  return { name, input }
+}
+
+function deriveStatus(terminalId: string, ev: HookEvent): StatusUpdate | null {
   switch (ev.event) {
+    case 'PreToolUse': {
+      const tool = readPendingTool(ev.payload)
+      if (tool) lastPreTool.set(terminalId, tool)
+      return { status: 'processing', pendingTool: null }
+    }
     case 'UserPromptSubmit':
-    case 'PreToolUse':
     case 'PostToolUse':
-      return 'processing'
+      return { status: 'processing', pendingTool: null }
     case 'Stop':
-      return 'waiting'
+      return { status: 'waiting', pendingTool: null }
     case 'Notification': {
-      const t = (ev.payload as Record<string, unknown> | null)?.notification_type
-      if (t === 'permission_prompt' || t === 'elicitation_dialog') return 'needs-approval'
-      if (t === 'idle_prompt') return 'waiting'
+      const p = ev.payload as Record<string, unknown> | null
+      const t = p?.notification_type
+      if (t === 'permission_prompt' || t === 'elicitation_dialog') {
+        const fromNotification = readPendingTool(p)
+        const pendingTool = fromNotification ?? lastPreTool.get(terminalId) ?? null
+        return { status: 'needs-approval', pendingTool }
+      }
+      if (t === 'idle_prompt') return { status: 'waiting', pendingTool: null }
       return null
     }
     default:
@@ -207,9 +243,14 @@ function tailLog(terminalId: string, win: BrowserWindow): void {
         continue
       }
       log('hooks', `event terminal=${terminalId} event=${ev.event}`)
-      const status = deriveStatus(ev)
-      if (status) {
-        win.webContents.send('terminal:status', terminalId, status)
+      const update = deriveStatus(terminalId, ev)
+      if (update) {
+        win.webContents.send(
+          'terminal:status',
+          terminalId,
+          update.status,
+          update.pendingTool
+        )
       }
     }
   } finally {
@@ -246,6 +287,7 @@ export function watchStatusDir(
 export function cleanupTerminalLog(terminalId: string): void {
   offsets.delete(terminalId)
   residual.delete(terminalId)
+  lastPreTool.delete(terminalId)
   try {
     unlinkSync(join(STATUS_DIR, `${terminalId}.ndjson`))
   } catch {

src/main/pty-manager.ts

@@ -50,7 +50,7 @@ export class PtyManager {
       log('pty', `spawn failed id=${id}`, err instanceof Error ? err.message : err)
       const msg = `\r\n\x1b[31mFailed to spawn "${shell}": ${err instanceof Error ? err.message : err}\x1b[0m\r\n`
       window.webContents.send('terminal:data', id, msg)
-      window.webContents.send('terminal:status', id, 'idle')
+      window.webContents.send('terminal:status', id, 'idle', null)
       return
     }
 
@@ -72,7 +72,7 @@ export class PtyManager {
       log('pty', `exit id=${id} code=${exitCode}`)
       const win = BrowserWindow.fromId(instance.windowId)
       if (win && !win.isDestroyed()) {
-        win.webContents.send('terminal:status', id, 'idle')
+        win.webContents.send('terminal:status', id, 'idle', null)
         win.webContents.send('terminal:exit', id, exitCode)
       }
       this.ptys.delete(id)

src/preload/index.ts

@@ -1,6 +1,14 @@
 import { contextBridge, ipcRenderer, webUtils } from 'electron'
 
-type StatusCallback = (id: string, status: string) => void
+interface PendingToolShape {
+  name: string
+  input: Record<string, unknown>
+}
+type StatusCallback = (
+  id: string,
+  status: string,
+  pendingTool: PendingToolShape | null
+) => void
 type DataCallback = (id: string, data: string) => void
 type ExitCallback = (id: string, exitCode: number) => void
 
@@ -277,8 +285,13 @@ contextBridge.exposeInMainWorld('api', {
     return () => ipcRenderer.removeListener('terminal:data', handler)
   },
   onStatusChange: (callback: StatusCallback) => {
-    const handler = (_event: Electron.IpcRendererEvent, id: string, status: string): void => {
-      callback(id, status)
+    const handler = (
+      _event: Electron.IpcRendererEvent,
+      id: string,
+      status: string,
+      pendingTool?: PendingToolShape | null
+    ): void => {
+      callback(id, status, pendingTool ?? null)
     }
     ipcRenderer.on('terminal:status', handler)
     return () => ipcRenderer.removeListener('terminal:status', handler)

src/renderer/App.tsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useCallback, useRef, useMemo } from 'react'
-import type { Worktree, TerminalTab, PtyStatus, PRStatus, QuestStep, WorkspacePane, PendingWorktree, UpdaterStatus } from './types'
+import type { Worktree, TerminalTab, PtyStatus, PendingTool, PRStatus, QuestStep, WorkspacePane, PendingWorktree, UpdaterStatus } from './types'
 import type { Action } from './hotkeys'
 import { resolveHotkeys } from './hotkeys'
 import { HotkeysProvider } from './components/Tooltip'
@@ -73,6 +73,7 @@ export default function App(): JSX.Element {
     return out
   }, [panes, activePaneId])
   const [statuses, setStatuses] = useState<Record<string, PtyStatus>>({})
+  const [pendingTools, setPendingTools] = useState<Record<string, PendingTool | null>>({})
   const [prStatuses, setPrStatuses] = useState<Record<string, PRStatus | null>>({})
   const [mergedPaths, setMergedPaths] = useState<Record<string, boolean>>({})
   const [prLoading, setPrLoading] = useState(false)
@@ -534,9 +535,14 @@ const setQuestStep = useCallback((next: QuestStep) => {
 
   // Listen for status changes from main process
   useEffect(() => {
-    const cleanup = window.api.onStatusChange((id, status) => {
+    const cleanup = window.api.onStatusChange((id, status, pendingTool) => {
       console.log(`[status] received: id=${id} status=${status}`)
       setStatuses((prev) => ({ ...prev, [id]: status as PtyStatus }))
+      setPendingTools((prev) => {
+        const next = status === 'needs-approval' ? pendingTool : null
+        if (prev[id] === next) return prev
+        return { ...prev, [id]: next }
+      })
       const wtPath = terminalToWorktree(id)
       if (wtPath) {
         markActive(wtPath)
@@ -1428,19 +1434,23 @@ const setQuestStep = useCallback((next: QuestStep) => {
 
   // Compute aggregate status per worktree (worst status wins)
   const worktreeStatuses: Record<string, PtyStatus> = {}
+  const worktreePendingTools: Record<string, PendingTool | null> = {}
   for (const wt of worktrees) {
     const tabs = terminalTabs[wt.path] || []
     let worstStatus: PtyStatus = 'idle'
+    let pending: PendingTool | null = null
     for (const tab of tabs) {
       const s = statuses[tab.id]
       if (s === 'needs-approval') {
         worstStatus = 'needs-approval'
+        pending = pendingTools[tab.id] || null
         break
       }
       if (s === 'waiting' && worstStatus !== 'needs-approval') worstStatus = 'waiting'
       if (s === 'processing' && worstStatus === 'idle') worstStatus = 'processing'
     }
     worktreeStatuses[wt.path] = worstStatus
+    worktreePendingTools[wt.path] = pending
   }
 
   // Record activity-log transitions whenever a worktree's effective state changes.
@@ -1596,6 +1606,7 @@ const setQuestStep = useCallback((next: QuestStep) => {
             pendingWorktrees={pendingWorktrees}
             activeWorktreeId={activeWorktreeId}
             statuses={worktreeStatuses}
+            pendingTools={worktreePendingTools}
             prStatuses={prStatuses}
             mergedPaths={mergedPaths}
             prLoading={prLoading}
@@ -1704,6 +1715,7 @@ const setQuestStep = useCallback((next: QuestStep) => {
           <CommandCenter
             worktrees={worktrees}
             worktreeStatuses={worktreeStatuses}
+            worktreePendingTools={worktreePendingTools}
             prStatuses={prStatuses}
             mergedPaths={mergedPaths}
             lastActive={lastActive}

src/renderer/components/CommandCenter.tsx

@@ -3,6 +3,7 @@ import { X, GitPullRequest, ChevronDown, ChevronRight, Layers, Rows3 } from 'luc
 import type {
   Worktree,
   PtyStatus,
+  PendingTool,
   PRStatus,
   TerminalTab,
   ActivityLog,
@@ -11,10 +12,12 @@ import type {
 import { eventsToSegments, STATE_COLOR } from './Activity'
 import { groupWorktrees, type GroupKey } from '../worktree-sort'
 import { RepoIcon } from './RepoIcon'
+import { formatPendingTool } from '../pending-tool'
 
 interface CommandCenterProps {
   worktrees: Worktree[]
   worktreeStatuses: Record<string, PtyStatus>
+  worktreePendingTools: Record<string, PendingTool | null>
   prStatuses: Record<string, PRStatus | null>
   mergedPaths: Record<string, boolean>
   lastActive: Record<string, number>
@@ -85,6 +88,7 @@ function relTime(ms: number | undefined): string {
 export function CommandCenter({
   worktrees,
   worktreeStatuses,
+  worktreePendingTools,
   prStatuses,
   mergedPaths,
   lastActive,
@@ -417,6 +421,14 @@ export function CommandCenter({
                                   {wt.branch}
                                 </span>
                               </div>
+                              {display === 'needs-approval' && worktreePendingTools[wt.path] && (
+                                <div className="flex items-center gap-1.5 min-w-0 text-[11px] text-danger">
+                                  <span className="font-semibold shrink-0">Waiting on:</span>
+                                  <span className="truncate font-mono">
+                                    {formatPendingTool(worktreePendingTools[wt.path] as PendingTool)}
+                                  </span>
+                                </div>
+                              )}
                               <div className="flex items-center gap-2 min-w-0 text-[11px]">
                                 <span
                                   className={`w-2 h-2 rounded-full shrink-0 ${STATUS_DOT[display]}`}

src/renderer/components/Sidebar.tsx

@@ -1,7 +1,7 @@
 import { useState, useCallback, useMemo } from 'react'
 import { ChevronDown, ChevronRight, Plus, RefreshCw, FolderOpen, Loader2, Settings as SettingsIcon, Sparkles, BarChart3, Trash2, LayoutGrid, X, Layers, Rows3, AlertCircle } from 'lucide-react'
 import { Tooltip } from './Tooltip'
-import type { Worktree, PtyStatus, PRStatus, PendingWorktree } from '../types'
+import type { Worktree, PtyStatus, PendingTool, PRStatus, PendingWorktree } from '../types'
 import type { GroupKey } from '../worktree-sort'
 import { groupWorktrees } from '../worktree-sort'
 import { WorktreeTab } from './WorktreeTab'
@@ -12,6 +12,7 @@ interface SidebarProps {
   pendingWorktrees: PendingWorktree[]
   activeWorktreeId: string | null
   statuses: Record<string, PtyStatus>
+  pendingTools: Record<string, PendingTool | null>
   prStatuses: Record<string, PRStatus | null>
   mergedPaths?: Record<string, boolean>
   prLoading: boolean
@@ -46,6 +47,7 @@ export function Sidebar({
   pendingWorktrees,
   activeWorktreeId,
   statuses,
+  pendingTools,
   prStatuses,
   mergedPaths,
   prLoading,
@@ -245,6 +247,7 @@ export function Sidebar({
                   worktree={wt}
                   isActive={wt.path === activeWorktreeId}
                   status={statuses[wt.path] || 'idle'}
+                  pendingTool={pendingTools[wt.path] || null}
                   prStatus={prStatuses[wt.path]}
                   isMerged={group.key === 'merged'}
                   repoLabel={showRepoLabelsOnTabs ? repoLabelFor(wt.repoRoot) : undefined}

src/renderer/components/WorktreeTab.tsx

@@ -1,12 +1,14 @@
 import { GitPullRequest, RotateCw, Trash2 } from 'lucide-react'
-import type { Worktree, PtyStatus, PRStatus } from '../types'
+import type { Worktree, PtyStatus, PendingTool, PRStatus } from '../types'
 import { Tooltip } from './Tooltip'
 import { RepoIcon } from './RepoIcon'
+import { formatPendingTool } from '../pending-tool'
 
 interface WorktreeTabProps {
   worktree: Worktree
   isActive: boolean
   status: PtyStatus
+  pendingTool?: PendingTool | null
   prStatus?: PRStatus | null
   isMerged?: boolean
   /** When set, shows a small repo hint next to the branch name. Used in
@@ -47,8 +49,9 @@ const PR_STATE_COLOR: Record<string, string> = {
   closed: 'text-danger'
 }
 
-export function WorktreeTab({ worktree, isActive, status, prStatus, isMerged, repoLabel, onClick, onDelete, onContinue }: WorktreeTabProps): JSX.Element {
+export function WorktreeTab({ worktree, isActive, status, pendingTool, prStatus, isMerged, repoLabel, onClick, onDelete, onContinue }: WorktreeTabProps): JSX.Element {
   const displayStatus: PtyStatus | 'merged' = isMerged ? 'merged' : status
+  const showPendingTool = displayStatus === 'needs-approval' && pendingTool
   const canContinue = !!onContinue && (prStatus?.state === 'merged' || prStatus?.state === 'closed')
   // Priority: merged/closed state always wins, then merge conflict, then check
   // status, then PR state
@@ -97,18 +100,24 @@ export function WorktreeTab({ worktree, isActive, status, prStatus, isMerged, re
       )}
       <div className="min-w-0 flex-1">
         <div className="text-sm font-medium truncate">{worktree.branch}</div>
-        <div className="text-xs text-faint truncate">
-          {repoLabel ? (
-            <span className="inline-flex items-center gap-1">
-              <RepoIcon repoName={repoLabel} size={11} />
-              <span className="text-dim">{repoLabel}</span>
-              <span className="mx-0.5">·</span>
-              {worktree.path.split('/').pop()}
-            </span>
-          ) : (
-            worktree.path.split('/').slice(-2).join('/')
-          )}
-        </div>
+        {showPendingTool ? (
+          <div className="text-xs text-danger truncate font-mono" title={formatPendingTool(pendingTool!)}>
+            {formatPendingTool(pendingTool!)}
+          </div>
+        ) : (
+          <div className="text-xs text-faint truncate">
+            {repoLabel ? (
+              <span className="inline-flex items-center gap-1">
+                <RepoIcon repoName={repoLabel} size={11} />
+                <span className="text-dim">{repoLabel}</span>
+                <span className="mx-0.5">·</span>
+                {worktree.path.split('/').pop()}
+              </span>
+            ) : (
+              worktree.path.split('/').slice(-2).join('/')
+            )}
+          </div>
+        )}
       </div>
       {canContinue && (
         <Tooltip label="Continue on a new branch off main" side="left">