@miphamai/cli 0.59.0 → 0.60.1

package/src/ui/app.tsx

@@ -2,6 +2,7 @@ import React, { useState, useCallback, useEffect, useRef, useMemo } from 'react'
 import { Box, Text, useInput } from 'ink'
 import TextInput from 'ink-text-input'
 import { ErrorBoundary } from './error-boundary'
+import { formatThinking } from './thinking'
 import type { QueryEngine } from '../core/engine'
 import type { RemoteEngine } from '../daemon/remote-engine'
 import type { MiphamConfig } from '../shared/index.ts'
@@ -23,6 +24,7 @@ import { InputBar } from './input'
 import { ModelPicker } from './picker'
 import { AgentFooter, type AgentEntry } from './agent-footer'
 import { GraftStatusLine } from './graft-status'
+import { collapseNoopTicks } from './loop-noop'
 
 /** Current context-window usage % — undefined when unknown (remote stub). */
 function contextUsagePct(engine: QueryEngine | RemoteEngine): number | undefined {
@@ -48,6 +50,8 @@ import {
 import { useI18n } from '../i18n-context'
 import type { PermissionMode } from '../shared/index.ts'
 import { sanitizeForDisplay } from '../shared/sanitize.ts'
+import { recordLoopTurn, readAutoloopJournal } from '../commands/autoloop-journal.js'
+import { cancelAllSessionTimers } from '../tools/scheduling/schedule-wakeup.js'
 
 interface AppProps {
   engine: QueryEngine | RemoteEngine
@@ -160,6 +164,10 @@ export function App({
   )
   const [messages, setMessages] = useState<ChatMessage[]>([])
   const [isLoading, setIsLoading] = useState(false)
+  /** Idle-drain tick — bumped by the engine's onEnqueue callback whenever the
+   *  ScheduleWakeup timer fires while the engine is idle. Drives the idle-drain
+   *  effect so a queued /loop wakeup re-invokes without waiting for user input. */
+  const [wakeupTick, setWakeupTick] = useState(0)
   const [providerId, setProviderId] = useState(initialProvider || config.defaultProvider)
   const [modelId, setModelId] = useState(initialModel || config.defaultModel)
   const [pickerOpen, setPickerOpen] = useState(false)
@@ -181,6 +189,8 @@ export function App({
   // Monotonic turn id — lets a stale turn's finally() skip resetting shared UI
   // state (isLoading/abortRef/progress) after a newer turn has already started.
   const turnIdRef = useRef(0)
+  // Consecutive /loop noop wakeup count — used to fold repeated idle turns (#53).
+  const noopStreakRef = useRef(0)
   // Stream buffer: accumulate text chunks and throttle state updates to ~16fps.
   // Without this, every SSE chunk triggers setMessages → copies full array →
   // re-renders ChatPanel → re-runs compactToolGroups O(n). At 20-50 chunks/sec
@@ -337,220 +347,50 @@ export function App({
     [apiKeyPrompt, config, engine],
   )
 
-  const handleSubmit = useCallback(
-    async (input: string) => {
-      if (!input.trim()) return
+  // ── runTurn: renders a single AI turn (user-submitted or /loop re-invoked) ──
+  // Extracted from handleSubmit so scheduled /loop wakeups re-enter the same streaming
+  // path. `source` marks user vs loop turns (currently identical rendering — loop turns
+  // skip handleSubmit's user-message/emotion/session-setup prelude). `controller` is
+  // supplied by user turns (already stored in abortRef); loop turns pass none and runTurn
+  // creates one so Escape/abort still works mid-loop-turn.
+  const runTurn = useCallback(
+    async (input: string, source: 'user' | 'loop', controller?: AbortController, noop = false) => {
+      void source // reserved for future user-vs-loop divergence; both paths share this body
       const turnId = ++turnIdRef.current
+      // Loop turns set loading state here (user turns already do it in handleSubmit;
+      // the duplicate is idempotent). Without this, the idle-drain effect can't tell
+      // a loop turn is running and would drain the queue mid-turn.
+      setIsLoading(true)
+      const loopStartTokens =
+        source === 'loop' && 'hasPendingWakeup' in engine
+          ? engine.getUsageTracker().totalApiTokens
+          : 0
+      const ctrl = controller ?? new AbortController()
+      if (!controller) abortRef.current = ctrl
 
-      // ── @mention: direct cross-session message — only when the name resolves
-      // to a live session; otherwise fall through to normal AI processing so a
-      // leading `@word` (e.g. "@bob please review") isn't hijacked as a send. ──
-      const mention = parseMention(input)
-      if (mention && resolveRecipientSession(discoverSessions(), mention.name).session) {
-        if (!mention.message) {
-          setMessages((prev) => [
-            ...prev,
-            { role: 'user', content: input },
-            { role: 'system', content: 'Usage: @session-name <message>' },
-          ])
-          return
-        }
-        const mentionSummary =
-          mention.message.length > 50 ? mention.message.slice(0, 47) + '...' : mention.message
-        const result = await getMessageRouter().route(
-          sessionId || 'main',
-          mention.name,
-          mentionSummary,
-          mention.message,
-        )
-        setMessages((prev) => [
-          ...prev,
-          { role: 'user', content: input },
-          {
-            role: 'system',
-            content: result.success
-              ? `── Message sent to ${mention.name} ──${result.messageId ? `\nID: ${result.messageId}` : ''}`
-              : `❌ Failed to send to ${mention.name}: ${result.error}`,
-          },
-        ])
-        return
+      // ── /loop idle folding (#53) ──
+      // Count consecutive noop wakeups; any non-noop loop turn or user turn resets.
+      if (source === 'loop' && noop) {
+        noopStreakRef.current++
+      } else {
+        noopStreakRef.current = 0
       }
-
-      // ── Slash command dispatch ──
-      if (looksLikeSlashCommand(input)) {
-        const { command, args } = parseSlashCommand(input)
-
-        // /switch takes args, handled separately
-        if (command === '/switch') {
-          const result = await handleSwitch(mkCtx(), args)
-          if (result.needsApiKey) {
-            setApiKeyPrompt(result.needsApiKey)
-            setApiKeyInput('')
-            setMessages((prev) => [
-              ...prev,
-              { role: 'user', content: input },
-              { role: 'system', content: result.content },
-            ])
+      // The first noop tick renders normally; the 2nd+ fold into one idle line.
+      const foldIdle = source === 'loop' && noop && noopStreakRef.current >= 2
+      if (foldIdle) {
+        const ticks = Array.from({ length: noopStreakRef.current }, () => ({ noop: true }))
+        const folded = collapseNoopTicks(ticks)
+        setMessages((prev) => {
+          const updated = [...prev]
+          const last = updated[updated.length - 1]
+          if (last?.role === 'system' && last.content.startsWith('💤 idle ×')) {
+            last.content = folded
           } else {
-            setMessages((prev) => [
-              ...prev,
-              { role: 'user', content: input },
-              { role: 'system', content: result.content },
-            ])
-            if (result.nextProvider) setProviderId(result.nextProvider)
-            if (result.nextModel) setModelId(result.nextModel)
-          }
-          if (result.exit) process.exit(0)
-          return
-        }
-
-        // /pick → open interactive model picker
-        if (command === '/pick' || command === '/model-picker') {
-          setPickerOpen(true)
-          return
-        }
-
-        // /quit and /exit are special
-        if (command === '/exit' || command === '/quit') {
-          process.exit(0)
-        }
-
-        // /focus toggle
-        if (command === '/focus') {
-          const nextFocus = !focusMode
-          setFocusMode(nextFocus)
-          setMessages((prev) => [
-            ...prev,
-            { role: 'user', content: input },
-            {
-              role: 'system',
-              content: nextFocus
-                ? '✓ Focus mode ON — showing only the most recent exchange. Type /focus again to show all.'
-                : '✓ Focus mode OFF — showing all messages.',
-            },
-          ])
-          return
-        }
-
-        let forwardToAI: string | undefined
-
-        const handler = getCommand(command)
-        if (handler) {
-          const result = await handler(mkCtx(), args)
-          forwardToAI = result.forwardToAI
-          // Handle API key prompt from command result
-          if (result.needsApiKey) {
-            setApiKeyPrompt(result.needsApiKey)
-            setApiKeyInput('')
-          }
-          setMessages((prev) => [
-            ...prev,
-            { role: 'user', content: input },
-            { role: 'system', content: result.content },
-          ])
-          if (result.needsApiKey) {
-            // Don't process nextProvider/model when waiting for API key
-            if (result.exit) process.exit(0)
-            return
+            updated.push({ role: 'system', content: folded })
           }
-          if (result.clearMessages) setMessages([])
-          if (result.nextProvider) setProviderId(result.nextProvider)
-          if (result.nextModel) setModelId(result.nextModel)
-          if (result.exit) process.exit(0)
-          if (result.forwardedMessages && result.forwardedMessages.length > 0) {
-            const restored: ChatMessage[] = result.forwardedMessages.map((msg) => ({
-              role: msg.role,
-              content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-            }))
-            if (result.resumeWarning) {
-              // Fix 7: Session isolation — add a visual separator between current session
-              // and restored history to prevent accidental leakage/confusion
-              const separator: ChatMessage = {
-                role: 'assistant' as const,
-                content: '── Restored session history below ──',
-              }
-              setMessages((prev) => [...prev, separator, ...restored])
-            } else {
-              setMessages((prev) => [...prev, ...restored])
-            }
-          }
-          if (result.copyContent) {
-            // Copy to clipboard via pbcopy (macOS) or clip (Windows)
-            try {
-              const { execSync } = await import('node:child_process')
-              if (process.platform === 'darwin') {
-                execSync('pbcopy', { input: result.copyContent })
-              } else if (process.platform === 'win32') {
-                execSync('clip', { input: result.copyContent })
-              }
-              // Linux: xclip or wl-copy not attempted to avoid dependency issues
-            } catch {
-              // Silent fail — content is still displayed
-            }
-          }
-        }
-
-        // Bridge: if command set forwardToAI, route the message to AI processing
-        if (forwardToAI) {
-          input = forwardToAI
-          // fall through to normal AI processing below
-        } else {
-          // No handler matched or handler didn't request AI routing — stop here
-          return
-        }
-      }
-
-      // ── Emotion detection: adjust behavior based on user's emotional state ──
-      // Uses regex heuristics (zero-latency) to detect frustration/impatience/confusion.
-      // When frustrated, prepends a terseness instruction to the user input so the
-      // AI model skips explanations and gets straight to the fix.
-      let emotionPrefix = ''
-      try {
-        const { EmotionDetector } = await import('../core/emotion-detector.js')
-        const detector = new EmotionDetector()
-        const result = detector.detect(input)
-        if (result.emotion === 'frustrated' || result.emotion === 'impatient') {
-          emotionPrefix = `[SYSTEM NOTE: The user is ${result.emotion}. Be extremely concise. Skip all explanations, preambles, and summaries. Output only the fix/result. No "here's what I did" or "let me explain". One sentence maximum before code.]\n\n`
-        } else if (result.emotion === 'confused') {
-          emotionPrefix = `[SYSTEM NOTE: The user seems confused. Explain more thoroughly, break down complex steps, and offer clarifying questions rather than assuming understanding.]\n\n`
-        }
-      } catch {
-        // Emotion detection is non-critical — fail silently
-      }
-
-      // ── Normal message processing (AI chat) ──
-      // First user message: auto-name the session if it still carries the
-      // default cwd-basename name (respecting any manual /rename).
-      if (
-        engine
-          .getContext()
-          .getMessages()
-          .every((m) => m.role !== 'user')
-      ) {
-        const currentName = discoverSessions().find((s) => s.id === sessionId)?.name
-        if (isDefaultSessionName(currentName, process.cwd())) {
-          const title = deriveSessionTitle(input)
-          if (title && sessionId) renameActiveSession(sessionId, title)
-        }
-      }
-
-      setMessages((prev) => [...prev, { role: 'user', content: input }])
-      setIsLoading(true)
-
-      // Start agent progress indicator immediately for ALL processing
-      const progressStart = Date.now()
-      const progress: AgentProgress = {
-        name: '',
-        description: '',
-        startTime: progressStart,
-        tokensUsed: 0,
+          return updated
+        })
       }
-      agentProgressRef.current = progress
-      setAgentProgress(progress)
-      setAgentTick((t) => t + 1)
-
-      const controller = new AbortController()
-      abortRef.current = controller
 
       let assistantContent = ''
       // Track whether we've started a new assistant turn — reset accumulator per turn
@@ -577,13 +417,11 @@ export function App({
       }
 
       try {
-        for await (const chunk of engine.process(
-          emotionPrefix ? emotionPrefix + input : input,
-          controller.signal,
-        )) {
+        for await (const chunk of engine.process(input, ctrl.signal)) {
           // Reasoning content (DeepSeek V4 thinking mode) — surface as a live
           // "thinking" indicator so long reasoning passes don't look like a stall.
           if (chunk.reasoning_content) {
+            if (foldIdle) continue // folded idle turns never surface reasoning
             thinkingRef.current += chunk.reasoning_content
             if (!thinkingTimerRef.current) {
               thinkingTimerRef.current = setTimeout(() => {
@@ -595,6 +433,8 @@ export function App({
           }
 
           if (chunk.type === 'text' && chunk.content) {
+            assistantContent += chunk.content
+            if (foldIdle) continue // suppress per-turn idle output; folded line already shown
             // New turn: push fresh assistant message, reset stream buffer
             if (isNewTurn) {
               // Flush any accumulated reasoning as a collapsed history line
@@ -606,10 +446,17 @@ export function App({
                   clearTimeout(thinkingTimerRef.current)
                   thinkingTimerRef.current = null
                 }
-                setMessages((prev) => [
-                  ...prev,
-                  { role: 'system' as const, content: `💭 ${thought}` },
-                ])
+                const thinkingLine = formatThinking(
+                  config.showThinking ?? 'off',
+                  thought,
+                  t('ui.loading.thinking'),
+                )
+                if (thinkingLine) {
+                  setMessages((prev) => [
+                    ...prev,
+                    { role: 'system' as const, content: thinkingLine },
+                  ])
+                }
               }
               turnContent = chunk.content
               isNewTurn = false
@@ -638,7 +485,6 @@ export function App({
                 }, 60)
               }
             }
-            assistantContent += chunk.content
           }
 
           if (chunk.type === 'tool_use' && chunk.toolUse) {
@@ -806,8 +652,284 @@ export function App({
         // Final sync of background agents after the turn completes
         syncBgAgents()
       }
+
+      // End-of-loop-turn accounting: log iteration + token delta, and stop at the
+      // max-iteration guard. `input` is the loop id for /loop auto (ScheduleWakeup
+      // re-invokes runTurn(loopId, 'loop')); fixed-interval loops have no journal and skip.
+      if (source === 'loop' && 'hasPendingWakeup' in engine) {
+        const journal = readAutoloopJournal(input)
+        if (journal && journal.status === 'active') {
+          const delta = engine.getUsageTracker().totalApiTokens - loopStartTokens
+          recordLoopTurn(input, assistantContent.slice(0, 200), delta)
+          // max-iteration guard: recordLoopTurn flips the journal to 'stopped' when
+          // iterations hit maxIterations. Stop re-invocation so the loop doesn't wake
+          // again after hitting the cap.
+          const after = readAutoloopJournal(input)
+          if (after && after.status !== 'active') {
+            if (sessionId) cancelAllSessionTimers(sessionId)
+            engine.clearWakeupQueue()
+          }
+        }
+      }
+
+      // Turn finished — drain any /loop wakeup queued while we were running.
+      drainLoopQueueRef.current?.(turnId)
+    },
+    [engine, syncBgAgents, config, t],
+  )
+
+  // Ref-held drain breaks the runTurn ↔ drain circular useCallback dependency: runTurn
+  // calls drainLoopQueueRef.current (a stable ref object), and the drain closure captures
+  // the latest runTurn. Reassigned each render so it never holds a stale runTurn.
+  const drainLoopQueueRef = useRef<((turnId: number) => Promise<void>) | null>(null)
+  drainLoopQueueRef.current = async (turnId: number) => {
+    // User turn wins: if a user submitted meanwhile, turnId advanced and this loop wakeup
+    // yields (the next timer fire re-enqueues). Spec §六 — do not force it to run anyway.
+    if (turnIdRef.current !== turnId) return
+    // RemoteEngine (remote attach mode) has no wakeup queue — /loop is CLI-local.
+    if (!('hasPendingWakeup' in engine)) return
+    const next = engine.hasPendingWakeup() ? engine.dequeueWakeup() : null
+    if (next) await runTurn(next.prompt, 'loop', undefined, next.noop)
+  }
+
+  // ── /loop idle-drain trigger ──
+  // The ScheduleWakeup timer fires 60–3600s after the turn that scheduled it, while
+  // the engine is idle. At that moment enqueueWakeup only mutates the queue (no React
+  // state change, no poller), so the queue would sit undrained forever. Subscribe the
+  // engine's onEnqueue callback to a state bump; the idle-drain effect below then
+  // drains the queue and re-invokes runTurn.
+  useEffect(() => {
+    if (!('setOnWakeupEnqueued' in engine)) return
+    const qe = engine // narrow to QueryEngine for the cleanup closure
+    qe.setOnWakeupEnqueued(() => setWakeupTick((t) => t + 1))
+    return () => qe.setOnWakeupEnqueued(null)
+  }, [engine])
+
+  // When a wakeup is enqueued and the engine is idle, drain it now (the running turn's
+  // end-drain handles the busy case). `wakeupTick === 0` skips the mount-time run.
+  useEffect(() => {
+    if (wakeupTick === 0) return
+    if (isLoading) return
+    drainLoopQueueRef.current?.(turnIdRef.current)
+  }, [wakeupTick, isLoading])
+
+  const handleSubmit = useCallback(
+    async (input: string) => {
+      if (!input.trim()) return
+
+      // ── @mention: direct cross-session message — only when the name resolves
+      // to a live session; otherwise fall through to normal AI processing so a
+      // leading `@word` (e.g. "@bob please review") isn't hijacked as a send. ──
+      const mention = parseMention(input)
+      if (mention && resolveRecipientSession(discoverSessions(), mention.name).session) {
+        if (!mention.message) {
+          setMessages((prev) => [
+            ...prev,
+            { role: 'user', content: input },
+            { role: 'system', content: 'Usage: @session-name <message>' },
+          ])
+          return
+        }
+        const mentionSummary =
+          mention.message.length > 50 ? mention.message.slice(0, 47) + '...' : mention.message
+        const result = await getMessageRouter().route(
+          sessionId || 'main',
+          mention.name,
+          mentionSummary,
+          mention.message,
+        )
+        setMessages((prev) => [
+          ...prev,
+          { role: 'user', content: input },
+          {
+            role: 'system',
+            content: result.success
+              ? `── Message sent to ${mention.name} ──${result.messageId ? `\nID: ${result.messageId}` : ''}`
+              : `❌ Failed to send to ${mention.name}: ${result.error}`,
+          },
+        ])
+        return
+      }
+
+      // ── Slash command dispatch ──
+      if (looksLikeSlashCommand(input)) {
+        const { command, args } = parseSlashCommand(input)
+
+        // /switch takes args, handled separately
+        if (command === '/switch') {
+          const result = await handleSwitch(mkCtx(), args)
+          if (result.needsApiKey) {
+            setApiKeyPrompt(result.needsApiKey)
+            setApiKeyInput('')
+            setMessages((prev) => [
+              ...prev,
+              { role: 'user', content: input },
+              { role: 'system', content: result.content },
+            ])
+          } else {
+            setMessages((prev) => [
+              ...prev,
+              { role: 'user', content: input },
+              { role: 'system', content: result.content },
+            ])
+            if (result.nextProvider) setProviderId(result.nextProvider)
+            if (result.nextModel) setModelId(result.nextModel)
+          }
+          if (result.exit) process.exit(0)
+          return
+        }
+
+        // /pick → open interactive model picker
+        if (command === '/pick' || command === '/model-picker') {
+          setPickerOpen(true)
+          return
+        }
+
+        // /quit and /exit are special
+        if (command === '/exit' || command === '/quit') {
+          process.exit(0)
+        }
+
+        // /focus toggle
+        if (command === '/focus') {
+          const nextFocus = !focusMode
+          setFocusMode(nextFocus)
+          setMessages((prev) => [
+            ...prev,
+            { role: 'user', content: input },
+            {
+              role: 'system',
+              content: nextFocus
+                ? '✓ Focus mode ON — showing only the most recent exchange. Type /focus again to show all.'
+                : '✓ Focus mode OFF — showing all messages.',
+            },
+          ])
+          return
+        }
+
+        let forwardToAI: string | undefined
+
+        const handler = getCommand(command)
+        if (handler) {
+          const result = await handler(mkCtx(), args)
+          forwardToAI = result.forwardToAI
+          // Handle API key prompt from command result
+          if (result.needsApiKey) {
+            setApiKeyPrompt(result.needsApiKey)
+            setApiKeyInput('')
+          }
+          setMessages((prev) => {
+            const next: ChatMessage[] = [...prev, { role: 'user', content: input }]
+            if (result.content) next.push({ role: 'system', content: result.content })
+            return next
+          })
+          if (result.needsApiKey) {
+            // Don't process nextProvider/model when waiting for API key
+            if (result.exit) process.exit(0)
+            return
+          }
+          if (result.clearMessages) setMessages([])
+          if (result.nextProvider) setProviderId(result.nextProvider)
+          if (result.nextModel) setModelId(result.nextModel)
+          if (result.exit) process.exit(0)
+          if (result.forwardedMessages && result.forwardedMessages.length > 0) {
+            const restored: ChatMessage[] = result.forwardedMessages.map((msg) => ({
+              role: msg.role,
+              content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            }))
+            if (result.resumeWarning) {
+              // Fix 7: Session isolation — add a visual separator between current session
+              // and restored history to prevent accidental leakage/confusion
+              const separator: ChatMessage = {
+                role: 'assistant' as const,
+                content: '── Restored session history below ──',
+              }
+              setMessages((prev) => [...prev, separator, ...restored])
+            } else {
+              setMessages((prev) => [...prev, ...restored])
+            }
+          }
+          if (result.copyContent) {
+            // Copy to clipboard via pbcopy (macOS) or clip (Windows)
+            try {
+              const { execSync } = await import('node:child_process')
+              if (process.platform === 'darwin') {
+                execSync('pbcopy', { input: result.copyContent })
+              } else if (process.platform === 'win32') {
+                execSync('clip', { input: result.copyContent })
+              }
+              // Linux: xclip or wl-copy not attempted to avoid dependency issues
+            } catch {
+              // Silent fail — content is still displayed
+            }
+          }
+        }
+
+        // Bridge: if command set forwardToAI, route the message to AI processing
+        if (forwardToAI) {
+          input = forwardToAI
+          // fall through to normal AI processing below
+        } else {
+          // No handler matched or handler didn't request AI routing — stop here
+          return
+        }
+      }
+
+      // ── Emotion detection: adjust behavior based on user's emotional state ──
+      // Uses regex heuristics (zero-latency) to detect frustration/impatience/confusion.
+      // When frustrated, prepends a terseness instruction to the user input so the
+      // AI model skips explanations and gets straight to the fix.
+      let emotionPrefix = ''
+      try {
+        const { EmotionDetector } = await import('../core/emotion-detector.js')
+        const detector = new EmotionDetector()
+        const result = detector.detect(input)
+        if (result.emotion === 'frustrated' || result.emotion === 'impatient') {
+          emotionPrefix = `[SYSTEM NOTE: The user is ${result.emotion}. Be extremely concise. Skip all explanations, preambles, and summaries. Output only the fix/result. No "here's what I did" or "let me explain". One sentence maximum before code.]\n\n`
+        } else if (result.emotion === 'confused') {
+          emotionPrefix = `[SYSTEM NOTE: The user seems confused. Explain more thoroughly, break down complex steps, and offer clarifying questions rather than assuming understanding.]\n\n`
+        }
+      } catch {
+        // Emotion detection is non-critical — fail silently
+      }
+
+      // ── Normal message processing (AI chat) ──
+      // First user message: auto-name the session if it still carries the
+      // default cwd-basename name (respecting any manual /rename).
+      if (
+        engine
+          .getContext()
+          .getMessages()
+          .every((m) => m.role !== 'user')
+      ) {
+        const currentName = discoverSessions().find((s) => s.id === sessionId)?.name
+        if (isDefaultSessionName(currentName, process.cwd())) {
+          const title = deriveSessionTitle(input)
+          if (title && sessionId) renameActiveSession(sessionId, title)
+        }
+      }
+
+      setMessages((prev) => [...prev, { role: 'user', content: input }])
+      setIsLoading(true)
+
+      // Start agent progress indicator immediately for ALL processing
+      const progressStart = Date.now()
+      const progress: AgentProgress = {
+        name: '',
+        description: '',
+        startTime: progressStart,
+        tokensUsed: 0,
+      }
+      agentProgressRef.current = progress
+      setAgentProgress(progress)
+      setAgentTick((t) => t + 1)
+
+      const controller = new AbortController()
+      abortRef.current = controller
+
+      await runTurn(emotionPrefix ? emotionPrefix + input : input, 'user', controller)
     },
-    [engine, mkCtx, syncBgAgents],
+    [engine, mkCtx, runTurn],
   )
 
   useInput((_input, key) => {
@@ -902,7 +1024,14 @@ export function App({
           <>
             {/* Chat panel */}
             <ChatPanel messages={messages} focusMode={focusMode} />
-            {thinkingText ? <Text dimColor>💭 {thinkingText.slice(-200)}</Text> : null}
+            {(() => {
+              const indicator = formatThinking(
+                config.showThinking ?? 'off',
+                thinkingText,
+                t('ui.loading.thinking'),
+              )
+              return indicator ? <Text dimColor>{indicator}</Text> : null
+            })()}
 
             {/* Input with separator lines */}
             {pickerOpen ? (
@@ -941,6 +1070,7 @@ export function App({
                 <InputBar
                   onSubmit={handleSubmit}
                   isLoading={isLoading}
+                  showCommandPicker={config.showCommandPicker ?? false}
                   onTogglePicker={() => setPickerOpen((prev) => !prev)}
                   onToggleFocus={() => setFocusMode((prev) => !prev)}
                   onToggleExpand={() => {