@raidou/pi-notify 0.5.3 → 0.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 A notification extension for the [pi](https://github.com/earendil-works/pi-coding-agent) coding agent.
 
-`@raidou/pi-notify` fires a native desktop notification on idle, configured tool calls (e.g., `Tool call: ask_user`), and custom pi events (default: `permissions:ui_prompt`).
+`@raidou/pi-notify` fires a native desktop notification on idle, tool calls (optional, e.g. `Tool call: ask_user`), user-facing UI prompts (via pi's `ui_prompt_start`, e.g. permission approvals or `select`/`confirm`/`input` dialogs, requires pi >= 0.85.0), and custom pi events.
 
 ## Installation
 
@@ -25,12 +25,11 @@ All options live under the `piNotify` key in `~/.pi/agent/settings.json`. Everyt
 {
   "piNotify": {
     "enabled": true, // master on/off switch (default: true)
-    "notifyTools": ["ask_user", "ask_user_question"], // tools that trigger "Tool call" notifications
+    "notifyTools": [], // tools that trigger "Tool call" notifications (default: empty, i.e. no tool notifications)
     "tmuxSymbol": "🔔", // symbol appended to tmux window title (empty string to disable)
     "finished": true, // enable/disable "Idle" notification
     "events": {
-      "permissions:ui_prompt": "Permission prompt", // custom event channel -> notification message
-      "my:custom:event": "Custom event triggered", // add your own custom events
+      "my:custom:event": "Custom event triggered", // custom event channel -> notification message
       "other:event": false, // set to false to disable a specific event
     },
     "finishedThrottleSecs": 0, // 0 = always notify; >0 = skip finished toasts for runs shorter than N seconds
@@ -42,11 +41,13 @@ All options live under the `piNotify` key in `~/.pi/agent/settings.json`. Everyt
 
 ## What triggers a notification
 
-| Event             | Source                                                      | Default body                                |
-| ----------------- | ----------------------------------------------------------- | ------------------------------------------- |
-| **Finished**      | `agent_settled` (pi idle, no active jobs)                   | `Idle`                                      |
-| **Tool calls**    | `tool_call` on tools in `notifyTools`                       | `Tool call: <toolName>`                     |
-| **Custom events** | Custom pi event channels (default: `permissions:ui_prompt`) | Customizable (default: `Permission prompt`) |
+| Event             | Source                                                                | Default body                      |
+| ----------------- | --------------------------------------------------------------------- | --------------------------------- |
+| **Finished**      | `agent_settled` (pi idle, no active jobs)                             | `Idle`                            |
+| **Tool calls**    | `tool_call` on tools in `notifyTools` (default: none)                 | `Tool call: <toolName>`           |
+| **UI prompts**    | `ui_prompt_start` (requires pi >= 0.85.0)                             | `Waiting: <kind>[ — <title>]` |
+| **Custom events** | Custom pi event channels configured in `events`                       | Customizable                      |
+| **External API**  | `pi.events.emit('pi-notify:notify', 'message')` from other extensions | The emitted message               |
 
 ### Job tracking for background tasks
 
@@ -76,6 +77,8 @@ Columns: `SESSION_ID` (last 6 chars), `PID`, `STATE` (running/idle, color-coded)
 
 Keybindings:
 
+- `j`/`k` or `↑`/`↓` — move selection
+- `x` — kill (SIGTERM) the selected session
 - `o` — show/hide the SESSION_ID and PID columns
 - `r` — refresh
 - `q` or `esc` — close

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raidou/pi-notify",
-  "version": "0.5.3",
+  "version": "0.7.0",
   "description": "Desktop notification extension for the pi coding agent.",
   "keywords": [
     "pi",
@@ -34,16 +34,17 @@
     "test:unit": "vitest run"
   },
   "dependencies": {
-    "@earendil-works/pi-tui": "0.80.7",
     "emittery": "^2.0.0",
     "lodash-es": "^4.18.1",
     "node-notifier": "^10.0.1",
     "proper-lockfile": "^4.1.2"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.79.0"
+    "@earendil-works/pi-coding-agent": ">=0.85.0",
+    "@earendil-works/pi-tui": ">=0.85.0"
   },
   "devDependencies": {
+    "@earendil-works/pi-tui": "0.85.1",
     "@raidou/eslint-config-base": "^4.4.3",
     "@types/lodash-es": "^4.17.12",
     "@types/node": "^22.0.0",

package/src/config.ts

@@ -28,20 +28,8 @@ export interface ResolvedNotifyConfig {
   readonly tmuxSymbol: string
 }
 
-/**
- * Default tool names that trigger notifications.
- *
- * Note: These are built-in pi tool names. If pi renames these tools, the default should be updated.
- * Source: @earendil-works/pi-coding-agent
- */
-const DEFAULT_NOTIFY_TOOLS = ['ask_user', 'ask_user_question'] as const
-
 const DEFAULT_TMUX_SYMBOL = '🔔'
 
-const DEFAULT_EVENTS: NotifyEventsConfig = {
-  'permissions:ui_prompt': 'Permission prompt',
-}
-
 const SETTINGS_PATH = join(getAgentDir(), 'settings.json')
 
 function readRawConfig(): NotifyConfig {
@@ -59,11 +47,10 @@ function readRawConfig(): NotifyConfig {
 
 export function loadConfig(): ResolvedNotifyConfig {
   const cfg = readRawConfig()
-  const events = cfg.events ?? DEFAULT_EVENTS
   return {
     enabled: cfg.enabled ?? true,
-    notifyTools: new Set(cfg.notifyTools ?? DEFAULT_NOTIFY_TOOLS),
-    events,
+    notifyTools: new Set(cfg.notifyTools ?? []),
+    events: cfg.events ?? {},
     finished: cfg.finished ?? true,
     onlyNotifyWhenUnfocused: cfg.onlyNotifyWhenUnfocused ?? true,
     unfocusedActivityThresholdMs: Math.max(

package/src/dashboard/session-store.test.ts

@@ -171,10 +171,11 @@ describe('SessionStore', () => {
     )
     store.register(vi.fn())
 
-    expect(emitSpy).toHaveBeenCalledTimes(4)
+    expect(emitSpy).toHaveBeenCalledTimes(5)
     expect(emitSpy).toHaveBeenCalledWith('running', expect.any(Function))
     expect(emitSpy).toHaveBeenCalledWith('idle', expect.any(Function))
     expect(emitSpy).toHaveBeenCalledWith('tool', expect.any(Function))
+    expect(emitSpy).toHaveBeenCalledWith('ui_prompt', expect.any(Function))
     expect(emitSpy).toHaveBeenCalledWith('event', expect.any(Function))
     expect(piOnSpy).toHaveBeenCalledWith('session_start', expect.any(Function))
   })
@@ -347,19 +348,20 @@ describe('SessionStore', () => {
     nowSpy.mockRestore()
   })
 
-  it('does not update state on tool emission outside notifyTools', async () => {
+  it('updates state immediately on event emission', async () => {
     await updateState(() => ({ version: 2, sessions: {} }))
     const pi = makeFakePi()
     const jobTracker = {
       hasActiveJobs: false,
+      onStart: () => () => {},
       onEnd: () => () => {},
     } as unknown as JobTracker
     const tracker = new StateTracker(
       pi as unknown as ExtensionAPI,
       jobTracker,
       {
-        notifyTools: new Set(['read']),
-        events: {},
+        notifyTools: new Set(['bash']),
+        events: { 'permissions:ui_prompt': 'msg' },
       } as unknown as ResolvedNotifyConfig,
     )
     tracker.register(() => {})
@@ -373,32 +375,66 @@ describe('SessionStore', () => {
     })
     await new Promise((resolve) => setTimeout(resolve, 20))
 
-    expect(readState().sessions[String(process.pid)]?.state).toBe('idle')
+    pi.emitEvent('permissions:ui_prompt', {})
+    await new Promise((resolve) => setTimeout(resolve, 20))
 
-    pi.emit('tool_call', {
-      type: 'tool_call',
-      toolCallId: 't1',
-      toolName: 'grep',
+    const record = readState().sessions[String(process.pid)]
+    expect(record?.state).toBe('event:permissions:ui_prompt')
+  })
+
+  it('updates state immediately on ui_prompt emission', async () => {
+    await updateState(() => ({ version: 2, sessions: {} }))
+    const pi = makeFakePi()
+    const jobTracker = {
+      hasActiveJobs: false,
+      onStart: () => () => {},
+      onEnd: () => () => {},
+    } as unknown as JobTracker
+    const tracker = new StateTracker(
+      pi as unknown as ExtensionAPI,
+      jobTracker,
+      {
+        notifyTools: new Set([]),
+        events: {},
+      } as unknown as ResolvedNotifyConfig,
+    )
+    tracker.register(() => {})
+
+    const store = new SessionStore(pi as unknown as ExtensionAPI, tracker)
+    store.register(() => {})
+
+    pi.emitSessionStart({
+      cwd: META.cwd,
+      sessionManager: { getSessionId: () => SESSION_ID },
     })
     await new Promise((resolve) => setTimeout(resolve, 20))
 
+    pi.emit('ui_prompt_start', {
+      type: 'ui_prompt_start',
+      reason: 'ui_prompt',
+      kind: 'confirm',
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
     const record = readState().sessions[String(process.pid)]
-    expect(record?.state).toBe('idle')
+    expect(record?.state).toBe('ui_prompt:confirm')
   })
 
-  it('updates state immediately on event emission', async () => {
+  it('does not update state on tool emission outside notifyTools', async () => {
     await updateState(() => ({ version: 2, sessions: {} }))
     const pi = makeFakePi()
     const jobTracker = {
       hasActiveJobs: false,
+      onStart: () => () => {},
       onEnd: () => () => {},
     } as unknown as JobTracker
     const tracker = new StateTracker(
       pi as unknown as ExtensionAPI,
       jobTracker,
       {
-        notifyTools: new Set(['bash']),
-        events: { 'permissions:ui_prompt': 'msg' },
+        notifyTools: new Set(['read']),
+        events: {},
       } as unknown as ResolvedNotifyConfig,
     )
     tracker.register(() => {})
@@ -412,11 +448,17 @@ describe('SessionStore', () => {
     })
     await new Promise((resolve) => setTimeout(resolve, 20))
 
-    pi.emitEvent('permissions:ui_prompt', {})
+    expect(readState().sessions[String(process.pid)]?.state).toBe('idle')
+
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't1',
+      toolName: 'grep',
+    })
     await new Promise((resolve) => setTimeout(resolve, 20))
 
     const record = readState().sessions[String(process.pid)]
-    expect(record?.state).toBe('event:permissions:ui_prompt')
+    expect(record?.state).toBe('idle')
   })
 
   it('ignores tool and event emissions before session_start', async () => {

package/src/dashboard/session-store.ts

@@ -79,6 +79,9 @@ export class SessionStore extends Registrar {
       this.stateTracker.events.on('tool', async ({ data }) => {
         await this.saveSession(`tool_call:${data}`)
       }),
+      this.stateTracker.events.on('ui_prompt', async ({ data }) => {
+        await this.saveSession(`ui_prompt:${data}`)
+      }),
       this.stateTracker.events.on('event', async ({ data }) => {
         await this.saveSession(`event:${data}`)
       }),

package/src/dashboard/state-store.ts

@@ -54,7 +54,11 @@ export async function readSessions(): Promise<SessionRecord[]> {
 }
 
 export type SessionState =
-  'running' | 'idle' | `tool_call:${string}` | `event:${string}`
+  | 'running'
+  | 'idle'
+  | `tool_call:${string}`
+  | `event:${string}`
+  | `ui_prompt:${string}`
 
 export interface SessionRecord {
   pid: number
@@ -112,8 +116,12 @@ function parseSessionRecord(value: unknown): SessionRecord | undefined {
 
 function isActivityState(
   value: string,
-): value is `tool_call:${string}` | `event:${string}` {
-  return value.startsWith('tool_call:') || value.startsWith('event:')
+): value is `tool_call:${string}` | `event:${string}` | `ui_prompt:${string}` {
+  return (
+    value.startsWith('tool_call:') ||
+    value.startsWith('event:') ||
+    value.startsWith('ui_prompt:')
+  )
 }
 
 function isSessionState(value: unknown): value is SessionState {

package/src/dashboard/ui/dashboard.test.ts

@@ -8,6 +8,7 @@ import { Dashboard } from './dashboard.js'
 const theme = {
   fg: (color: ThemeColor, text: string) => `\x1b[90m${text}\x1b[0m`,
   bold: (text: string) => `\x1b[1m${text}\x1b[0m`,
+  underline: (text: string) => `\x1b[4m${text}\x1b[0m`,
 } as unknown as Theme
 
 const ANSI_RE =
@@ -70,18 +71,31 @@ describe('Dashboard render clipping', () => {
     const visible = lines.map(stripAnsi)
     const header = visible.find((l) => l.includes('STATE'))
     expect(header).toBeDefined()
-    const footer = visible.find((l) => l.startsWith('[o] show/hide ids'))
+    const footer = visible.find((l) => l.startsWith('[j/k/'))
     expect(footer).toBeDefined()
     if (!header || !footer) throw new Error('unreachable')
-    expect(header.startsWith('STATE')).toBe(true)
+    expect(header.startsWith('  STATE')).toBe(true)
     expect(header.endsWith('…')).toBe(true)
-    expect(footer.startsWith('[o] show/hide ids ·…')).toBe(true)
+    expect(footer.startsWith('[j/k/↑↓] move · [x]…')).toBe(true)
     for (const line of visible) {
       expect(visibleWidth(line)).toBeLessThanOrEqual(20)
     }
     dashboard.dispose()
   })
 
+  it('aligns header columns with session rows via the 2-char gutter', () => {
+    const dashboard = makeDashboard([makeSession({})])
+    const lines = dashboard.render(200).map(stripAnsi)
+    const header = lines.find((l) => l.includes('STATE'))
+    const row = lines.find((l) => l.includes('proj'))
+    expect(header).toBeDefined()
+    expect(row).toBeDefined()
+    if (!header || !row) throw new Error('unreachable')
+    expect(header.indexOf('PROJECT')).toBe(row.indexOf('proj'))
+    expect(header.indexOf('STATE')).toBe(2)
+    dashboard.dispose()
+  })
+
   it('counts CJK project names by display width', () => {
     const dashboard = makeDashboard([
       makeSession({ projectName: '中文项目名' }),
@@ -127,6 +141,7 @@ describe('dashboard state display', () => {
     const dashboard = makeDashboard([
       makeSession({ pid: process.pid, state: 'idle' }),
     ])
+    dashboard.handleInput('o')
     try {
       const row = dashboard
         .render(200)
@@ -144,6 +159,7 @@ describe('dashboard state display', () => {
     const dashboard = makeDashboard([
       makeSession({ pid: 999, state: 'running' }),
     ])
+    dashboard.handleInput('o')
     try {
       const row = dashboard
         .render(200)
@@ -175,3 +191,232 @@ describe('auto-refresh', () => {
     expect(onRefresh).not.toHaveBeenCalled()
   })
 })
+
+describe('selection navigation', () => {
+  const rows = (dashboard: Dashboard) =>
+    dashboard
+      .render(200)
+      .map(stripAnsi)
+      .filter((l) => l.includes('proj'))
+
+  it('starts with first row selected and moves with j/k and arrows', () => {
+    const dashboard = makeDashboard([
+      makeSession({ pid: 1, sessionId: 'abc123' }),
+      makeSession({ pid: 2, sessionId: 'def456' }),
+      makeSession({ pid: 3, sessionId: 'ghi789' }),
+    ])
+    try {
+      dashboard.handleInput('o')
+      let [first, second, third] = rows(dashboard)
+      expect(first?.startsWith('> ')).toBe(true)
+      expect(second?.startsWith('  ')).toBe(true)
+
+      dashboard.handleInput('j')
+      ;[first, second, third] = rows(dashboard)
+      expect(first?.startsWith('  ')).toBe(true)
+      expect(second?.startsWith('> ')).toBe(true)
+
+      dashboard.handleInput('\x1b[B')
+      ;[first, second, third] = rows(dashboard)
+      expect(third?.startsWith('> ')).toBe(true)
+
+      dashboard.handleInput('k')
+      dashboard.handleInput('\x1b[A')
+      ;[first, second, third] = rows(dashboard)
+      expect(first?.startsWith('> ')).toBe(true)
+    } finally {
+      dashboard.dispose()
+    }
+  })
+
+  it('clamps selection at first and last row', () => {
+    const dashboard = makeDashboard([
+      makeSession({ pid: 1, sessionId: 'abc123' }),
+      makeSession({ pid: 2, sessionId: 'def456' }),
+    ])
+    try {
+      dashboard.handleInput('o')
+      dashboard.handleInput('k')
+      expect(rows(dashboard)[0]?.startsWith('> ')).toBe(true)
+
+      dashboard.handleInput('j')
+      dashboard.handleInput('j')
+      const rowsNow = rows(dashboard)
+      expect(rowsNow[0]?.startsWith('  ')).toBe(true)
+      expect(rowsNow[1]?.startsWith('> ')).toBe(true)
+    } finally {
+      dashboard.dispose()
+    }
+  })
+
+  it('clamps selection to the last row after refresh shrinks the list', async () => {
+    const onRefresh = vi.fn(async () => [
+      makeSession({ pid: 3, sessionId: 'ghi789' }),
+    ])
+    const dashboard = makeDashboard(
+      [
+        makeSession({ pid: 1, sessionId: 'abc123' }),
+        makeSession({ pid: 2, sessionId: 'def456' }),
+        makeSession({ pid: 4, sessionId: 'jkl012' }),
+      ],
+      { onRefresh },
+    )
+    try {
+      dashboard.handleInput('o')
+      dashboard.handleInput('j')
+      dashboard.handleInput('j')
+      expect(rows(dashboard)[2]?.startsWith('> ')).toBe(true)
+
+      dashboard.handleInput('r')
+      await vi.waitFor(() => {
+        expect(onRefresh).toHaveBeenCalled()
+      })
+
+      // selection stays on the last row (position-based), moving down must not go out of bounds
+      dashboard.handleInput('j')
+      const visible = rows(dashboard)
+      expect(visible).toHaveLength(1)
+      expect(visible[0]?.startsWith('> ')).toBe(true)
+    } finally {
+      dashboard.dispose()
+    }
+  })
+
+  it('no-ops on empty session list', () => {
+    const dashboard = makeDashboard([])
+    try {
+      dashboard.handleInput('j')
+      dashboard.handleInput('k')
+      dashboard.handleInput('x')
+      expect(
+        dashboard.render(200).some((l) => stripAnsi(l).startsWith('> ')),
+      ).toBe(false)
+    } finally {
+      dashboard.dispose()
+    }
+  })
+})
+
+describe('kill action', () => {
+  let killSpy: ReturnType<typeof vi.spyOn>
+
+  const rows = (dashboard: Dashboard) =>
+    dashboard
+      .render(200)
+      .map(stripAnsi)
+      .filter((l) => l.includes('proj'))
+
+  it('kills the selected session with SIGTERM', async () => {
+    killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true)
+    const onRefresh = vi.fn(async () => [
+      makeSession({ pid: process.pid, sessionId: 'abc123' }),
+    ])
+    const dashboard = makeDashboard(
+      [
+        makeSession({ pid: process.pid, sessionId: 'self001' }),
+        makeSession({ pid: 999, sessionId: 'target1' }),
+      ],
+      { onRefresh },
+    )
+    try {
+      dashboard.handleInput('o')
+      dashboard.handleInput('j')
+      expect(rows(dashboard)[1]?.startsWith('> ')).toBe(true)
+      dashboard.handleInput('x')
+      expect(killSpy).toHaveBeenCalledWith(999, 'SIGTERM')
+      await vi.waitFor(() => {
+        expect(onRefresh).toHaveBeenCalled()
+      })
+    } finally {
+      dashboard.dispose()
+      killSpy.mockRestore()
+    }
+  })
+
+  it('does not kill the dashboard own row', () => {
+    killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true)
+    const dashboard = makeDashboard([
+      makeSession({ pid: process.pid, sessionId: 'abc123' }),
+    ])
+    try {
+      dashboard.handleInput('x')
+      expect(killSpy).not.toHaveBeenCalled()
+    } finally {
+      dashboard.dispose()
+      killSpy.mockRestore()
+    }
+  })
+
+  it('ignores ESRCH errors from kill', () => {
+    killSpy = vi.spyOn(process, 'kill').mockImplementation(() => {
+      throw Object.assign(new Error('no such process'), { code: 'ESRCH' })
+    })
+    const dashboard = makeDashboard([
+      makeSession({ pid: 999, sessionId: 'abc123' }),
+    ])
+    try {
+      expect(() => {
+        dashboard.handleInput('x')
+      }).not.toThrow()
+    } finally {
+      dashboard.dispose()
+      killSpy.mockRestore()
+    }
+  })
+})
+
+describe('selection degradation', () => {
+  it('follows the selected session as the list shrinks', async () => {
+    const onRefresh = vi.fn(async () => [
+      makeSession({ pid: 2, sessionId: 'bbb' }),
+    ])
+    const dashboard = makeDashboard(
+      [
+        makeSession({ pid: 1, sessionId: 'aaa' }),
+        makeSession({ pid: 2, sessionId: 'bbb' }),
+      ],
+      { onRefresh },
+    )
+    try {
+      // select row 0 (session 'aaa'), refresh removes it -> marker lands on 'bbb'
+      dashboard.handleInput('r')
+      await vi.waitFor(() => {
+        expect(onRefresh).toHaveBeenCalled()
+      })
+      const visible = dashboard
+        .render(200)
+        .map(stripAnsi)
+        .filter((l) => l.includes('proj'))
+      expect(visible).toHaveLength(1)
+      expect(visible[0]?.startsWith('> ')).toBe(true)
+
+      // refresh to empty -> no marker; navigation/kill no-op
+      const emptyRefresh = vi.fn(async () => [])
+      const dashboard2 = makeDashboard(
+        [makeSession({ pid: 2, sessionId: 'abc123' })],
+        { onRefresh: emptyRefresh },
+      )
+      try {
+        dashboard2.handleInput('r')
+        await vi.waitFor(() => {
+          expect(emptyRefresh).toHaveBeenCalled()
+        })
+        const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true)
+        try {
+          dashboard2.handleInput('j')
+          dashboard2.handleInput('x')
+          expect(
+            dashboard2.render(200).some((l) => stripAnsi(l).startsWith('> ')),
+          ).toBe(false)
+          expect(killSpy).not.toHaveBeenCalled()
+        } finally {
+          killSpy.mockRestore()
+        }
+      } finally {
+        dashboard2.dispose()
+      }
+    } finally {
+      dashboard.dispose()
+    }
+  })
+})

package/src/dashboard/ui/dashboard.ts

@@ -1,6 +1,7 @@
 import type { Theme } from '@earendil-works/pi-coding-agent'
 import type { Component } from '@earendil-works/pi-tui'
 import { Key, matchesKey, truncateToWidth } from '@earendil-works/pi-tui'
+import { clamp } from 'lodash-es'
 
 import type { SessionRecord } from '../state-store.js'
 import { watchStore } from '../watch-store.js'
@@ -30,6 +31,7 @@ export class Dashboard implements Component {
   private cachedLines: string[] = []
   private disposed = false
   private showHidden = false
+  private selectedIndex = 0
   private readonly stopWatching: () => void
 
   constructor({
@@ -57,11 +59,36 @@ export class Dashboard implements Component {
     this.tui.requestRender()
   }
 
+  private clampSelection(): void {
+    if (this.sessions.length === 0) return
+    this.selectedIndex = clamp(this.selectedIndex, 0, this.sessions.length - 1)
+  }
+
+  private moveSelection(delta: 1 | -1): void {
+    if (this.sessions.length === 0) return
+    this.selectedIndex += delta
+    this.clampSelection()
+    this.forceRender()
+  }
+
+  private killSelected(): void {
+    const session = this.sessions[this.selectedIndex]
+    if (!session || session.pid === process.pid) return
+    try {
+      process.kill(session.pid, 'SIGTERM')
+    } catch {
+      // ignore ESRCH etc.
+    }
+    this.refresh()
+  }
+
   private refresh(): void {
     if (this.disposed) return
     this.onRefresh()
       .then((newSessions) => {
+        if (this.disposed) return
         this.sessions = [...newSessions]
+        this.clampSelection()
         this.forceRender()
       })
       .catch(() => {})
@@ -78,17 +105,24 @@ export class Dashboard implements Component {
       return this.cachedLines
     }
     this.cachedWidth = width
-    const columns = resolveColumns(width, this.showHidden)
+    const tableWidth = width - 2
+    const columns = resolveColumns(tableWidth, this.showHidden)
     const rows = [
-      this.theme.fg('borderAccent', this.headerLine(columns)),
-      this.theme.fg('borderAccent', '─'.repeat(Math.max(1, width))),
-      ...this.sessions.map((session) =>
-        columns
+      this.theme.fg('borderAccent', `  ${this.headerLine(columns)}`),
+      this.theme.fg('borderAccent', `  ${'─'.repeat(Math.max(1, tableWidth))}`),
+      ...this.sessions.map((session, index) => {
+        const row = columns
           .map(({ col, width }) => col.render(session, this.theme, width))
-          .join(COLUMN_SEPARATOR),
-      ),
+          .join(COLUMN_SEPARATOR)
+        const selected = index === this.selectedIndex
+        const gutter = selected ? '> ' : '  '
+        const styledRow = selected ? this.theme.underline(row) : row
+        return gutter + styledRow
+      }),
       '',
       this.footerLine(width, [
+        ['j/k/↑↓', 'move'],
+        ['x', 'kill'],
         ['o', 'show/hide ids'],
         ['r', 'refresh'],
         ['q/esc', 'close'],
@@ -113,6 +147,21 @@ export class Dashboard implements Component {
   }
 
   handleInput(data: string): void {
+    if (matchesKey(data, 'j') || matchesKey(data, Key.down)) {
+      this.moveSelection(1)
+      return
+    }
+
+    if (matchesKey(data, 'k') || matchesKey(data, Key.up)) {
+      this.moveSelection(-1)
+      return
+    }
+
+    if (matchesKey(data, 'x')) {
+      this.killSelected()
+      return
+    }
+
     if (matchesKey(data, 'r')) {
       this.refresh()
       return

package/src/jobs.test.ts

@@ -0,0 +1,106 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { describe, expect, it, vi } from 'vitest'
+
+import { JOB_END_EVENT, JOB_START_EVENT, JobTracker } from './jobs.js'
+
+type EventsListener = (payload?: unknown) => void
+
+interface FakePi {
+  on(event: string, listener: (payload?: unknown) => void): () => void
+  events: { on(event: string, listener: EventsListener): () => void }
+  emitEvent(event: string, payload?: unknown): void
+}
+
+function makeFakePi(): FakePi {
+  const eventListeners = new Map<string, Set<EventsListener>>()
+  return {
+    on() {
+      return () => {}
+    },
+    events: {
+      on(event, listener) {
+        let set = eventListeners.get(event)
+        if (!set) {
+          set = new Set()
+          eventListeners.set(event, set)
+        }
+        set.add(listener)
+        return () => {
+          set.delete(listener)
+        }
+      },
+    },
+    emitEvent(event, payload) {
+      const set = eventListeners.get(event)
+      if (!set) return
+      for (const listener of [...set]) listener(payload)
+    },
+  }
+}
+
+function makeTracker(pi: FakePi = makeFakePi()): JobTracker {
+  const tracker = new JobTracker(pi as unknown as ExtensionAPI)
+  tracker.register(() => {})
+  return tracker
+}
+
+describe('JobTracker', () => {
+  it('fires onStart listeners on job start', () => {
+    const pi = makeFakePi()
+    const tracker = makeTracker(pi)
+    const onStart = vi.fn()
+
+    tracker.onStart(onStart)
+
+    pi.emitEvent(JOB_START_EVENT, { id: 'job-1' })
+
+    expect(onStart).toHaveBeenCalledOnce()
+    expect(tracker.hasActiveJobs).toBe(true)
+  })
+
+  it('stops firing onStart after unsubscribe', () => {
+    const pi = makeFakePi()
+    const tracker = makeTracker(pi)
+    const onStart = vi.fn()
+
+    const unsubscribe = tracker.onStart(onStart)
+    unsubscribe()
+
+    pi.emitEvent(JOB_START_EVENT, { id: 'job-1' })
+
+    expect(onStart).not.toHaveBeenCalled()
+  })
+
+  it('fires onEnd while the job is still active', () => {
+    const pi = makeFakePi()
+    const tracker = makeTracker(pi)
+
+    pi.emitEvent(JOB_START_EVENT, { id: 'job-1' })
+
+    let activeDuringEnd: boolean | undefined
+    tracker.onEnd(() => {
+      activeDuringEnd = tracker.hasActiveJobs
+    })
+    pi.emitEvent(JOB_END_EVENT, { id: 'job-1' })
+
+    expect(activeDuringEnd).toBe(true)
+    expect(tracker.hasActiveJobs).toBe(false)
+  })
+
+  it('drops old listeners when re-registering after stop', () => {
+    const pi = makeFakePi()
+    const tracker = makeTracker(pi)
+    const oldListener = vi.fn()
+    const newListener = vi.fn()
+
+    tracker.onStart(oldListener)
+    tracker.stop()
+    tracker.register(() => {})
+    tracker.onStart(newListener)
+
+    pi.emitEvent(JOB_START_EVENT, { id: 'job-1' })
+
+    expect(oldListener).not.toHaveBeenCalled()
+    expect(newListener).toHaveBeenCalledOnce()
+  })
+})

package/src/jobs.ts

@@ -5,12 +5,21 @@ export const JOB_END_EVENT = 'pi-notify:job:end'
 
 export class JobTracker extends Registrar {
   private activeJobs = new Set<string>()
+  private onStartListeners: Array<() => void> = []
   private onEndListeners: Array<() => void> = []
 
   get hasActiveJobs(): boolean {
     return this.activeJobs.size > 0
   }
 
+  onStart(listener: () => void): () => void {
+    this.onStartListeners.push(listener)
+    return () => {
+      const index = this.onStartListeners.indexOf(listener)
+      if (index !== -1) this.onStartListeners.splice(index, 1)
+    }
+  }
+
   onEnd(listener: () => void): () => void {
     this.onEndListeners.push(listener)
     return () => {
@@ -19,28 +28,33 @@ export class JobTracker extends Registrar {
     }
   }
 
+  private extractJobId(params: unknown): string | undefined {
+    if (
+      typeof params === 'object' &&
+      params !== null &&
+      'id' in params &&
+      typeof params.id === 'string'
+    ) {
+      return params.id
+    }
+    return undefined
+  }
+
   protected override setup(): void {
     const startUnsub = this.pi.events.on(JOB_START_EVENT, (params) => {
-      if (
-        typeof params === 'object' &&
-        params !== null &&
-        'id' in params &&
-        typeof params.id === 'string'
-      ) {
-        this.activeJobs.add(params.id)
+      const id = this.extractJobId(params)
+      if (id !== undefined) {
+        this.activeJobs.add(id)
+        for (const listener of this.onStartListeners) listener()
       }
     })
     this.unsubscribes.push(startUnsub)
 
     const endUnsub = this.pi.events.on(JOB_END_EVENT, (params) => {
-      if (
-        typeof params === 'object' &&
-        params !== null &&
-        'id' in params &&
-        typeof params.id === 'string'
-      ) {
+      const id = this.extractJobId(params)
+      if (id !== undefined) {
         for (const listener of this.onEndListeners) listener()
-        this.activeJobs.delete(params.id)
+        this.activeJobs.delete(id)
       }
     })
     this.unsubscribes.push(endUnsub)
@@ -49,5 +63,7 @@ export class JobTracker extends Registrar {
   override stop(): void {
     super.stop()
     this.activeJobs.clear()
+    this.onStartListeners = []
+    this.onEndListeners = []
   }
 }

package/src/state-tracker.test.ts

@@ -56,11 +56,29 @@ function makeFakePi(): FakePi {
   }
 }
 
-function makeFakeJobTracker(): JobTracker {
-  return {
+type FakeJobTracker = {
+  hasActiveJobs: boolean
+  onStart: (listener: () => void) => () => void
+  onEnd: (listener: () => void) => () => void
+  startListener?: () => void
+  endListener?: () => void
+}
+
+function makeFakeJobTracker(): FakeJobTracker {
+  const instance: FakeJobTracker = {
     hasActiveJobs: false,
-    onEnd: () => () => {},
-  } as unknown as JobTracker
+    onStart: (listener: () => void) => {
+      instance.startListener = listener
+      return () => {}
+    },
+    onEnd: (listener: () => void) => {
+      instance.endListener = listener
+      return () => {}
+    },
+    startListener: undefined as (() => void) | undefined,
+    endListener: undefined as (() => void) | undefined,
+  }
+  return instance
 }
 
 async function flush(): Promise<void> {
@@ -71,7 +89,7 @@ const BASE_CONFIG: ResolvedNotifyConfig = {
   enabled: true,
   notifyTools: new Set(['bash', 'read']),
   events: {
-    'permissions:ui_prompt': 'msg',
+    'my:custom:event': 'msg',
     'disabled:channel': false,
   },
   finished: true,
@@ -87,12 +105,14 @@ function makeTracker(
   tracker: StateTracker
   states: string[]
   bodies: string[]
+  jobs: FakeJobTracker
 } {
   const states: string[] = []
   const bodies: string[] = []
+  const jobs = makeFakeJobTracker()
   const tracker = new StateTracker(
     pi as unknown as ExtensionAPI,
-    makeFakeJobTracker(),
+    jobs as unknown as JobTracker,
     config,
   )
   tracker.register((body) => bodies.push(body))
@@ -102,7 +122,7 @@ function makeTracker(
   tracker.events.on('idle', () => {
     states.push('idle')
   })
-  return { tracker, states, bodies }
+  return { tracker, states, bodies, jobs }
 }
 
 describe('StateTracker', () => {
@@ -144,16 +164,41 @@ describe('StateTracker', () => {
 
     pi.emit('turn_start')
     pi.emit('message_start')
+    pi.emit('turn_start')
+
+    await flush()
+
+    expect(states).toEqual(['running'])
+  })
+
+  it('re-emits running after a notified custom event resets the state', async () => {
+    const pi = makeFakePi()
+    const { states } = makeTracker(pi)
+
+    pi.emit('turn_start')
+    pi.emitEvent('my:custom:event', {})
+    pi.emit('turn_start')
+
+    await flush()
+
+    expect(states).toEqual(['running', 'running'])
+  })
+
+  it('re-emits running after a notified tool call resets the state', async () => {
+    const pi = makeFakePi()
+    const { states } = makeTracker(pi)
+
+    pi.emit('turn_start')
     pi.emit('tool_call', {
       type: 'tool_call',
       toolCallId: 't1',
-      toolName: 'read',
+      toolName: 'bash',
     })
     pi.emit('turn_start')
 
     await flush()
 
-    expect(states).toEqual(['running'])
+    expect(states).toEqual(['running', 'running'])
   })
 
   it('emits tool only for tools in notifyTools', async () => {
@@ -188,12 +233,12 @@ describe('StateTracker', () => {
       events.push(event.data)
     })
 
-    pi.emitEvent('permissions:ui_prompt', {})
+    pi.emitEvent('my:custom:event', {})
     pi.emitEvent('disabled:channel', {})
 
     await flush()
 
-    expect(events).toEqual(['permissions:ui_prompt'])
+    expect(events).toEqual(['my:custom:event'])
   })
 
   it('unsubscribes from channel events on stop', async () => {
@@ -205,7 +250,7 @@ describe('StateTracker', () => {
     })
 
     tracker.stop()
-    pi.emitEvent('permissions:ui_prompt', {})
+    pi.emitEvent('my:custom:event', {})
 
     await flush()
 
@@ -230,7 +275,7 @@ describe('StateTracker', () => {
     const pi = makeFakePi()
     const { bodies } = makeTracker(pi)
 
-    pi.emitEvent('permissions:ui_prompt', {})
+    pi.emitEvent('my:custom:event', {})
 
     expect(bodies).toEqual(['msg'])
   })
@@ -265,6 +310,56 @@ describe('StateTracker', () => {
     expect(bodies).toEqual(['custom payload'])
   })
 
+  it('notifies on ui_prompt_start with kind and title', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emit('ui_prompt_start', {
+      type: 'ui_prompt_start',
+      reason: 'ui_prompt',
+      kind: 'confirm',
+      title: 'Apply changes?',
+    })
+
+    expect(bodies).toEqual(['Waiting: Confirm — Apply changes?'])
+  })
+
+  it('notifies on ui_prompt_start without a title', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emit('ui_prompt_start', {
+      type: 'ui_prompt_start',
+      reason: 'ui_prompt',
+      kind: 'select',
+    })
+
+    expect(bodies).toEqual(['Waiting: Select'])
+  })
+
+  it('emits ui_prompt with the raw kind and resets running', async () => {
+    const pi = makeFakePi()
+    const { tracker, states } = makeTracker(pi)
+    const kinds: string[] = []
+    tracker.events.on('ui_prompt', (event) => {
+      kinds.push(event.data)
+    })
+
+    pi.emit('turn_start')
+    pi.emit('ui_prompt_start', {
+      type: 'ui_prompt_start',
+      reason: 'ui_prompt',
+      kind: 'confirm',
+      title: 'Apply changes?',
+    })
+    pi.emit('turn_start')
+
+    await flush()
+
+    expect(kinds).toEqual(['confirm'])
+    expect(states).toEqual(['running', 'running'])
+  })
+
   it('notifies for tools in notifyTools', () => {
     const pi = makeFakePi()
     const { bodies } = makeTracker(pi)
@@ -291,6 +386,22 @@ describe('StateTracker', () => {
     expect(bodies).toEqual([])
   })
 
+  it('does not notify when notifyTools is empty', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi, {
+      ...BASE_CONFIG,
+      notifyTools: new Set([]),
+    })
+
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't1',
+      toolName: 'bash',
+    })
+
+    expect(bodies).toEqual([])
+  })
+
   it('notifies Idle on idle when there was activity', async () => {
     const pi = makeFakePi()
     const { bodies } = makeTracker(pi)
@@ -304,6 +415,19 @@ describe('StateTracker', () => {
     expect(bodies).toEqual(['Idle'])
   })
 
+  it('notifies Idle after background job activity without a turn', async () => {
+    const pi = makeFakePi()
+    const { bodies, jobs } = makeTracker(pi)
+
+    jobs.startListener?.()
+    jobs.endListener?.()
+    vi.advanceTimersByTime(10000)
+
+    await flush()
+
+    expect(bodies).toEqual(['Idle'])
+  })
+
   it('does not notify Idle on idle without activity', async () => {
     const pi = makeFakePi()
     const { bodies } = makeTracker(pi)

package/src/state-tracker.ts

@@ -1,4 +1,7 @@
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import type {
+  ExtensionAPI,
+  UIPromptKind,
+} from '@earendil-works/pi-coding-agent'
 import Emittery from 'emittery'
 
 import type { ResolvedNotifyConfig } from './config.js'
@@ -10,19 +13,33 @@ export const PI_NOTIFY_EVENT = 'pi-notify:notify'
 
 const IDLE_TIMEOUT_MS = 10000
 
+const PROMPT_KIND_LABELS: Record<UIPromptKind, string> = {
+  select: 'Select',
+  confirm: 'Confirm',
+  input: 'Input',
+  editor: 'Editor',
+  custom: 'Prompt',
+}
+
+function promptMessage(kind: UIPromptKind, title?: string): string {
+  const label = PROMPT_KIND_LABELS[kind]
+  if (!title) return `Waiting: ${label}`
+  return `Waiting: ${label} — ${title}`
+}
+
 export class StateTracker extends Registrar {
   readonly events = new Emittery<{
     running: never
     idle: never
     tool: string
     event: string
+    ui_prompt: string
   }>()
 
   private readonly jobTracker: JobTracker
   private readonly config: ResolvedNotifyConfig
   private idleTimer: NodeJS.Timeout | null = null
   private running = false
-  private hasActivity = false
   private notify: NotifyAction = () => {}
 
   constructor(
@@ -40,9 +57,10 @@ export class StateTracker extends Registrar {
     this.clearIdleTimer()
     this.idleTimer = setTimeout(() => {
       this.idleTimer = null
+      const wasRunning = this.running
       this.running = false
       void this.events.emit('idle')
-      if (this.hasActivity && this.config.finished) {
+      if (wasRunning && this.config.finished) {
         this.notify('Idle')
       }
     }, IDLE_TIMEOUT_MS)
@@ -66,6 +84,7 @@ export class StateTracker extends Registrar {
       if (typeof message !== 'string' || message === '') continue
       const unsubscribe = this.pi.events.on(channel, () => {
         this.notify(message)
+        this.running = false
         void this.events.emit('event', channel)
       })
       this.unsubscribes.push(unsubscribe)
@@ -73,15 +92,25 @@ export class StateTracker extends Registrar {
 
     const customEventUnsub = this.pi.events.on(PI_NOTIFY_EVENT, (payload) => {
       this.notify(String(payload))
+      this.running = false
       void this.events.emit('event', PI_NOTIFY_EVENT)
     })
     this.unsubscribes.push(customEventUnsub)
   }
 
+  private setupUiPrompt() {
+    this.pi.on('ui_prompt_start', (event) => {
+      this.notify(promptMessage(event.kind, event.title))
+      this.running = false
+      void this.events.emit('ui_prompt', event.kind)
+    })
+  }
+
   private setupToolCall() {
     this.pi.on('tool_call', (event) => {
       if (this.config.notifyTools.has(event.toolName)) {
         this.notify(`Tool call: ${event.toolName}`)
+        this.running = false
         void this.events.emit('tool', event.toolName)
       }
       this.clearIdleTimer()
@@ -92,15 +121,16 @@ export class StateTracker extends Registrar {
     this.notify = notify
 
     this.setupPiEvents()
+    this.setupUiPrompt()
     this.setupToolCall()
 
     this.pi.on('turn_start', () => {
-      this.hasActivity = true
       this.markRunning()
       this.clearIdleTimer()
     })
 
     this.pi.on('message_start', () => {
+      this.markRunning()
       this.clearIdleTimer()
     })
 
@@ -109,6 +139,10 @@ export class StateTracker extends Registrar {
     })
 
     this.unsubscribes.push(
+      this.jobTracker.onStart(() => {
+        this.markRunning()
+        this.clearIdleTimer()
+      }),
       this.jobTracker.onEnd(() => {
         this.startIdleTimer()
       }),
@@ -117,7 +151,7 @@ export class StateTracker extends Registrar {
 
   override stop(): void {
     super.stop()
+    this.running = false
     this.clearIdleTimer()
-    this.hasActivity = false
   }
 }