@raidou/pi-notify 0.5.3 → 0.6.0

package/README.md

@@ -76,6 +76,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.6.0",
   "description": "Desktop notification extension for the pi coding agent.",
   "keywords": [
     "pi",

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

@@ -352,6 +352,7 @@ describe('SessionStore', () => {
     const pi = makeFakePi()
     const jobTracker = {
       hasActiveJobs: false,
+      onStart: () => () => {},
       onEnd: () => () => {},
     } as unknown as JobTracker
     const tracker = new StateTracker(
@@ -391,6 +392,7 @@ describe('SessionStore', () => {
     const pi = makeFakePi()
     const jobTracker = {
       hasActiveJobs: false,
+      onStart: () => () => {},
       onEnd: () => () => {},
     } as unknown as JobTracker
     const tracker = new StateTracker(

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

@@ -70,18 +70,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 +140,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 +158,7 @@ describe('dashboard state display', () => {
     const dashboard = makeDashboard([
       makeSession({ pid: 999, state: 'running' }),
     ])
+    dashboard.handleInput('o')
     try {
       const row = dashboard
         .render(200)
@@ -175,3 +190,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> {
@@ -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,28 @@ 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 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 () => {
@@ -304,6 +336,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

@@ -22,7 +22,6 @@ export class StateTracker extends Registrar {
   private readonly config: ResolvedNotifyConfig
   private idleTimer: NodeJS.Timeout | null = null
   private running = false
-  private hasActivity = false
   private notify: NotifyAction = () => {}
 
   constructor(
@@ -40,9 +39,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 +66,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,6 +74,7 @@ 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)
@@ -82,6 +84,7 @@ export class StateTracker extends Registrar {
     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()
@@ -95,12 +98,12 @@ export class StateTracker extends Registrar {
     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 +112,10 @@ export class StateTracker extends Registrar {
     })
 
     this.unsubscribes.push(
+      this.jobTracker.onStart(() => {
+        this.markRunning()
+        this.clearIdleTimer()
+      }),
       this.jobTracker.onEnd(() => {
         this.startIdleTimer()
       }),
@@ -117,7 +124,7 @@ export class StateTracker extends Registrar {
 
   override stop(): void {
     super.stop()
+    this.running = false
     this.clearIdleTimer()
-    this.hasActivity = false
   }
 }