cli: Pause timer when using ask user tool

Author: jahooma

cli/src/chat.tsx

@@ -252,6 +252,7 @@ export const Chat = ({
   const isConnected = useConnectionStatus(handleReconnection)
   const mainAgentTimer = useElapsedTime()
   const { ad } = useGravityAd()
+  // Use startTime for active timer display; when paused, timer hook maintains frozen value
   const timerStartTime = mainAgentTimer.startTime
 
   // Set initial mode from CLI flag on mount
@@ -437,6 +438,15 @@ export const Chat = ({
   const setInputMode = useChatStore((state) => state.setInputMode)
   const askUserState = useChatStore((state) => state.askUserState)
 
+  // Pause/resume timer when ask_user tool becomes active/inactive
+  useEffect(() => {
+    if (askUserState !== null) {
+      mainAgentTimer.pause()
+    } else if (mainAgentTimer.isPaused) {
+      mainAgentTimer.resume()
+    }
+  }, [askUserState, mainAgentTimer])
+
   // Filter slash commands based on current ads state - only show the option that changes state
   const filteredSlashCommands = useMemo(() => {
     const adsEnabled = getAdsEnabled()

cli/src/components/status-bar.tsx

@@ -26,18 +26,28 @@ export const StatusBar = ({
   const theme = useTheme()
   const [elapsedSeconds, setElapsedSeconds] = useState(0)
 
-  // Show timer only when actively working (streaming or waiting for response)
+  // Show timer when actively working (streaming or waiting for response) or paused (ask_user)
   // This uses statusIndicatorState as the single source of truth for "is the LLM working?"
   const shouldShowTimer =
     statusIndicatorState?.kind === 'waiting' ||
-    statusIndicatorState?.kind === 'streaming'
+    statusIndicatorState?.kind === 'streaming' ||
+    statusIndicatorState?.kind === 'paused'
 
   useEffect(() => {
     if (!timerStartTime || !shouldShowTimer) {
       setElapsedSeconds(0)
       return
     }
 
+    // When paused, don't update the timer - just keep the frozen value
+    if (statusIndicatorState?.kind === 'paused') {
+      // Calculate current elapsed time once and freeze it
+      const now = Date.now()
+      const elapsed = Math.floor((now - timerStartTime) / 1000)
+      setElapsedSeconds(elapsed)
+      return
+    }
+
     const updateElapsed = () => {
       const now = Date.now()
       const elapsed = Math.floor((now - timerStartTime) / 1000)
@@ -48,7 +58,7 @@ export const StatusBar = ({
     const interval = setInterval(updateElapsed, 1000)
 
     return () => clearInterval(interval)
-  }, [timerStartTime, shouldShowTimer])
+  }, [timerStartTime, shouldShowTimer, statusIndicatorState?.kind])
 
   const renderStatusIndicator = () => {
     switch (statusIndicatorState.kind) {
@@ -96,6 +106,9 @@ export const StatusBar = ({
           />
         )
 
+      case 'paused':
+        return null
+      
       case 'idle':
         return null
     }

cli/src/hooks/__tests__/use-send-message-timer.test.ts

@@ -31,8 +31,11 @@ describe('createSendMessageTimerController', () => {
     mainAgentTimer = {
       start: startMock,
       stop: stopMock,
+      pause: mock(() => {}),
+      resume: mock(() => {}),
       elapsedSeconds: 0,
       startTime: null,
+      isPaused: false,
     }
   })
 

cli/src/hooks/helpers/__tests__/send-message.test.ts

@@ -53,6 +53,8 @@ const createMockTimerController = (): SendMessageTimerController & {
       stopCalls.push(outcome)
       return { finishedAt: Date.now(), elapsedMs: 100 }
     },
+    pause: () => {},
+    resume: () => {},
     isActive: () => startCalls.length > stopCalls.length,
   }
 }

cli/src/hooks/use-elapsed-time.ts

@@ -9,6 +9,14 @@ export interface ElapsedTimeTracker {
    * Stop tracking and reset to 0
    */
   stop: () => void
+  /**
+   * Pause tracking, freezing the current elapsed time
+   */
+  pause: () => void
+  /**
+   * Resume tracking from the frozen elapsed time
+   */
+  resume: () => void
   /**
    * Get the current elapsed seconds
    */
@@ -17,6 +25,10 @@ export interface ElapsedTimeTracker {
    * Get the start time timestamp (null if not started)
    */
   startTime: number | null
+  /**
+   * Whether the timer is currently paused
+   */
+  isPaused: boolean
 }
 
 /**
@@ -37,19 +49,47 @@ export interface ElapsedTimeTracker {
 export const useElapsedTime = (): ElapsedTimeTracker => {
   const [startTime, setStartTime] = useState<number | null>(null)
   const [elapsedSeconds, setElapsedSeconds] = useState<number>(0)
+  const [isPaused, setIsPaused] = useState(false)
+  // Track accumulated time from previous pause/resume cycles
+  const [accumulatedSeconds, setAccumulatedSeconds] = useState(0)
 
   const start = useCallback(() => {
     setStartTime(Date.now())
+    setAccumulatedSeconds(0)
+    setIsPaused(false)
   }, [])
 
   const stop = useCallback(() => {
     setStartTime(null)
     setElapsedSeconds(0)
+    setAccumulatedSeconds(0)
+    setIsPaused(false)
   }, [])
 
+  const pause = useCallback(() => {
+    if (startTime && !isPaused) {
+      // Capture current elapsed time before pausing
+      const currentElapsed = Math.floor((Date.now() - startTime) / 1000)
+      setAccumulatedSeconds(currentElapsed)
+      setElapsedSeconds(currentElapsed)
+      setIsPaused(true)
+    }
+  }, [startTime, isPaused])
+
+  const resume = useCallback(() => {
+    if (isPaused) {
+      // Set a new start time adjusted for accumulated time
+      setStartTime(Date.now() - accumulatedSeconds * 1000)
+      setIsPaused(false)
+    }
+  }, [isPaused, accumulatedSeconds])
+
   useEffect(() => {
-    if (!startTime) {
-      setElapsedSeconds(0)
+    if (!startTime || isPaused) {
+      // When paused, keep showing the frozen elapsed time (don't reset)
+      if (!isPaused && !startTime) {
+        setElapsedSeconds(0)
+      }
       return
     }
 
@@ -65,11 +105,11 @@ export const useElapsedTime = (): ElapsedTimeTracker => {
     const interval = setInterval(updateElapsed, 1000)
 
     return () => clearInterval(interval)
-  }, [startTime])
+  }, [startTime, isPaused])
 
   const timer = useMemo(
-    () => ({ start, stop, elapsedSeconds, startTime }),
-    [start, stop, elapsedSeconds, startTime],
+    () => ({ start, stop, pause, resume, elapsedSeconds, startTime, isPaused }),
+    [start, stop, pause, resume, elapsedSeconds, startTime, isPaused],
   )
 
   return timer

cli/src/utils/__tests__/send-message-timer.test.ts

@@ -9,6 +9,9 @@ describe('createSendMessageTimerController', () => {
     const mainAgentTimer = {
       start: mock(() => {}),
       stop: mock(() => {}),
+      pause: mock(() => {}),
+      resume: mock(() => {}),
+      isPaused: false,
     }
 
     const controller = createSendMessageTimerController({
@@ -37,6 +40,9 @@ describe('createSendMessageTimerController', () => {
     const mainAgentTimer = {
       start: mock(() => {}),
       stop: mock(() => {}),
+      pause: mock(() => {}),
+      resume: mock(() => {}),
+      isPaused: false,
     }
 
     const controller = createSendMessageTimerController({

cli/src/utils/send-message-timer.ts

@@ -26,6 +26,8 @@ export interface SendMessageTimerController {
     finishedAt: number
     elapsedMs: number
   } | null
+  pause: () => void
+  resume: () => void
   isActive: () => boolean
 }
 
@@ -94,7 +96,15 @@ export const createSendMessageTimerController = (
     return { finishedAt, elapsedMs }
   }
 
+  const pause = () => {
+    mainAgentTimer.pause()
+  }
+
+  const resume = () => {
+    mainAgentTimer.resume()
+  }
+
   const isActive = () => timerActive
 
-  return { start, stop, isActive }
+  return { start, stop, pause, resume, isActive }
 }

cli/src/utils/status-indicator-state.ts

@@ -9,6 +9,7 @@ export type StatusIndicatorState =
   | { kind: 'waiting' }
   | { kind: 'streaming' }
   | { kind: 'reconnected' }
+  | { kind: 'paused' }
 
 export type AuthStatus = 'ok' | 'retrying' | 'unreachable'
 
@@ -82,9 +83,9 @@ export const getStatusIndicatorState = ({
     return { kind: 'connecting' }
   }
 
-  // Hide working/thinking indicators when ask_user is active
+  // Show paused state when ask_user is active (timer stays visible but frozen)
   if (isAskUserActive) {
-    return { kind: 'idle' }
+    return { kind: 'paused' }
   }
 
   if (streamStatus === 'waiting') {