@miphamai/cli 0.85.6 → 0.85.7

package/package.json

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

package/src/agent-view/dashboard.tsx

@@ -31,6 +31,13 @@ const STATUS_HEADERS: Record<string, { label: string; color: string }> = {
 }
 
 export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps) {
+  // 这里**刻意**不迁 `useKeyState`（picker / config-wizard / command-picker 都迁了）。
+  // 那些地方的病是「一次刷进来的按键作用在上一拍的行上」，而 Ink 只在 chunk **以转义
+  // 序列打头**时才把它拆成多个事件 —— 所以能撞上的是方向键（`\x1b[B` + `\r` 拆成两拍）。
+  // 本面板的键全是普通字符（j / k / space / Enter / Ctrl+X / Ctrl+R / Ctrl+T），一起到达
+  // 时会**合并成一个**事件（实测 `'j\r'` → 单个 `input="j\r"`、`key.return` 为 false），
+  // 两个分支都不匹配 ⇒ 症状是「这一拍什么也没发生」，不是「作用在上一行」。
+  // 换句话说这一格没有可复现的故障，迁过去只会让测试**改前改后都绿**。
   const [selectedIndex, setSelectedIndex] = useState(0)
   const [peekingSessionId, setPeekingSessionId] = useState<string | null>(null)
   const [groupBy, setGroupBy] = useState<'status' | 'directory'>('status')

package/src/core/context.ts

@@ -30,7 +30,6 @@ export interface CompactionStats {
 interface Checkpoint {
   id: number
   messages: Message[]
-  estimatedTokens: number
   timestamp: Date
   label: string
 }
@@ -52,7 +51,22 @@ export class ContextManager {
    * 组装时烘进去的话，本次会话里后连上的 server 永远进不了提示 —— 用户只能重启。
    */
   private mcpInstructionsSource: (() => string) | null = null
-  private estimatedTokens = 0
+  /**
+   * **消息那部分**的估值，增量累加（提示那部分见 `promptTokens()`，读时派生）。
+   *
+   * 两份分开是因为它们的变化条件不同：消息只在本类里变（每次 push 顺手加一笔就够了），
+   * 而提示里的两段是**读时闭包**、变点不在这条类里（见上面两个 source 的注释）。
+   * 把两者混在一个累加器里，闭包那半就必然滞后 —— 这正是本类此前的缺陷。
+   */
+  private messageTokens = 0
+  /**
+   * `promptTokens()` 的记忆化。键**就是**那份拼好的提示本身，所以不存在失效问题：
+   * 「键没变而值该变」需要的恰恰是「输入没变而输出该变」，不可能发生。
+   *
+   * 记忆化只是别在每次 `addMessage` 里把同一份四万字符的系统提示重扫一遍
+   * （`checkCompression()` 会读估值，它在每条消息上都被调一次）。
+   */
+  private promptTokensCache: { text: string; tokens: number } | null = null
   private checkpoints: Checkpoint[] = []
   private checkpointCounter = 0
   private summarizer?: Summarizer
@@ -93,7 +107,7 @@ export class ContextManager {
     // 否则「模型看得见的必须已记录」这条不变量当场破），见 `closeInterruptedToolCalls`。
     closeInterruptedToolCalls(log)
     this.messages = deriveMessages(log.events())
-    this.reEstimateTokens()
+    this.recountMessageTokens()
   }
 
   /**
@@ -137,11 +151,13 @@ export class ContextManager {
 
   setSystemPrompt(prompt: string): void {
     this.systemPrompt = prompt
-    // 估值必须**含 messages** —— 走 `reEstimateTokens()` 这一条唯一推导，别在这儿手写
-    // 第二份。`--resume` 路径（`index.tsx:584-585`）先 `restoreLog()` 算出含消息的完整
-    // 估值，紧接着调这里；只按系统提示重算会把它**覆盖成偏低值** ⇒ `needsCompaction()`
-    // 长期偏 false ⇒ 压缩迟触发（上下文越滚越大才动手）。
-    this.reEstimateTokens()
+    // 这里**故意什么都不算**。提示那部分由 `promptTokens()` 读时派生，消息那部分由
+    // `messageTokens` 自己带着 —— 所以「设提示」这件事对估值**没有可出错的空间**。
+    //
+    // 从前这里要重算一次，且必须记得「重算要含消息」：`--resume` 路径
+    // （`index.tsx:584-585`）先 `restoreLog()` 得出含消息的估值、紧接着设提示，只按
+    // 提示重算就会把它覆盖成偏低值。那是个**要靠注释守住的契约**；现在它不可能被违反
+    // —— 没有任何一条路径能在这里把消息那半丢掉。
   }
 
   /**
@@ -185,7 +201,7 @@ export class ContextManager {
 
   addMessage(msg: Message): void {
     this.messages.push(msg)
-    this.estimatedTokens += this.estimateTokens(
+    this.messageTokens += this.estimateTokens(
       typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
     )
 
@@ -212,7 +228,7 @@ export class ContextManager {
    */
   injectContext(source: string, text: string): void {
     this.messages.push({ role: 'user', content: text })
-    this.estimatedTokens += this.estimateTokens(text)
+    this.messageTokens += this.estimateTokens(text)
 
     if (this.log) {
       this.log.append({ type: 'context/inject', at: Date.now(), source, text })
@@ -241,7 +257,7 @@ export class ContextManager {
       ],
     }
     this.messages.push(msg)
-    this.estimatedTokens += this.estimateTokens(JSON.stringify(msg.content))
+    this.messageTokens += this.estimateTokens(JSON.stringify(msg.content))
     if (this.log) this.log.append({ type: 'tool/result', at: Date.now(), id: toolUseId, result })
     this.checkCompression()
   }
@@ -262,7 +278,7 @@ export class ContextManager {
     if (this.log) {
       for (const m of messages) for (const e of messageToEvents(m, Date.now())) this.log.append(e)
     }
-    this.reEstimateTokens()
+    this.recountMessageTokens()
 
     if (this.log && isAssertModelVisibleDebug()) {
       assertModelVisible(this.log.events(), this.messages)
@@ -274,11 +290,11 @@ export class ContextManager {
   }
 
   needsCompaction(): boolean {
-    return this.estimatedTokens > this.config.maxTokens * this.config.compactionThreshold
+    return this.getEstimatedTokens() > this.config.maxTokens * this.config.compactionThreshold
   }
 
   async compact(heading: string): Promise<{ before: number; after: number }> {
-    const beforeTokens = this.estimatedTokens
+    const beforeTokens = this.getEstimatedTokens()
 
     if (this.messages.length <= 30) {
       return { before: beforeTokens, after: beforeTokens }
@@ -322,26 +338,27 @@ export class ContextManager {
       }
     }
 
-    // Re-estimate tokens
-    this.estimatedTokens = this.estimateTokens(this.composedSystemPrompt())
-    for (const msg of this.messages) {
-      this.estimatedTokens += this.estimateTokens(
-        typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-      )
-    }
+    // Re-estimate the message half (the prompt half is derived on read).
+    this.recountMessageTokens()
 
-    return { before: beforeTokens, after: this.estimatedTokens }
+    return { before: beforeTokens, after: this.getEstimatedTokens() }
   }
 
+  /**
+   * 当前会话的估算 token 数 = **消息那半（累加）+ 提示那半（读时派生）**。
+   *
+   * 提示那半必须在读数这一刻才拼：`systemPrompt`、权限段、MCP instructions 段三者任一
+   * 变了都该反映出来，而其中两段的变点在调用方（见字段注释）—— 派生就没有变点要枚举。
+   */
   getEstimatedTokens(): number {
-    return this.estimatedTokens
+    return this.messageTokens + this.promptTokens()
   }
 
   clear(): void {
     this.messages = []
     this.checkpoints = []
     this.checkpointCounter = 0
-    this.estimatedTokens = this.estimateTokens(this.composedSystemPrompt())
+    this.messageTokens = 0
   }
 
   getMessageCount(): number {
@@ -356,13 +373,8 @@ export class ContextManager {
    */
   replaceMessages(messages: Message[]): void {
     this.messages = messages
-    // Re-estimate tokens
-    this.estimatedTokens = this.estimateTokens(this.composedSystemPrompt())
-    for (const msg of messages) {
-      this.estimatedTokens += this.estimateTokens(
-        typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-      )
-    }
+    // Re-estimate the message half (the prompt half is derived on read).
+    this.recountMessageTokens()
   }
 
   // ── Checkpoint / Rewind ──
@@ -372,7 +384,6 @@ export class ContextManager {
     const checkpoint: Checkpoint = {
       id: this.checkpointCounter,
       messages: structuredClone(this.messages),
-      estimatedTokens: this.estimatedTokens,
       timestamp: new Date(),
       label,
     }
@@ -399,7 +410,21 @@ export class ContextManager {
     }
 
     this.messages = structuredClone(target.messages)
-    this.estimatedTokens = target.estimatedTokens
+    // 估值从**刚恢复出来的这份消息**重算，而不是从快照里存的一个数还原：存下来的数
+    // 是「同一件事的第二份拷贝」，它会与消息各自漂移，而消息本身就是唯一真源。
+    this.recountMessageTokens()
+    // 回退改写的是**投影的整份内容**，所以它必须落成事件：日志是 `--resume` / `/resume`
+    // 重建历史的唯一来源，不记这一次改写，被回退掉的那一轮会在下次恢复时原样回来。
+    // 走与 `addMessage` 同一条写通路径（先入日志、再断言）—— 断言因此也从「前缀匹配」
+    // 变成「逐条相等」，回退不再是断言的一个盲区。
+    // 传快照副本：`append` 只按引用入 buf，序列化推迟到 `save()`，共用同一个数组会让
+    // 之后对 `this.messages` 的原地修改回写进已入队的事件里。
+    if (this.log) {
+      this.log.append({ type: 'rewind', at: Date.now(), messages: structuredClone(this.messages) })
+      if (isAssertModelVisibleDebug()) {
+        assertModelVisible(this.log.events(), this.messages)
+      }
+    }
     return { restored: true, messageCount: this.messages.length, label: target.label }
   }
 
@@ -451,7 +476,7 @@ export class ContextManager {
   private checkCompression(): void {
     if (this.compressionPending) return
 
-    const usage = this.estimatedTokens / this.config.maxTokens
+    const usage = this.getEstimatedTokens() / this.config.maxTokens
 
     // Adaptive microcompact threshold: 200K→0.70, 500K→0.80, 1M→0.85
     const microThreshold = this.config.contextWindow
@@ -497,19 +522,30 @@ export class ContextManager {
     } else {
       this.messages = compacted
     }
-    this.reEstimateTokens()
+    this.recountMessageTokens()
   }
 
-  /** Re-estimate tokens from system prompt + current messages. */
-  private reEstimateTokens(): void {
-    this.estimatedTokens = this.estimateTokens(this.composedSystemPrompt())
+  /** 从当前消息**重算消息那半**的估值（提示那半不在这里 —— 它是读时派生的）。 */
+  private recountMessageTokens(): void {
+    this.messageTokens = 0
     for (const msg of this.messages) {
-      this.estimatedTokens += this.estimateTokens(
+      this.messageTokens += this.estimateTokens(
         typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
       )
     }
   }
 
+  /** 提示那半的估值 —— 每次读数现拼现算，见 `getEstimatedTokens()`。 */
+  private promptTokens(): number {
+    const text = this.composedSystemPrompt()
+    const cached = this.promptTokensCache
+    if (cached && cached.text === text) return cached.tokens
+
+    const tokens = this.estimateTokens(text)
+    this.promptTokensCache = { text, tokens }
+    return tokens
+  }
+
   /**
    * Estimate token count for a text string.
    *

package/src/core/session-log.ts

@@ -23,6 +23,9 @@ export type SessionEvent =
   | { type: 'context/inject'; at: number; source: string; text: string }
   | { type: 'compaction/summary'; at: number; summary: string; replacedCount: number }
   | { type: 'compaction/rewrite'; at: number; messages: Message[] }
+  // 回退（`/rewind`）。投影语义与 `compaction/rewrite` 相同（整份快照替换），但**不是压缩**：
+  // 合用一个类型会让「这份日志里哪些轮被摘要过」的答案变成错的。
+  | { type: 'rewind'; at: number; messages: Message[] }
   | { type: 'checker/decision'; at: number; toolName: string; decision: CheckerDecision }
 
 export function messageToEvents(msg: Message, at = 0): SessionEvent[] {
@@ -110,6 +113,9 @@ export function deriveMessages(events: SessionEvent[]): Message[] {
     } else if (e.type === 'compaction/rewrite') {
       // 快照替换：整个投影重建（微压缩/截断等结构性编辑的字节级复现）
       out = structuredClone(e.messages)
+    } else if (e.type === 'rewind') {
+      // 回退同样是快照替换：整份投影重建为回退到的那一点
+      out = structuredClone(e.messages)
     }
     // 'session/start' / 'checker/decision' → 无消息（决策仅记录证据，不进投影，保字节级可逆）
   }
@@ -311,6 +317,9 @@ function isValidEvent(e: unknown): e is SessionEvent {
     case 'compaction/rewrite':
       // 快照替换：整份投影由它重建 ⇒ 元素形状与 message 事件同罪
       return Array.isArray(ev.messages) && ev.messages.every(isValidMessage)
+    case 'rewind':
+      // 同上：回退也是整份投影替换，坏元素同样会让投影崩
+      return Array.isArray(ev.messages) && ev.messages.every(isValidMessage)
     default:
       return true
   }

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

@@ -186,7 +186,6 @@
     },
     "task_list": {
       "title": "── Background Tasks ──",
-      "detected": "{count} task operations detected in this session.\n\nUse the Task tool (action \"create\" / \"update\" / \"list\") to manage structured task tracking.",
       "no_tasks": "No tasks tracked yet. Use the Task tool with action \"create\", \"update\", or \"list\" to manage structured tasks.",
       "reference": "Quick reference:",
       "legacy_hint": "Type /todos for the legacy task interface."

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

@@ -186,7 +186,6 @@
     },
     "task_list": {
       "title": "── 后台任务 ──",
-      "detected": "在此会话中检测到 {count} 次任务操作。\n\n使用 Task 工具（action \"create\" / \"update\" / \"list\"）管理结构化任务跟踪。",
       "no_tasks": "尚未跟踪任何任务。使用 Task 工具的 action \"create\"、\"update\" 或 \"list\" 管理结构化任务。",
       "reference": "快速参考:",
       "legacy_hint": "输入 /todos 使用旧版任务界面。"

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.85.6' as const
+export const PACKAGE_VERSION = '0.85.7' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const
@@ -90,4 +90,4 @@ export const TOOL_COUNT = 31 as const
  * —— `test/e2e/full-pipeline.test.ts` 在 Linux 上整文件 skip、在 macOS 上跑 ——
  * 但**总数相同**（两边都把被 skip 的算进去）。
  */
-export const TEST_COUNT = 3506 as const
+export const TEST_COUNT = 3535 as const

package/src/telemetry/consent.ts

@@ -31,6 +31,15 @@ export interface TelemetrySettings {
 /** Why telemetry ended up on or off — surfaced by `/telemetry status`. */
 export type ConsentSource = 'env-off' | 'project-veto' | 'user-optin' | 'default-off'
 
+/**
+ * 项目级文件里**写了、但按设计不采纳**的键。
+ *
+ * 只有这两档词汇：`enabled: true`（项目不能授予同意）与非空 `endpoint`（项目不能选
+ * 目的地）。`installId` / `promptedAt` 不在内 —— 那两键由本工具写进**用户**文件，
+ * 出现在项目文件里是「键写错了」，报成「一档被拒绝」只会把人引偏。
+ */
+export type ProjectIgnoredKey = 'enabled' | 'endpoint'
+
 export interface TelemetryConsent {
   enabled: boolean
   endpoint: string
@@ -43,6 +52,28 @@ export interface TelemetryConsent {
    * user debugging an unexpected destination needs the second one.
    */
   endpointSource: EndpointSource | 'off'
+  /**
+   * 项目级文件里声明了、而**没有生效**的键（按 `enabled` → `endpoint` 固定序）。
+   *
+   * 为什么要有这个名单：「按设计不采纳」与「压根没读你的文件」从外面看是**同一片
+   * 沉默**，而这是用户自己写下的字，就在他还能看见的那个文件里。兄弟形状见
+   * `config/loader.ts` 的 `projectModeSkipped` —— 同一条理由，同一句公告。
+   *
+   * 为什么不干脆采纳：项目这一档只许**收紧**（`enabled: false` 是否决）。采纳
+   * `endpoint` 等于克隆一个仓库就把用户已 opt-in 的遥测改道到仓库指定的收集器，
+   * 与「项目不能授予同意」是同一件事的两种写法。
+   *
+   * 空串不算声明 —— 名单要说的是「你写了 X 而它不生效」，不是「这个键存在过」。
+   */
+  ignoredProjectKeys: ProjectIgnoredKey[]
+}
+
+/** 项目文件里声明了这两档词汇的那些键（顺序固定，与文件里的书写顺序无关）。 */
+function declaredProjectKeys(project: TelemetrySettings): ProjectIgnoredKey[] {
+  const keys: ProjectIgnoredKey[] = []
+  if (project.enabled === true) keys.push('enabled')
+  if (typeof project.endpoint === 'string' && project.endpoint !== '') keys.push('endpoint')
+  return keys
 }
 
 /**
@@ -93,6 +124,12 @@ export function readTelemetrySettings(
  * consenting on the user's behalf. Same shape as the existing
  * `permissionRestrictions` fail-closed downgrade.
  *
+ * **The withholding is reported, not silent.** A project that declared
+ * `enabled: true` or a destination gets those keys named back to it in
+ * `ignoredProjectKeys` — from the outside, "ignored on purpose" and "never read
+ * your file" are the same silence, and the user is the one who wrote those
+ * lines, in a file they can still see.
+ *
  * There is intentionally no env var that grants consent. Consent has to be a
  * persistent, deliberate act (the first-run prompt or `/telemetry on`) — env
  * vars are inherited by child processes and end up in CI logs, so they must not
@@ -102,21 +139,30 @@ export function resolveTelemetry(
   cwd: string = process.cwd(),
   env: NodeJS.ProcessEnv = process.env,
 ): TelemetryConsent {
+  // The kill switch is resolved first and reads no file at all — so there is no
+  // project-tier declaration to report here, not even an unread one.
   if (isHardDisabled(env)) {
-    return { enabled: false, endpoint: '', source: 'env-off', endpointSource: 'off' }
+    return {
+      enabled: false,
+      endpoint: '',
+      source: 'env-off',
+      endpointSource: 'off',
+      ignoredProjectKeys: [],
+    }
   }
 
   const user = readTelemetrySettings('user', cwd)
   const project = readTelemetrySettings('project', cwd)
   const { endpoint, source: endpointSource } = resolveEndpoint(user.endpoint, env)
+  const ignoredProjectKeys = declaredProjectKeys(project)
 
   if (project.enabled === false) {
-    return { enabled: false, endpoint, source: 'project-veto', endpointSource }
+    return { enabled: false, endpoint, source: 'project-veto', endpointSource, ignoredProjectKeys }
   }
   if (user.enabled === true) {
-    return { enabled: true, endpoint, source: 'user-optin', endpointSource }
+    return { enabled: true, endpoint, source: 'user-optin', endpointSource, ignoredProjectKeys }
   }
-  return { enabled: false, endpoint, source: 'default-off', endpointSource }
+  return { enabled: false, endpoint, source: 'default-off', endpointSource, ignoredProjectKeys }
 }
 
 function patchUserTelemetry(patch: TelemetrySettings, cwd: string): void {

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

@@ -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`',
   ]

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