@miphamai/cli 0.58.0 → 0.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/commands/autoloop-journal.ts

@@ -8,7 +8,7 @@ function ensureDir(): void {
   if (!existsSync(AUTOLOOP_DIR)) mkdirSync(AUTOLOOP_DIR, { recursive: true })
 }
 
-interface AutoloopJournal {
+export interface AutoloopJournal {
   sessionId: string
   prompt: string
   status: 'active' | 'completed' | 'stopped'
@@ -16,6 +16,9 @@ interface AutoloopJournal {
   startedAt: string
   lastIteration?: string
   logs: string[]
+  startTokens?: number
+  totalTokens: number
+  maxIterations: number
 }
 
 function journalPath(sessionId: string): string {
@@ -23,7 +26,11 @@ function journalPath(sessionId: string): string {
 }
 
 /** Create or reset an autonomous loop journal. */
-export function createAutoloopJournal(sessionId: string, prompt: string): AutoloopJournal {
+export function createAutoloopJournal(
+  sessionId: string,
+  prompt: string,
+  startTokens = 0,
+): AutoloopJournal {
   ensureDir()
   const journal: AutoloopJournal = {
     sessionId,
@@ -32,11 +39,22 @@ export function createAutoloopJournal(sessionId: string, prompt: string): Autolo
     iterations: 0,
     startedAt: new Date().toISOString(),
     logs: [],
+    startTokens,
+    totalTokens: 0,
+    maxIterations: 100,
   }
   writeFileSync(journalPath(sessionId), JSON.stringify(journal, null, 2), 'utf-8')
   return journal
 }
 
+/** Accumulate token usage into the loop journal. */
+export function recordLoopTokens(sessionId: string, delta: number): void {
+  const journal = readAutoloopJournal(sessionId)
+  if (!journal) return
+  journal.totalTokens += delta
+  writeFileSync(journalPath(sessionId), JSON.stringify(journal, null, 2), 'utf-8')
+}
+
 /** Read the journal for an autonomous loop. */
 export function readAutoloopJournal(sessionId: string): AutoloopJournal | null {
   const path = journalPath(sessionId)
@@ -48,6 +66,19 @@ export function readAutoloopJournal(sessionId: string): AutoloopJournal | null {
   }
 }
 
+/** End-of-loop-turn accounting: log the iteration, record the token delta, and
+ *  stop the loop if it has reached its max-iteration guard (spec §七). */
+export function recordLoopTurn(sessionId: string, summary: string, delta: number): void {
+  const journal = readAutoloopJournal(sessionId)
+  if (!journal || journal.status !== 'active') return
+  logAutoloopIteration(sessionId, summary)
+  recordLoopTokens(sessionId, delta)
+  const updated = readAutoloopJournal(sessionId)
+  if (updated && updated.iterations >= updated.maxIterations) {
+    completeAutoloopJournal(sessionId, 'stopped')
+  }
+}
+
 /** Log an iteration in the autonomous loop journal. */
 export function logAutoloopIteration(sessionId: string, summary: string): void {
   const journal = readAutoloopJournal(sessionId)
@@ -85,6 +116,15 @@ export function listActiveAutoloops(): AutoloopJournal[] {
   return journals
 }
 
+/** Format active loop journals as one-line rows for the /usage panel. */
+export function formatLoopRows(journals: AutoloopJournal[]): string[] {
+  return journals.map((j) => {
+    const per = j.iterations > 0 ? Math.round(j.totalTokens / j.iterations) : 0
+    const last = j.lastIteration ? new Date(j.lastIteration).toLocaleString() : 'N/A'
+    return `${j.sessionId.slice(-8)}  🔄 ${j.iterations} iterations · ${j.totalTokens} tokens · ${per} /run · last ${last}`
+  })
+}
+
 /** Get the autonomous loop status message. */
 export function getAutoloopStatus(sessionId: string): string {
   const journal = readAutoloopJournal(sessionId)

package/src/config/defaults.ts

@@ -13,6 +13,7 @@ export const DEFAULT_CONFIG: MiphamConfig = {
   defaultProvider: 'deepseek',
   defaultModel: 'deepseek-v4-pro',
   permission: 'default',
+  showThinking: 'minimal',
   // Org 级权限限制（可选）：forbiddenModes 禁指定模式 / maxAllowedMode 封顶层级；
   // 请求被禁模式时 fail-closed 降级（如 forbiddenModes:['bypassPermissions']）。
   // permissionRestrictions: { forbiddenModes: ['bypassPermissions'] },

package/src/core/engine.ts

@@ -38,6 +38,7 @@ import { UsageTracker } from './usage-tracker'
 import { getMetrics } from './metrics'
 import { buildRequest, sendInferenceCheck, isInferenceHookEnabled } from './inference-hook'
 import { getFileInboxTransport } from '../agent/cross-session/file-inbox'
+import { registerWakeupHandler } from '../tools/scheduling/schedule-wakeup'
 import { accumulateGraftSavings } from '../shared/graft-savings'
 import { getMessageBus, type AgentMessage } from '../agent/message-bus'
 import { createT } from '../i18n-core/t'
@@ -101,6 +102,12 @@ export class QueryEngine {
   /** 注入的 LLM chat 缝。未设置时回退 this.registry（strangler-fig）。 */
   private llm?: Llm
 
+  /** Pending /loop re-invocation prompts, enqueued by the ScheduleWakeup timer. */
+  private wakeupQueue: Array<{ prompt: string; noop: boolean }> = []
+
+  /** Callback fired whenever a wakeup is enqueued (the ScheduleWakeup timer fired). */
+  private onWakeupEnqueued: (() => void) | null = null
+
   constructor(
     private registry: ProviderRegistry,
     private context: ContextManager,
@@ -109,6 +116,36 @@ export class QueryEngine {
     ruleEngine?: ExperienceRuleEngine,
   ) {
     this.ruleEngine = ruleEngine
+    // ScheduleWakeup 的 timer 到期后，把 loop prompt 交回本引擎 re-invoke。
+    registerWakeupHandler((_sessionId, prompt, noop) => this.enqueueWakeup(prompt, noop))
+  }
+
+  /** Enqueue a loop prompt for later re-invocation (keep-latest — drops older wakeups). */
+  enqueueWakeup(prompt: string, noop = false): void {
+    // 队列只保留最新（丢弃旧唤醒，防堆积）
+    this.wakeupQueue = [{ prompt, noop }]
+    this.onWakeupEnqueued?.()
+  }
+
+  /** Register a callback fired whenever a wakeup is enqueued (the ScheduleWakeup
+   *  timer fired). The app subscribes to drain the queue while idle. */
+  setOnWakeupEnqueued(cb: (() => void) | null): void {
+    this.onWakeupEnqueued = cb
+  }
+
+  /** Empty the wakeup queue (stops re-invocation at the max-iteration guard). */
+  clearWakeupQueue(): void {
+    this.wakeupQueue = []
+  }
+
+  /** Pop the next pending wakeup prompt, or null when the queue is empty. */
+  dequeueWakeup(): { prompt: string; noop: boolean } | null {
+    return this.wakeupQueue.shift() ?? null
+  }
+
+  /** Whether a wakeup prompt is pending re-invocation. */
+  hasPendingWakeup(): boolean {
+    return this.wakeupQueue.length > 0
   }
 
   /** Session identifier for cross-session messaging. Set by the app startup via setSessionId(). */
@@ -486,8 +523,11 @@ export class QueryEngine {
         yield chunk
 
         if (chunk.type === 'error') {
+          // #23: client-generated errors are system lines, not model output —
+          // store as `system` so resume renders an error line (⚠) rather than
+          // attributing the failure to the assistant.
           this.context.addMessage({
-            role: 'assistant',
+            role: 'system',
             content: t('errors.model_error', { error: chunk.error ?? 'Unknown error' }),
           })
           return
@@ -964,7 +1004,7 @@ export class QueryEngine {
       // P1-4: Increment consecutive block counter; if limit exceeded,
       // tell the model to move on instead of retrying.
       const limitExceeded = this.permission.incrementBlockCounter()
-      const baseError = t('errors.tool_not_allowed', { name })
+      const baseError = this.buildDenialError(name, tool, params)
       const moveOnHint = limitExceeded
         ? '\n(Consecutive block limit reached. Please try a different approach or ask the user for guidance.)'
         : ''
@@ -1297,6 +1337,29 @@ export class QueryEngine {
     return this.tools
   }
 
+  /**
+   * Build a rich permission-denial error naming the mode (level), the setting
+   * (rule/level) that caused the denial, and the correct fix (#52).
+   */
+  private buildDenialError(
+    name: string,
+    tool: ToolDefinition,
+    params: Record<string, unknown>,
+  ): string {
+    const { reason, rulePattern } = this.permission.explainDenial(tool, params)
+    const mode = this.permission.getMode()
+    switch (reason) {
+      case 'deny-rule':
+        return t('errors.tool_denied_deny_rule', { name, pattern: rulePattern ?? '?' })
+      case 'ask-rule':
+        return t('errors.tool_denied_ask_rule', { name, pattern: rulePattern ?? '?' })
+      default:
+        // mode-baseline / tool-default / legacy-rule / system-default — a mode
+        // switch (or /permissions) resolves it.
+        return t('errors.tool_denied_mode', { name, mode })
+    }
+  }
+
   getRuleEngine(): ExperienceRuleEngine | undefined {
     return this.ruleEngine
   }

package/src/core/permission.ts

@@ -62,6 +62,18 @@ function isVerificationCommand(input: Record<string, unknown>): boolean {
 
 const VALID_MODES: Set<string> = new Set<string>(MODE_CYCLE)
 
+/**
+ * Why a tool resolved to 'ask' — for rich denial errors (#52).
+ * Mirrors the resolution chain order in `check()` (first match wins).
+ */
+export type PermissionDenialReason =
+  | 'deny-rule' // org deny rule — overrides mode, cannot be switched away
+  | 'ask-rule' // explicit ask rule — still requires approval under any mode
+  | 'legacy-rule' // legacy exact-name rule (setRule)
+  | 'mode-baseline' // mode-specific default (acceptEdits/plan) → ask
+  | 'tool-default' // tool.permission === 'ask'
+  | 'system-default' // no rule, no tool permission → fallback ask
+
 export class PermissionSystem {
   private allowRules: PermissionRuleEntry[] = []
   private denyRules: PermissionRuleEntry[] = []
@@ -344,6 +356,39 @@ export class PermissionSystem {
     return this.check(tool, input) === 'bypass'
   }
 
+  /**
+   * Explain WHY a tool resolves to 'ask' (rich denial errors — #52).
+   *
+   * Only call after `check()` returns 'ask'; mirrors its resolution order
+   * (deny → ask → legacy → mode → tool → system). Returns the matched
+   * rule pattern when the denial came from a deny/ask rule.
+   */
+  explainDenial(
+    tool: ToolDefinition,
+    input: Record<string, unknown>,
+  ): { reason: PermissionDenialReason; rulePattern?: string } {
+    for (const rule of this.denyRules) {
+      if (this.ruleMatches(rule, tool, input)) {
+        return { reason: 'deny-rule', rulePattern: rule.pattern }
+      }
+    }
+    for (const rule of this.askRules) {
+      if (this.ruleMatches(rule, tool, input)) {
+        return { reason: 'ask-rule', rulePattern: rule.pattern }
+      }
+    }
+    if (this.legacyRules.has(tool.name)) {
+      return { reason: 'legacy-rule' }
+    }
+    if (this.modeBaseline(tool, input) !== 'mode-baseline') {
+      return { reason: 'mode-baseline' }
+    }
+    if (tool.permission) {
+      return { reason: 'tool-default' }
+    }
+    return { reason: 'system-default' }
+  }
+
   // ── Helpers ──
 
   private ruleMatches(

package/src/i18n-core/locales/en-US.json

@@ -364,6 +364,7 @@
       "provider_line": "Provider:         {provider}",
       "model_line": "Model:            {model}",
       "tool_section": "── Per-Tool ──",
+      "loops_header": "── Autonomous Loops ──",
       "hint": "Use /context for detailed stats, /compact to free space."
     },
     "reload_skills": {
@@ -940,6 +941,9 @@
   },
   "errors": {
     "tool_not_allowed": "Tool \"{name}\" requires user approval (permission: ask). The tool was not executed. Press Shift+Tab to switch permission mode, or run /permissions.",
+    "tool_denied_deny_rule": "Tool \"{name}\" blocked by a deny rule (\"{pattern}\"). Deny rules override permission mode — try a different approach.",
+    "tool_denied_ask_rule": "Tool \"{name}\" requires approval (ask rule: \"{pattern}\"). Approve when prompted, or adjust the rule via /permissions.",
+    "tool_denied_mode": "Tool \"{name}\" requires approval under \"{mode}\" mode. Press Shift+Tab to switch permission mode, or run /permissions.",
     "tool_blocked": "Tool \"{name}\" blocked by hook",
     "user_input_blocked": "User input blocked by hook.",
     "dlp_blocked": "Request blocked by DLP policy.",

package/src/i18n-core/locales/zh-CN.json

@@ -364,6 +364,7 @@
       "provider_line": "提供商:         {provider}",
       "model_line": "模型:            {model}",
       "tool_section": "── 按工具 ──",
+      "loops_header": "── 自动循环 ──",
       "hint": "使用 /context 查看详细统计，/compact 释放空间。"
     },
     "reload_skills": {
@@ -940,6 +941,9 @@
   },
   "errors": {
     "tool_not_allowed": "工具 \"{name}\" 需要用户批准（权限：ask），未执行。按 Shift+Tab 切换权限模式，或运行 /permissions。",
+    "tool_denied_deny_rule": "工具 \"{name}\" 被拒绝规则（\"{pattern}\"）阻止。拒绝规则优先于权限模式 — 请改用其他方式。",
+    "tool_denied_ask_rule": "工具 \"{name}\" 需要批准（ask 规则：\"{pattern}\"）。请在提示时批准，或通过 /permissions 调整规则。",
+    "tool_denied_mode": "工具 \"{name}\" 在 \"{mode}\" 模式下需要批准。按 Shift+Tab 切换权限模式，或运行 /permissions。",
     "tool_blocked": "工具 \"{name}\" 被钩子拦截",
     "user_input_blocked": "用户输入被钩子拦截。",
     "dlp_blocked": "请求被 DLP 策略阻止。",

package/src/providers/fetch-utils.ts

@@ -24,8 +24,9 @@ function isRetryableError(err: unknown): boolean {
 /**
  * Fetch with optional timeout and retry with exponential backoff.
  *
- * Retries on: network errors, 5xx, 429.
- * Does NOT retry on: timeout (AbortError), 4xx (except 429).
+ * Retries on: network errors, 5xx, 429, and the internal timeout firing
+ *   (first-byte never arrived) — retried once as a transient network issue.
+ * Does NOT retry on: caller-initiated abort (init.signal), 4xx (except 429).
  */
 export async function fetchWithRetry(
   url: string,
@@ -38,7 +39,11 @@ export async function fetchWithRetry(
 
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), timeout)
+    let timedOut = false
+    const timer = setTimeout(() => {
+      timedOut = true
+      controller.abort()
+    }, timeout)
     const signal = init.signal ? anySignal([init.signal, controller.signal]) : controller.signal
 
     try {
@@ -57,7 +62,16 @@ export async function fetchWithRetry(
       return response
     } catch (err) {
       lastErr = err
-      if (!isRetryableError(err) || attempt >= maxRetries) throw err
+      // First-byte timeout is transient → retry once. Caller abort is not.
+      const retryable = timedOut || isRetryableError(err)
+      if (!retryable || attempt >= maxRetries) {
+        if (timedOut) {
+          throw new Error(
+            `API Error: No response from API (timed out after ${Math.round(timeout / 1000)}s)`,
+          )
+        }
+        throw err
+      }
       await sleep(baseDelay * Math.pow(2, attempt))
     } finally {
       clearTimeout(timer)

package/src/providers/openai-compat.ts

@@ -21,7 +21,7 @@ export class OpenAICompatProvider implements ProviderInstance {
       model: req.model,
       messages: this.convertMessages(req.messages, req.systemPrompt),
       stream: true,
-      max_tokens: req.maxTokens,
+      max_tokens: req.maxTokens || 8192,
       temperature: req.temperature,
       tools: req.tools?.map((t) => ({ type: 'function', function: t })),
     }

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.58.0' as const
+export const PACKAGE_VERSION = '0.60.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/shared/types.ts

@@ -135,6 +135,13 @@ export interface MiphamConfig {
   permissionRestrictions?: PermissionRestrictions
   /** User-defined permission rules (allow/deny patterns), wired into the runtime PermissionSystem. */
   permissionRules?: { allow?: string[]; deny?: string[] }
+  /**
+   * How to render the model's reasoning/thinking before the answer:
+   * - `off`     → hide entirely
+   * - `minimal` → content-free "thinking…" indicator (default)
+   * - `full`    → last 200 chars of the actual thinking text
+   */
+  showThinking?: 'off' | 'minimal' | 'full'
   providers: ProviderConfig[]
   skills?: { paths: string[]; mcpServers: McpServerConfig[] }
   marketplace?: {

package/src/tools/computer/app-launcher.ts

@@ -34,6 +34,12 @@ export function launchApp(appName: string): { success: boolean; message: string
     }
     return { success: true, message: `Launched: ${appName}` }
   } catch (err) {
-    return { success: false, message: `Failed to launch ${appName}: ${String(err)}` }
+    // #57: on macOS an `open -a` failure is often missing Automation permission —
+    // point the user at the fix instead of a raw error.
+    const macHint =
+      process.platform === 'darwin'
+        ? ' On macOS, grant Automation permission (System Settings → Privacy & Security → Automation) if prompted.'
+        : ''
+    return { success: false, message: `Failed to launch ${appName}: ${String(err)}${macHint}` }
   }
 }

package/src/tools/computer/screenshot.ts

@@ -52,6 +52,12 @@ $bitmap.Dispose()
     } catch {
       // ignore cleanup failures
     }
-    return { success: false, error: `Screenshot failed: ${String(err)}` }
+    // #57: on macOS a screencapture failure is almost always missing Screen
+    // Recording permission — point the user at the fix instead of a raw error.
+    const macHint =
+      process.platform === 'darwin'
+        ? '\n(macOS: grant Screen Recording permission in System Settings → Privacy & Security → Screen Recording)'
+        : ''
+    return { success: false, error: `Screenshot failed: ${String(err)}${macHint}` }
   }
 }

package/src/tools/scheduling/schedule-wakeup.ts

@@ -6,6 +6,15 @@ import type { ToolDefinition } from '../../shared/index.ts'
  */
 const activeTimers = new Map<string, ReturnType<typeof setTimeout>>()
 
+let wakeupHandler: ((sessionId: string, prompt: string, noop?: boolean) => void) | null = null
+
+/** 引擎在启动时注入——timer 到期后回调，把 loop prompt 交回引擎 re-invoke。 */
+export function registerWakeupHandler(
+  fn: (sessionId: string, prompt: string, noop?: boolean) => void,
+): void {
+  wakeupHandler = fn
+}
+
 export const scheduleWakeupTool: ToolDefinition = {
   name: 'ScheduleWakeup',
   description:
@@ -31,6 +40,10 @@ export const scheduleWakeupTool: ToolDefinition = {
         type: 'boolean',
         description: 'Set to true to end the dynamic loop immediately.',
       },
+      noop: {
+        type: 'boolean',
+        description: 'true = 本轮无事可报（仅用于 UI 折叠空闲提示，不改变 re-invoke 语义）',
+      },
     },
     required: [],
   },
@@ -58,6 +71,7 @@ export const scheduleWakeupTool: ToolDefinition = {
     const delaySeconds = params.delaySeconds as number
     const prompt = (params.prompt as string) || ''
     const reason = (params.reason as string) || 'scheduled wakeup'
+    const noop = params.noop === true
 
     if (!delaySeconds || typeof delaySeconds !== 'number') {
       return {
@@ -86,6 +100,7 @@ export const scheduleWakeupTool: ToolDefinition = {
     const timerKey = `${sessionId}:wakeup`
     const timeoutId = setTimeout(() => {
       activeTimers.delete(timerKey)
+      wakeupHandler?.(sessionId, prompt, noop)
     }, delaySeconds * 1000)
 
     activeTimers.set(timerKey, timeoutId)

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
-          }
-          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])
-            }
+            updated.push({ role: 'system', content: folded })
           }
-          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
@@ -638,7 +478,6 @@ export function App({
                 }, 60)
               }
             }
-            assistantContent += chunk.content
           }
 
           if (chunk.type === 'tool_use' && chunk.toolUse) {
@@ -806,8 +645,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],
+  )
+
+  // 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) => [
+            ...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
+          }
+          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 +1017,14 @@ export function App({
           <>
             {/* Chat panel */}
             <ChatPanel messages={messages} focusMode={focusMode} />
-            {thinkingText ? <Text dimColor>💭 {thinkingText.slice(-200)}</Text> : null}
+            {(() => {
+              const indicator = formatThinking(
+                config.showThinking ?? 'minimal',
+                thinkingText,
+                t('ui.loading.thinking'),
+              )
+              return indicator ? <Text dimColor>{indicator}</Text> : null
+            })()}
 
             {/* Input with separator lines */}
             {pickerOpen ? (

package/src/ui/commands.ts

@@ -62,6 +62,7 @@ import { commitCmd, pushCmd, prCmd, issueCmd } from '../commands/git.js'
 import { suggestDirectories } from '../commands/cd-suggest.js'
 import { keysCmd } from '../commands/keys'
 import { workflowViewCmd, workflowWatchCmd } from '../commands/workflow-view.js'
+import { listActiveAutoloops, formatLoopRows } from '../commands/autoloop-journal.js'
 import { execSync } from 'node:child_process'
 import { OLLAMA_PRESET_MODELS } from '../shared/constants'
 import { renameActiveSession } from '../agent/cross-session/discovery'
@@ -545,6 +546,7 @@ const configCmd: CommandHandler = (ctx) => {
     `defaultProvider:  ${c.defaultProvider}`,
     `defaultModel:     ${c.defaultModel}`,
     `permission:       ${c.permission}`,
+    `showThinking:     ${c.showThinking ?? 'minimal'}`,
     `providers:        ${c.providers.length} configured`,
     '',
     `crossSessionInbound: ${xs.crossSessionInbound}`,
@@ -2105,6 +2107,12 @@ const usageCmd: CommandHandler = (ctx) => {
   const toolSection =
     toolLines.length > 0 ? `\n${t('commands.usage.tool_section')}\n${toolLines.join('\n')}` : ''
 
+  const loops = listActiveAutoloops()
+  const loopSection =
+    loops.length > 0
+      ? `\n${t('commands.usage.loops_header')}\n${formatLoopRows(loops).join('\n')}`
+      : ''
+
   return {
     content: stripIndent`
       ${t('commands.usage.title')}
@@ -2115,7 +2123,7 @@ const usageCmd: CommandHandler = (ctx) => {
       ${t('commands.usage.model_line', { model: ctx.modelId })}
 
       ${'█'.repeat(Math.ceil(Number(pct) / 5))}${'░'.repeat(20 - Math.ceil(Number(pct) / 5))} ${pct}%
-      ${toolSection}
+      ${toolSection}${loopSection}
 
       ${t('commands.usage.hint')}
     `,
@@ -2618,7 +2626,7 @@ function parseInterval(raw: string): number | null {
   return null
 }
 
-const loopCmd: CommandHandler = async (_ctx, args) => {
+const loopCmd: CommandHandler = async (ctx, args) => {
   const sub = args[0]
 
   // ── /loop init — scaffold project vault ──
@@ -2720,7 +2728,7 @@ const loopCmd: CommandHandler = async (_ctx, args) => {
 
     const sessionId = `autoloop-${Date.now()}`
     const { createAutoloopJournal } = await import('../commands/autoloop-journal.js')
-    createAutoloopJournal(sessionId, prompt)
+    createAutoloopJournal(sessionId, prompt, ctx.engine.getUsageTracker().totalApiTokens)
 
     const autoPrompt =
       `## Autonomous Loop — ${sessionId}\n\n` +
@@ -2780,7 +2788,7 @@ const loopCmd: CommandHandler = async (_ctx, args) => {
     if (fullPrompt.length > 0) {
       const sessionId = `autoloop-${Date.now()}`
       const { createAutoloopJournal } = await import('../commands/autoloop-journal.js')
-      createAutoloopJournal(sessionId, fullPrompt)
+      createAutoloopJournal(sessionId, fullPrompt, ctx.engine.getUsageTracker().totalApiTokens)
 
       const autoPrompt =
         `## Autonomous Loop — ${sessionId}\n\n` +

package/src/ui/loop-noop.ts

@@ -0,0 +1,23 @@
+/**
+ * /loop idle-wakeup folding — collapse consecutive noop ticks into a single
+ * "💤 idle ×N" line so repeated "nothing to report" wakeups don't spam the UI.
+ */
+export function collapseNoopTicks(ticks: Array<{ noop: boolean }>): string {
+  const lines: string[] = []
+  let i = 0
+  while (i < ticks.length) {
+    const tick = ticks[i]!
+    if (tick.noop) {
+      let count = 0
+      while (i < ticks.length && ticks[i]!.noop) {
+        count++
+        i++
+      }
+      lines.push(`💤 idle ×${count}`)
+    } else {
+      lines.push('● active')
+      i++
+    }
+  }
+  return lines.join('\n')
+}

package/src/ui/thinking.ts

@@ -0,0 +1,21 @@
+export type ThinkingMode = 'off' | 'minimal' | 'full'
+
+/**
+ * Render the live reasoning/thinking indicator for the given display mode.
+ *
+ * - `off`     → nothing (hide thinking entirely)
+ * - `minimal` → a content-free "💭 <label>…" so long reasoning passes don't
+ *               look like a stall, without dumping the model's chain-of-thought
+ * - `full`    → the last 200 chars of the actual thinking text (legacy behavior)
+ *
+ * Returns null when there is no thinking text to show (or mode is `off`).
+ */
+export function formatThinking(
+  mode: ThinkingMode,
+  thinkingText: string,
+  thinkingLabel: string,
+): string | null {
+  if (mode === 'off' || !thinkingText) return null
+  if (mode === 'minimal') return `💭 ${thinkingLabel}…`
+  return `💭 ${thinkingText.slice(-200)}`
+}