@miphamai/cli 0.85.5 → 0.85.7

package/src/telemetry/index.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto'
 import { getMetrics } from '../core/metrics'
+import { settingsPathFor } from '../config/loader'
 import { resolveTelemetry, getOrCreateInstallId, type TelemetryConsent } from './consent'
 import { enqueueSync } from './queue'
 import { buildSessionEvent } from './payload'
@@ -50,6 +51,12 @@ export function initTelemetry(cwd: string = process.cwd()): TelemetryConsent {
 
   state = { consent, installId, startedAt: Date.now(), flushed: false }
 
+  // A project that declared a telemetry key we do not honour is told so, here
+  // rather than in the TUI path — this is the one place consent is resolved, so
+  // it is also the one place that knows something was withheld, and it covers
+  // remote-attach and non-interactive runs the TUI setup never reaches.
+  announceIgnoredProjectKeys(consent, cwd)
+
   // Crash capture is installed unconditionally, even when telemetry is off:
   // it is what keeps a crash from becoming a silent hang. When telemetry is
   // off the record is simply never uploaded.
@@ -71,6 +78,26 @@ export function initTelemetry(cwd: string = process.cwd()): TelemetryConsent {
   return consent
 }
 
+/**
+ * Tell the user that a project-level telemetry key was read and not honoured.
+ *
+ * The same shape as `index.tsx`'s `projectModeSkipped` notice, and for the same
+ * reason: "ignored on purpose" and "never read your file" are the same silence
+ * from the outside — and this is the user's own line, in a file they can still
+ * open. Once per startup, on stderr, so it cannot corrupt stdout rendering.
+ *
+ * Not a permission prompt: the outcome is already final by the time this runs.
+ * It only removes the ambiguity about *why*.
+ */
+function announceIgnoredProjectKeys(consent: TelemetryConsent, cwd: string): void {
+  if (consent.ignoredProjectKeys.length === 0) return
+  const keys = consent.ignoredProjectKeys.map((k) => `telemetry.${k}`).join(', ')
+  process.stderr.write(
+    `⚠ Mipham Code: ignored ${keys} from ${settingsPathFor('project', cwd)}\n` +
+      `    (a repository may turn telemetry off, but must not turn it on or choose where it goes — set that in ${settingsPathFor('user', cwd)})\n`,
+  )
+}
+
 /**
  * Record a slash-command invocation.
  *

package/src/tools/exec/task.ts

@@ -112,6 +112,78 @@ function getBlockingIds(task: Task): string[] {
   })
 }
 
+/**
+ * Render the session's task list: status-grouped, availability-sorted, blockers marked.
+ *
+ * **One renderer, two readers.** The `list` action answers the model, and the
+ * `/tasks` panel answers the human — both show the same session registry, so
+ * both go through here. A second renderer for the panel would be the "two
+ * paths, one wired" mistake this repo has already paid for once.
+ */
+export function formatTaskList(): string {
+  const all = getTasks()
+  if (all.length === 0) return '(no tasks)'
+
+  // Sort by availability: in_progress → pending(available) → pending(blocked) → completed
+  const sortOrder: Record<string, number> = {
+    in_progress: 0,
+    pending: 1,
+    completed: 2,
+    failed: 3,
+  }
+
+  const sorted = [...all].sort((a, b) => {
+    const orderA = sortOrder[a.status] ?? 3
+    const orderB = sortOrder[b.status] ?? 3
+    if (orderA !== orderB) return orderA - orderB
+    // Within same status: available before blocked
+    if (a.status === 'pending' && b.status === 'pending') {
+      const aBlocked = isBlocked(a)
+      const bBlocked = isBlocked(b)
+      if (aBlocked !== bBlocked) return aBlocked ? 1 : -1
+    }
+    return 0
+  })
+
+  const lines: string[] = []
+  const statusLabels: Record<string, { emoji: string; label: string }> = {
+    in_progress: { emoji: '🔄', label: 'In Progress' },
+    pending: { emoji: '📋', label: 'Pending' },
+    completed: { emoji: '✅', label: 'Completed' },
+    failed: { emoji: '❌', label: 'Failed' },
+  }
+
+  let currentStatus = ''
+  for (const t of sorted) {
+    const statusInfo = statusLabels[t.status]
+    if (!statusInfo) continue
+
+    if (statusInfo.label !== currentStatus) {
+      currentStatus = statusInfo.label
+      // Count tasks in this status group
+      const count = sorted.filter((s) => statusLabels[s.status]?.label === currentStatus).length
+      lines.push(`${statusInfo.emoji} ${currentStatus} (${count}):`)
+    }
+
+    const blocked = isBlocked(t)
+    const prefix = blocked && t.status === 'pending' ? '🚫 ' : '  '
+    const blockingNote = blocked ? ` 🚫 阻塞中 (等待: ${getBlockingIds(t).join(', ')})` : ''
+    lines.push(`${prefix}${formatTask(t)}${blockingNote}`)
+  }
+
+  // Summary footer
+  const available = all.filter((t) => t.status === 'pending' && !isBlocked(t)).length
+  const blockedCount = all.filter((t) => t.status === 'pending' && isBlocked(t)).length
+  if (blockedCount > 0) {
+    lines.push('')
+    lines.push(
+      `📊 ${available} available · ${blockedCount} blocked · ${all.filter((t) => t.status === 'completed').length} done`,
+    )
+  }
+
+  return lines.join('\n')
+}
+
 export const taskTool: ToolDefinition = {
   name: 'Task',
   description:
@@ -205,67 +277,7 @@ export const taskTool: ToolDefinition = {
 
     // ── LIST ──
     if (action === 'list') {
-      const all = Array.from(tasks.values()).filter((t) => t.status !== 'deleted')
-      if (all.length === 0) return { success: true, content: '(no tasks)' }
-
-      // Sort by availability: in_progress → pending(available) → pending(blocked) → completed
-      const sortOrder: Record<string, number> = {
-        in_progress: 0,
-        pending: 1,
-        completed: 2,
-        failed: 3,
-      }
-
-      const sorted = [...all].sort((a, b) => {
-        const orderA = sortOrder[a.status] ?? 3
-        const orderB = sortOrder[b.status] ?? 3
-        if (orderA !== orderB) return orderA - orderB
-        // Within same status: available before blocked
-        if (a.status === 'pending' && b.status === 'pending') {
-          const aBlocked = isBlocked(a)
-          const bBlocked = isBlocked(b)
-          if (aBlocked !== bBlocked) return aBlocked ? 1 : -1
-        }
-        return 0
-      })
-
-      const lines: string[] = []
-      const statusLabels: Record<string, { emoji: string; label: string }> = {
-        in_progress: { emoji: '🔄', label: 'In Progress' },
-        pending: { emoji: '📋', label: 'Pending' },
-        completed: { emoji: '✅', label: 'Completed' },
-        failed: { emoji: '❌', label: 'Failed' },
-      }
-
-      let currentStatus = ''
-      for (const t of sorted) {
-        const statusInfo = statusLabels[t.status]
-        if (!statusInfo) continue
-
-        if (statusInfo.label !== currentStatus) {
-          currentStatus = statusInfo.label
-          // Count tasks in this status group
-          const count = sorted.filter((s) => statusLabels[s.status]?.label === currentStatus).length
-          lines.push(`${statusInfo.emoji} ${currentStatus} (${count}):`)
-        }
-
-        const blocked = isBlocked(t)
-        const prefix = blocked && t.status === 'pending' ? '🚫 ' : '  '
-        const blockingNote = blocked ? ` 🚫 阻塞中 (等待: ${getBlockingIds(t).join(', ')})` : ''
-        lines.push(`${prefix}${formatTask(t)}${blockingNote}`)
-      }
-
-      // Summary footer
-      const available = all.filter((t) => t.status === 'pending' && !isBlocked(t)).length
-      const blockedCount = all.filter((t) => t.status === 'pending' && isBlocked(t)).length
-      if (blockedCount > 0) {
-        lines.push('')
-        lines.push(
-          `📊 ${available} available · ${blockedCount} blocked · ${all.filter((t) => t.status === 'completed').length} done`,
-        )
-      }
-
-      return { success: true, content: lines.join('\n') }
+      return { success: true, content: formatTaskList() }
     }
 
     // ── GET ──

package/src/ui/commands.ts

@@ -11,7 +11,7 @@ import type { SkillsLoader } from '../skills/loader'
 import { loadSkillUsage } from '../skills/usage'
 import type { PluginManager } from '../plugin/plugin-manager'
 import type { Message } from '../shared/types.js'
-import type { UpdateStatus } from '../shared/update'
+import type { InstallState, UpdateStatus } from '../shared/update'
 import { McpClient } from '../mcp/client'
 import { unregisterMcpServerTools } from '../mcp/registry'
 import { buildCapabilityReport } from '../core/capability-inventory'
@@ -110,6 +110,7 @@ import { listActiveAutoloops, formatLoopRows } from '../commands/autoloop-journa
 import { execSync } from 'node:child_process'
 import { MIPHAM_DIR, OLLAMA_PRESET_MODELS } from '../shared/constants'
 import { renameActiveSession } from '../agent/cross-session/discovery'
+import { formatTaskList } from '../tools/exec/task'
 
 export interface CommandContext {
   engine: QueryEngine
@@ -2775,7 +2776,11 @@ const rewindCmd: CommandHandler = (ctx) => {
       count: String(result.messageCount),
       remaining: String(c.getCheckpoints().length),
     }),
+    // `clearMessages` 单用是 `/clear` 的形状（屏幕上**没有**该留的东西）；回退不一样 ——
+    // 留到那一点为止的历史仍然算数，只是屏幕上的那份旧了。不带 `forwardedMessages`
+    // 就会把消息列表清成空、再也不回填：模型看得见回退后的历史，用户看得见一片空白。
     clearMessages: true,
+    forwardedMessages: c.getMessages(),
   }
 }
 
@@ -2918,24 +2923,20 @@ const ultracodeCmd: CommandHandler = (ctx, args) => {
 
 const tasksCmd: CommandHandler = (ctx) => {
   const t = resolveT(ctx)
-  const c = ctx.engine.getContext()
-  const msgs = c.getMessages()
 
-  // Scan for task-related tool uses in message history.
-  // 任务工具只有一个 `Task`，动作走 action 参数 —— 过滤条件必须按真实工具名匹配，
-  // 否则计数恒为 0，「已检测到 N 次任务操作」这条分支永远不可达。
-  const toolUses = msgs.flatMap((m) => {
-    if (Array.isArray(m.content)) {
-      return m.content.filter((b) => b.type === 'tool_use' && b.name === 'Task')
-    }
-    return []
-  })
+  // 读**登记表**，不数历史。此前这个面板数的是历史里 `Task` 工具调用块的个数，
+  // 于是压缩掉历史之后（块没了、任务还在）它会说「尚未跟踪任何任务」，而没有任务
+  // 却有历史时又会说「检测到 N 次任务操作」。面板自称 "Background tasks"、标题写
+  // 「后台任务」、空态写「尚未跟踪任何任务」—— 全是登记表词汇，而登记表就在
+  // 一步之外（`getTasks()`，`GoalProgress` 早就接了）。
+  const taskList = formatTaskList()
+  const hasTasks = taskList !== '(no tasks)'
 
   return {
     content: stripIndent`
       ${t('commands.task_list.title')}
 
-      ${toolUses.length > 0 ? t('commands.task_list.detected', { count: String(toolUses.length) }) : t('commands.task_list.no_tasks')}
+      ${hasTasks ? taskList : t('commands.task_list.no_tasks')}
 
       ${t('commands.task_list.reference')}
         Task(action: "create")  — create a new task
@@ -4001,6 +4002,14 @@ const telemetryCmd: CommandHandler = async (ctx, args) => {
     `| Source | \`${consent.endpointSource}\` |`,
     `| Install id | ${settings.installId ?? '_(not yet generated)_'} |`,
     `| Prompted | ${settings.promptedAt ?? '_(never)_'} |`,
+    // Only when there is something to say. An always-present "Ignored: _(none)_"
+    // row would be noise in the common case, and this table is read when
+    // something already looks wrong.
+    ...(consent.ignoredProjectKeys.length > 0
+      ? [
+          `| Ignored from project | ${consent.ignoredProjectKeys.map((k) => `\`telemetry.${k}\``).join(', ')} — a repository may veto, not grant |`,
+        ]
+      : []),
     '',
     'Full data dictionary: `docs/telemetry.md`',
   ]
@@ -4438,6 +4447,21 @@ const memoryCmd: CommandHandler = async (ctx, args) => {
 // Upgrade
 // ═══════════════════════════════════════════════════════════════
 
+/**
+ * 失败后「我手里还有没有 CLI」这句话的四种说法。
+ *
+ * `Record<InstallState, …>` 而非内联三元：漏一个状态**编译期就红**。写成
+ * `result.rolledBack ? A : B` 时漏掉的那一格会静默落进 else，而 else 说的正是**最重的
+ * 那句**（「原安装未能恢复」）—— 拿「最坏情况」当兜底，就等于把每条没想清楚的路径都
+ * 报成灾难。
+ */
+const UPGRADE_FAILURE_NOTE: Record<InstallState, string> = {
+  untouched: 'commands.upgrade.install_untouched',
+  restored: 'commands.upgrade.rolled_back',
+  broken: 'commands.upgrade.no_rollback',
+  unknown: 'commands.upgrade.install_unknown',
+}
+
 const upgradeCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
   const { checkForUpdates, backupConfig, performUpdate, restoreConfig, getConfigPath } =
@@ -4500,10 +4524,9 @@ const upgradeCmd: CommandHandler = async (ctx) => {
     lines.push(t('commands.upgrade.old_version_warning'))
   } else {
     lines.push('')
-    // 失败信息必须回答两件事：为什么，以及**我手里还有没有 CLI**。
-    const rollbackNote = t(
-      result.rolledBack ? 'commands.upgrade.rolled_back' : 'commands.upgrade.no_rollback',
-    )
+    // 失败信息必须回答两件事：为什么，以及**我手里还有没有 CLI**。四态各有各的说法 ——
+    // 尤其「旧树没被碰过」与「旧树没能恢复」是两件不同的事，合并成一句后者必定说谎。
+    const rollbackNote = t(UPGRADE_FAILURE_NOTE[result.installState])
     lines.push(
       t('commands.upgrade.update_failed', {
         reason: result.reason ?? '',

package/src/ui/graft-status.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from 'react'
+import React, { useEffect, useState } from 'react'
 import { Box, Text } from 'ink'
 import { basename } from 'node:path'
 import { findGraftStats, type GraftStats } from '../shared/graft-stats'
@@ -13,17 +13,46 @@ function freshnessSegment(stats: GraftStats): { label: string; color: string } {
   return { label: '✓ synced', color: 'blue' }
 }
 
+/**
+ * 只有**真变了**才换 state —— 否则每秒一次 setState 会把整棵树重渲染一遍。
+ * 两侧都出自 `findGraftStats` 的同一个 return 字面量，键序恒等，故字符串比较是稳的；
+ * 用整体比较而不是逐字段比，是为了将来给 `GraftStats` 加字段时**不必回来补这一行**。
+ */
+function sameStats(a: GraftStats | null, b: GraftStats | null): boolean {
+  if (a === b) return true
+  if (!a || !b) return false
+  return JSON.stringify(a) === JSON.stringify(b)
+}
+
+/** 重读间隔。与 `goal-progress` / `workflow-progress` 同法（那两处也是 1s 一拍）。 */
+const STATS_REFRESH_MS = 1000
+
 /**
  * Bottom-of-screen graft status line — mirrors graft's own "◤ graft · …" bar:
  *   ◤ graft · N nodes / E edges · ✓ synced · ~T tok saved
  *   ▸ ctx X% · last: file
- * Reads `graft/.cache/stats.json` (walking up to the repo root) once at mount;
- * the session's tok-saved total is read live each render (the app re-renders on
- * the agent tick). Renders nothing only when there's no graft graph AND no known
- * ctx% — the ctx% line shows even when graft isn't built in this directory.
+ *
+ * `graft/.cache/stats.json`（向上走到仓库根）是**别人在后台写的**：graft 自己重建索引时
+ * 先落 `syncing: true`，建完再落回来。挂载时读一次就永远说那一拍的话 ⇒ 启动正好撞上索引
+ * 重建的话，页脚会一直挂着 `syncing…`，而磁盘上早已 `"syncing": false` ——「有人的读数与
+ * 没人读的那个对象不一致」。故这里**按拍重读**。
+ *
+ * 别把它降成「每次渲染读一遍」：那要靠别的组件把这一棵带着重渲染（敲键盘 / agent tick）
+ * 才生效，而索引建完的那一刻**恰恰可能一个键都没有** —— 页脚会一直撒谎到用户下次敲键。
+ *
+ * 其余同前：tok-saved 每次渲染实时读；只在有 graft 图或有已知 ctx% 时渲染 —— ctx% 行
+ * 在本目录没建过 graft 时也照常显示。
  */
 export function GraftStatusLine({ cwd, ctxPct }: { cwd: string; ctxPct?: number }) {
-  const [stats] = useState(() => findGraftStats(cwd))
+  const [stats, setStats] = useState(() => findGraftStats(cwd))
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      const next = findGraftStats(cwd)
+      setStats((prev) => (sameStats(prev, next) ? prev : next))
+    }, STATS_REFRESH_MS)
+    return () => clearInterval(timer)
+  }, [cwd])
   const showCtx = typeof ctxPct === 'number'
   if (!stats && !showCtx) return null
   const fresh = stats ? freshnessSegment(stats) : null

package/src/ui/input.tsx

@@ -324,7 +324,12 @@ export function InputBar({
   const suggestionReqIdRef = useRef(0)
 
   // 统一清理：清 suggestion + 使在途/待发请求失效 + 取消防抖定时器。
-  // Escape / handleSubmit / 翻历史三处共用，避免各自手写漏掉某一环（rule of three）。
+  // Escape / handleSubmit / 翻历史 / **Tab 接受** 四处共用，避免各自手写漏掉某一环。
+  // Tab 那一处原先只手写 `setSuggestion(null)`（ROADMAP D8 缺口③）：今天**不可达**
+  // ——有建议显示就说明上次请求已结束、定时器早烧掉了——但「接受后继续续写」一加上，
+  // 那个漏掉的环立刻变成洞。走同一入口，洞就不存在了。
+  // （`onChange` 里另有一处内联的同样三步，**不共用**：那里要的是把 reqId 推成**新**的，
+  // 与这里的「作废」是两件事。）
   const clearSuggestion = () => {
     setSuggestion(null)
     suggestionReqIdRef.current++
@@ -411,7 +416,7 @@ export function InputBar({
       const next = valueRef.current + suggestion
       setValue(next)
       valueRef.current = next
-      setSuggestion(null)
+      clearSuggestion()
       return
     }
     // Ctrl+P → toggle model picker

package/src/ui/picker.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useCallback } from 'react'
+import React, { useCallback } from 'react'
 import { Box, Text, useInput } from 'ink'
 import { useI18n } from '../i18n-context'
 import { useKeyState } from './use-key-state'
@@ -34,7 +34,11 @@ export function ModelPicker({
   const providers = config.providers.filter((p) => p.status !== 'upcoming')
 
   // State
-  const [activePanel, setActivePanel] = useState<Panel>('provider')
+  // 面板选择同样走 `useKeyState` —— 它与两个光标是**同一次按键里一起判读**的。
+  // 反例是「Tab ↓ Enter」一次刷进来：Ink 把 Tab 之后那段也拆成两拍，于是 ↓ 与
+  // Enter 都还在按**切换之前**那一拍算 —— ↓ 去动 provider 光标，Enter 走
+  // `goToProvider`（provider 面板上那条路）⇒ 一次都没选中。
+  const activePanel = useKeyState<Panel>('provider')
   // 光标走 `useKeyState`：一组按键可能在同一拍里到达（↓ 之后紧跟 Enter），判据必须
   // 读得到本次按键刚写下的那个索引，而不是上一张闭包里的。
   const providerIdx = useKeyState(() => {
@@ -51,7 +55,7 @@ export function ModelPicker({
     (idx: number) => {
       providerIdx.set(wrap(idx, providers.length))
       modelIdx.set(0)
-      setActivePanel('model') // auto-switch to model panel
+      activePanel.set('model') // auto-switch to model panel
     },
     [providers.length, providerIdx, modelIdx],
   )
@@ -93,7 +97,7 @@ export function ModelPicker({
     }
 
     if (key.return) {
-      if (activePanel === 'provider') {
+      if (activePanel.read() === 'provider') {
         goToProvider(providerIdx.read()) // switches to model panel
       } else {
         confirmSelection()
@@ -102,20 +106,20 @@ export function ModelPicker({
     }
 
     // Tab or right arrow → switch to model panel
-    if (key.tab || (activePanel === 'provider' && input === 'l')) {
-      setActivePanel('model')
+    if (key.tab || (activePanel.read() === 'provider' && input === 'l')) {
+      activePanel.set('model')
       return
     }
 
     // Left arrow → switch to provider panel
-    if (key.leftArrow || (activePanel === 'model' && input === 'h')) {
-      setActivePanel('provider')
+    if (key.leftArrow || (activePanel.read() === 'model' && input === 'h')) {
+      activePanel.set('provider')
       return
     }
 
     // Up/Down navigation
     if (key.upArrow) {
-      if (activePanel === 'provider') {
+      if (activePanel.read() === 'provider') {
         providerIdx.set((prev) => wrap(prev - 1, providers.length))
       } else {
         stepModel(-1)
@@ -124,7 +128,7 @@ export function ModelPicker({
     }
 
     if (key.downArrow) {
-      if (activePanel === 'provider') {
+      if (activePanel.read() === 'provider') {
         providerIdx.set((prev) => wrap(prev + 1, providers.length))
       } else {
         stepModel(1)
@@ -153,11 +157,11 @@ export function ModelPicker({
           flexDirection="column"
           width={28}
           borderStyle="single"
-          borderColor={activePanel === 'provider' ? 'cyan' : 'gray'}
+          borderColor={activePanel.value === 'provider' ? 'cyan' : 'gray'}
           padding={1}
         >
           <Text bold underline dimColor>
-            {t('ui.picker.provider_label')} {activePanel === 'provider' ? '◀' : ''}
+            {t('ui.picker.provider_label')} {activePanel.value === 'provider' ? '◀' : ''}
           </Text>
           {providers.map((p, i) => {
             const isCurrent = p.id === currentProvider
@@ -186,11 +190,11 @@ export function ModelPicker({
           flexDirection="column"
           width={42}
           borderStyle="single"
-          borderColor={activePanel === 'model' ? 'cyan' : 'gray'}
+          borderColor={activePanel.value === 'model' ? 'cyan' : 'gray'}
           padding={1}
         >
           <Text bold underline dimColor>
-            {t('ui.picker.models_label')} {activePanel === 'model' ? '◀' : ''}
+            {t('ui.picker.models_label')} {activePanel.value === 'model' ? '◀' : ''}
             {selectedProvider ? ` — ${selectedProvider.name}` : ''}
           </Text>
           {models.length === 0 && <Text dimColor> {t('ui.picker.no_active_models')}</Text>}
@@ -221,7 +225,7 @@ export function ModelPicker({
       {/* Footer hint */}
       <Box marginTop={1}>
         <Text dimColor>
-          {activePanel === 'provider'
+          {activePanel.value === 'provider'
             ? t('ui.picker.select_provider_hint')
             : t('ui.picker.select_model_hint')}
         </Text>

package/src/workflow/primitives/agent.ts

@@ -46,13 +46,6 @@ export async function workflowAgent(
   opts: WorkflowAgentOpts = {},
   llm?: Llm,
 ): Promise<unknown> {
-  // If provider override, switch temporarily
-  if (opts.provider) {
-    registry.switchProvider(opts.provider, opts.model)
-  } else if (opts.model) {
-    registry.switchProvider(registry.getActive().config.id, opts.model)
-  }
-
   const maxRetries = opts.maxRetries ?? 2
 
   // ── Worktree isolation setup ──
@@ -93,7 +86,26 @@ export async function workflowAgent(
   let lastResult = ''
   let lastErrors: string[] = []
 
+  /** Set only when we actually switched — and then it is the way back. */
+  let restore: (() => void) | undefined
+
   try {
+    // ── Provider override, scoped to this call ──
+    // 「临时」必须是真的。registry 的 active 是**会话级**的：`SubAgent` 在
+    // `runExecution` 里读 `registry.getActiveModel()`、`registry.chat` 按 active 路由，
+    // 引擎的页脚与 `/model` 面板读的也是它 —— 覆盖不还原，等于一个 workflow 里的一次
+    // `agent(…, { provider: 'x' })` 把整台机器的会话换到 x 上。
+    //
+    // 切在这里而不是函数开头：上面那段建 worktree 会抛（`git worktree add` 非 0 即
+    // throw），抛在切走之前就不该已经切走。
+    if (opts.provider || opts.model) {
+      const prevProviderId = registry.getActive().config.id
+      const prevModelId = registry.getActiveModel()
+      // `opts.provider` 缺席时只换模型 —— provider 保持这一次调用开始时的那一个。
+      registry.switchProvider(opts.provider ?? prevProviderId, opts.model)
+      restore = () => registry.switchProvider(prevProviderId, prevModelId)
+    }
+
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       const retryPrompt =
         attempt === 0
@@ -158,6 +170,10 @@ export async function workflowAgent(
 
     return result
   } finally {
+    // 还原排在 finally 的**第一件**：下面的 worktree 清理要 spawn git、还可能抛，
+    // 排在它之后就等于「清理顺利时才还原」—— 而那正是最不需要还原的场合。
+    restore?.()
+
     // ── Cleanup worktree ──
     if (worktreePath) {
       // Best-effort: auto-commit any changes