@leviyuan/lodestar 0.1.0 → 0.1.2

package/README.md

@@ -18,7 +18,7 @@ AI 不是帮手，是倍率。它放大的不是体力，是你——你的直
 
 - 在群里发任意文字 — Claude 接管这一轮，回复以**流式打字机**实时渲染在一张飞书卡片里。
 - 思考过程、每一次工具调用都在卡片里被收纳为**可展开折叠面板**：折起来是概述，展开是详情。你随时能审阅它在做什么。
-- 需要授权的操作（执行命令、修改文件……）会单独弹一张橙色**权限卡片**，你在群里点 `允许` / `始终允许` / `拒绝` 就行。
+- 需要授权的操作（执行命令、修改文件……）**就在原来那一格工具调用面板里**升级为 🔐 等审批状态，三颗按钮 `允许` / `始终允许` / `拒绝` 直接内嵌在面板里 — 不再弹独立卡片，决策结果与后续 output 串在同一条时序里。默认 `bypassPermissions`，所以这一格只在 SDK 真的拦下来时才出现。
 - **图片、文件双向互传**：用户发到群里的图/文件，Claude 通过消息里的 `[file: /abs/path]` 提示就能读；Claude 想把文件发回来，在回复任意位置写 `[[send: /abs/path]]`，标记会被剥离，文件以独立消息出现在群里。出站路径限制在该会话的工作目录、`/tmp/lodestar-*` 与 inbox 之内，`/etc`、`~/.ssh`、`~/.config` 等敏感目录被白名单拒绝。
 - 一轮跑完，卡片合上、可转发；下一句话开新一轮。
 
@@ -28,7 +28,7 @@ AI 不是帮手，是倍率。它放大的不是体力，是你——你的直
 
 | 指令 | 行为 |
 | --- | --- |
-| `hi` | 未运行时启动；运行中弹一张**控制台卡片**（状态行 + 中断/clear/终止/ls 按钮） |
+| `hi` | 未运行时启动；运行中弹一张**状态卡片**（model · 上下文占用 · 累计 tokens/cost · 上一轮 delta · session id） |
 | `kill` | 优雅关闭 Claude 进程；记住 `sessionId`，下次 `restart` 还能 resume |
 | `restart` | 用上一次的 `sessionId` 重启会话（保留上下文） |
 | `clear` | 杀掉进程并启动一个全新 session（等价于 Claude Code 的 `/clear`） |
@@ -68,10 +68,14 @@ projects_root = "~/"        # 可选，新建群对应的项目目录会落到
 ### 3. 启动
 
 ```bash
-git clone https://github.com/leviyuan/lodestar.git ~/lodestar
-cd ~/lodestar
-bun install
-bun daemon.ts
+bun install -g @leviyuan/lodestar
+lodestar-daemon
+```
+
+或者一次性跑（无需全局安装）：
+
+```bash
+bunx @leviyuan/lodestar
 ```
 
 把机器人拉进任意飞书群，发一条消息——Claude 就上线了。
@@ -89,7 +93,7 @@ After=network-online.target
 
 [Service]
 Type=simple
-ExecStart=/home/USER/.bun/bin/bun /home/USER/lodestar/daemon.ts
+ExecStart=/home/USER/.bun/bin/lodestar-daemon
 Restart=always
 RestartSec=3
 

package/daemon.ts

@@ -140,6 +140,9 @@ async function handleCardAction(data: any): Promise<any> {
     case 'menu':
       await session.onUserMessage(`(menu choice ${value.choice + 1})`)
       return { toast: { type: 'success', content: 'OK' } }
+    case 'ask':
+      await session.onAskAnswer(value.tool_use_id, value.question_idx ?? 0, value.option_idx, userId)
+      return { toast: { type: 'success', content: '已回答' } }
   }
   return { toast: { type: 'info', content: 'unknown action' } }
 }
@@ -152,6 +155,7 @@ function fmt(m: any[]): string {
 async function boot(): Promise<void> {
   log(`lodestar-daemon: pid ${process.pid} starting`)
   feishu.loadSessionChatMap()
+  feishu.loadSessionResumeMap()
   await feishu.refreshChatList()
   setInterval(() => { void feishu.refreshChatList() }, 5 * 60 * 1000)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leviyuan/lodestar",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "publishConfig": {
     "access": "public"
   },

package/src/cards.ts

@@ -19,10 +19,55 @@ export const ELEMENTS = {
   assistant: (i: number) => `assistant_${i}`,
 } as const
 
+/** Minimal projection of an SDK task — used by Session's local mirror,
+ * built incrementally from observed TaskCreate / TaskUpdate input+output
+ * pairs. Not authoritative (the SDK is the source of truth), but enough
+ * to render the "全部任务清单" footer on every Task* panel. */
+export interface Todo {
+  id: number
+  subject?: string
+  description?: string
+  status: 'pending' | 'in_progress' | 'completed' | string
+  owner?: string
+  activeForm?: string
+}
+
+function todoStatusIcon(s: string): string {
+  switch (s) {
+    case 'pending':     return '☐'
+    case 'in_progress': return '🔄'
+    case 'completed':   return '✅'
+    default:            return '·'
+  }
+}
+
+/** Render the session's full todo mirror as a markdown list. Empty list
+ * yields '' so callers can unconditionally concat. Sorted by numeric id
+ * so the order matches creation order regardless of Map iteration. */
+function renderTodoList(todos: Todo[]): string {
+  if (!todos || todos.length === 0) return ''
+  const sorted = [...todos].sort((a, b) => a.id - b.id)
+  const lines = ['', '---', `**📋 当前任务清单（${sorted.length} 项）**`, '']
+  for (const t of sorted) {
+    const icon = todoStatusIcon(t.status)
+    const subject = t.subject ?? '(无 subject)'
+    const ownerTag = t.owner ? `  · ${t.owner}` : ''
+    lines.push(`- ${icon} **#${t.id}** ${subject}${ownerTag}`)
+  }
+  return lines.join('\n')
+}
+
 /** Single-line summary used as a collapsible-panel header for a tool call. */
 export function summarizeToolInput(name: string, input: any): string {
   if (!input || typeof input !== 'object') return ''
   const truncate = (s: string, n: number) => s.length > n ? s.slice(0, n) + '…' : s
+  // Task workflow tools (TaskCreate / TaskUpdate / TaskList / ...) carry
+  // structured fields that summarize much better as natural language than
+  // as truncated JSON. Routed first so they don't fall through to the
+  // generic Agent/Task case below.
+  if (name.startsWith('Task') && name !== 'Task') {
+    return truncate(summarizeTaskWorkflow(name, input), 80)
+  }
   switch (name) {
     case 'Bash':       return truncate(String(input.command ?? ''), 80)
     case 'Read':
@@ -44,6 +89,78 @@ export function summarizeToolInput(name: string, input: any): string {
   return ''
 }
 
+/** Header summary for Task* workflow tools — `Task` (singular) is the
+ * separate subagent-spawn tool and is handled above; everything else
+ * (TaskCreate / TaskUpdate / TaskList / TaskGet / TaskStop / TaskOutput /
+ * TaskDelete) summarises through here. */
+function summarizeTaskWorkflow(name: string, input: any): string {
+  switch (name) {
+    case 'TaskCreate':
+      return `📝 创建: ${input.subject ?? '(无 subject)'}`
+    case 'TaskUpdate': {
+      const parts: string[] = []
+      if (input.status) parts.push(`→ ${input.status}`)
+      if (input.owner) parts.push(`owner=${input.owner}`)
+      if (input.subject) parts.push(`subject="${input.subject}"`)
+      if (input.addBlocks) parts.push(`blocks=[${(input.addBlocks ?? []).join(',')}]`)
+      if (input.addBlockedBy) parts.push(`blockedBy=[${(input.addBlockedBy ?? []).join(',')}]`)
+      const tail = parts.length ? ' ' + parts.join(', ') : ''
+      return `✏️ #${input.taskId ?? '?'}${tail}`
+    }
+    case 'TaskList':   return '📋 查询任务列表'
+    case 'TaskGet':    return `🔍 查询 #${input.taskId ?? '?'}`
+    case 'TaskStop':   return `⏹ 停止 #${input.taskId ?? '?'}`
+    case 'TaskOutput': return `📤 取输出 #${input.taskId ?? '?'}`
+    case 'TaskDelete': return `🗑 删除 #${input.taskId ?? '?'}`
+  }
+  return name
+}
+
+/** Markdown body for Task* workflow tools — replaces the generic JSON
+ * dump with a human-readable description of the operation plus, once the
+ * tool result is in, the SDK's text reply (which already contains "Task
+ * #N created" / "Updated task #X" / a rendered list for TaskList). When
+ * `todos` is non-empty, the full mirror is appended as a "📋 当前任务
+ * 清单" footer so every Task* panel doubles as a current-state readout. */
+function renderTaskWorkflowBody(name: string, input: any, output: string | null, todos?: Todo[]): string {
+  const lines: string[] = []
+  switch (name) {
+    case 'TaskCreate':
+      lines.push(`**📝 创建任务**`)
+      if (input.subject)    lines.push(`- subject: ${input.subject}`)
+      if (input.description) lines.push(`- 描述: ${input.description}`)
+      if (input.activeForm) lines.push(`- 进行时: ${input.activeForm}`)
+      break
+    case 'TaskUpdate': {
+      lines.push(`**✏️ 更新 #${input.taskId ?? '?'}**`)
+      if (input.status)       lines.push(`- status → \`${input.status}\``)
+      if (input.subject)      lines.push(`- subject: ${input.subject}`)
+      if (input.description)  lines.push(`- description: ${input.description}`)
+      if (input.owner)        lines.push(`- owner: ${input.owner}`)
+      if (input.activeForm)   lines.push(`- 进行时: ${input.activeForm}`)
+      if (input.addBlocks)    lines.push(`- blocks → ${(input.addBlocks).join(', ')}`)
+      if (input.addBlockedBy) lines.push(`- blockedBy → ${(input.addBlockedBy).join(', ')}`)
+      if (input.metadata)     lines.push(`- metadata: \`${JSON.stringify(input.metadata)}\``)
+      break
+    }
+    case 'TaskList':   lines.push('**📋 查询当前任务清单**'); break
+    case 'TaskGet':    lines.push(`**🔍 查询 #${input.taskId ?? '?'}**`); break
+    case 'TaskStop':   lines.push(`**⏹ 停止 #${input.taskId ?? '?'}**`); break
+    case 'TaskOutput': lines.push(`**📤 取 #${input.taskId ?? '?'} 输出**`); break
+    case 'TaskDelete': lines.push(`**🗑 删除 #${input.taskId ?? '?'}**`); break
+    default:
+      lines.push(`**${name}**`)
+      lines.push('```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 1000) + '\n```')
+  }
+  if (output != null) {
+    lines.push('')
+    lines.push('---')
+    lines.push('**结果**')
+    lines.push(output.slice(0, 3000))
+  }
+  return lines.join('\n') + renderTodoList(todos ?? [])
+}
+
 interface MainCardOpts {
   sessionName: string
   turn: number
@@ -100,70 +217,84 @@ export function thinkingCollapsedPanel(fullText: string): object {
   }
 }
 
-/** Element to insert for each tool call. expandable for big results.
+/** Element to insert for each tool call. Expandable for big results.
  *
  * Header is a one-line summary: status + name + summarized input.
- * Body holds the full input + (after completion) the full output. */
+ * Body holds the full input + (after completion) the full output.
+ * `resolvedNote` is an optional one-liner appended below the input —
+ * used to surface "✅ 允许 by Alice" inline after a permission decision
+ * lands but before the actual tool execution completes. */
 export function toolCallElement(
   i: number,
   name: string,
   input: any,
   output: string | null,
   status: '⏳' | '✅' | '❌' = '⏳',
+  resolvedNote?: string,
+  /** Session's full todo mirror — only rendered when the tool is a Task*
+   * workflow op. Other tools ignore it. Passed in by Session so every
+   * Task* panel shows the *current* state, not just this op's diff. */
+  todos?: Todo[],
 ): object {
   const summary = summarizeToolInput(name, input)
   const headerText = summary
     ? `${status} 🔧 ${name}: ${summary}`
     : `${status} 🔧 ${name}`
-  const inputBlock = '```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 2000) + '\n```'
-  const outputBlock = output != null
-    ? '\n---\n**output:**\n```\n' + output.slice(0, 3000) + '\n```'
-    : ''
+  const isTaskWorkflow = name.startsWith('Task') && name !== 'Task'
+  const noteBlock = resolvedNote ? `\n\n${resolvedNote}` : ''
+  // Task* gets a narrative body (operation + result + current todo list),
+  // the rest keeps the JSON-input + raw-output split — generic dump is
+  // better for unfamiliar tools where users can't predict what fields
+  // matter.
+  const body = isTaskWorkflow
+    ? renderTaskWorkflowBody(name, input, output, todos) + noteBlock
+    : '```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 2000) + '\n```'
+      + noteBlock
+      + (output != null ? '\n---\n**output:**\n```\n' + output.slice(0, 3000) + '\n```' : '')
   return {
     tag: 'collapsible_panel',
     element_id: ELEMENTS.tool(i),
     header: { title: { tag: 'plain_text', content: headerText } },
     expanded: false,
     elements: [
-      { tag: 'markdown', content: inputBlock + outputBlock },
+      { tag: 'markdown', content: body },
     ],
   }
 }
 
-interface PermissionOpts {
-  sessionName: string
-  toolName: string
-  description: string
-  inputPreview: string
-  requestId: string
-}
-
-export function permissionCard(opts: PermissionOpts): object {
-  const { sessionName, toolName, description, inputPreview, requestId } = opts
-  let pretty = inputPreview
-  try { pretty = JSON.stringify(JSON.parse(inputPreview), null, 2) } catch {}
+/** Same tool panel as `toolCallElement`, but with the 🔐 status and
+ * three inline action buttons (allow / allow_always / deny). Expanded
+ * by default so the user can read the request without clicking through.
+ * This is the "merge into tool panel" UX — the permission decision
+ * lives on the same row as the tool call instead of as a separate
+ * floating card. */
+export function toolCallPermissionElement(
+  i: number,
+  name: string,
+  input: any,
+  requestId: string,
+): object {
+  const summary = summarizeToolInput(name, input)
+  const headerText = summary
+    ? `🔐 等审批 · ${name}: ${summary}`
+    : `🔐 等审批 · ${name}`
+  const inputBlock = '```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 2000) + '\n```'
   return {
-    schema: '2.0',
-    config: { update_multi: true },
-    header: {
-      title: { tag: 'plain_text', content: `🔐 权限请求 · ${toolName}` },
-      subtitle: { tag: 'plain_text', content: sessionName },
-      template: 'orange',
-    },
-    body: {
-      elements: [
-        { tag: 'markdown', content: description },
-        { tag: 'markdown', content: '```\n' + pretty.slice(0, 2000) + '\n```' },
-        {
-          tag: 'column_set',
-          columns: [
-            permissionButtonColumn('✅ 允许', 'primary', requestId, 'allow'),
-            permissionButtonColumn('♾️ 始终允许', 'default', requestId, 'allow_always'),
-            permissionButtonColumn('❌ 拒绝', 'danger', requestId, 'deny'),
-          ],
-        },
-      ],
-    },
+    tag: 'collapsible_panel',
+    element_id: ELEMENTS.tool(i),
+    header: { title: { tag: 'plain_text', content: headerText } },
+    expanded: true,
+    elements: [
+      { tag: 'markdown', content: inputBlock },
+      {
+        tag: 'column_set',
+        columns: [
+          permissionButtonColumn('✅ 允许', 'primary', requestId, 'allow'),
+          permissionButtonColumn('♾️ 始终允许', 'default', requestId, 'allow_always'),
+          permissionButtonColumn('❌ 拒绝', 'danger', requestId, 'deny'),
+        ],
+      },
+    ],
   }
 }
 
@@ -179,26 +310,89 @@ function permissionButtonColumn(label: string, type: string, requestId: string,
   }
 }
 
-export function permissionResolvedCard(
-  toolName: string,
-  decision: 'allow' | 'allow_always' | 'deny',
-  user: string,
+/** Schema of an AskUserQuestion question, projected to just the fields
+ * the panel needs. Mirrors the SDK tool's input — kept loose since the
+ * runtime guarantees it matches. */
+export interface AskQuestion {
+  question: string
+  header?: string
+  multiSelect?: boolean
+  options: { label: string; description?: string }[]
+}
+
+/** Tool-panel renderer for `AskUserQuestion` — the SDK's structured
+ * multiple-choice question. Daemon takes over the client-side role:
+ * instead of letting the request fall through to the generic JSON
+ * dump (or worse, the permission flow that misappropriates it), we
+ * render each question with one button per option, callbacks tagged
+ * `kind:'ask'` so the Lark handler can route the answer back as a
+ * `tool_result`.
+ *
+ * Single-question is the common case; multi-question gets buttons on
+ * the first question only and a text-only listing for the rest (an
+ * acceptable limitation — these are rare in practice and we can lift
+ * it once the UX is validated). */
+export function askUserQuestionElement(
+  i: number,
+  toolUseId: string,
+  questions: AskQuestion[],
+  status: '🤔' | '✅' | '❌' = '🤔',
+  resolvedNote?: string,
 ): object {
-  const ok = decision !== 'deny'
-  const label = decision === 'allow_always' ? '始终允许' : decision === 'allow' ? '已允许' : '已拒绝'
+  const primary = questions[0]
+  const headerTag = primary?.header ? ` · ${primary.header}` : ''
+  const headerText = `${status} 🤔 AskUserQuestion${headerTag}`
+  const bodyElements: any[] = []
+  if (primary) {
+    bodyElements.push({ tag: 'markdown', content: `**${primary.question}**` })
+    // Stack option buttons in a column_set — one button per option.
+    // Each carries `kind:'ask'` + the toolUseId + question/option idx
+    // so the daemon's card action handler can map a click back to
+    // exactly one (question, choice) pair.
+    bodyElements.push({
+      tag: 'column_set',
+      columns: primary.options.map((opt, optIdx) => ({
+        tag: 'column', width: 'weighted', weight: 1,
+        elements: [{
+          tag: 'button',
+          text: { tag: 'plain_text', content: opt.label },
+          type: 'default',
+          behaviors: [{
+            type: 'callback',
+            value: {
+              kind: 'ask',
+              tool_use_id: toolUseId,
+              question_idx: 0,
+              option_idx: optIdx,
+            },
+          }],
+        }],
+      })),
+    })
+    // Inline option descriptions below the buttons so the user can
+    // read context without hovering.
+    const descLines = primary.options
+      .map((o, idx) => o.description ? `- **${o.label}** — ${o.description}` : `- **${o.label}**`)
+      .join('\n')
+    if (descLines) bodyElements.push({ tag: 'markdown', content: descLines })
+  }
+  // Secondary questions get text-only treatment (TODO: multi-question
+  // panels when actually requested by a real prompt).
+  for (let qi = 1; qi < questions.length; qi++) {
+    const q = questions[qi]
+    const opts = q.options.map(o => `  - ${o.label}${o.description ? ` — ${o.description}` : ''}`).join('\n')
+    bodyElements.push({
+      tag: 'markdown',
+      content: `\n---\n**(其他问题 #${qi + 1}, 暂未支持回答)** ${q.question}\n${opts}`,
+    })
+  }
+  if (resolvedNote) bodyElements.push({ tag: 'markdown', content: resolvedNote })
   return {
-    schema: '2.0',
-    config: { update_multi: true },
-    header: {
-      title: { tag: 'plain_text', content: `🔐 权限请求 · ${toolName}` },
-      template: ok ? 'green' : 'red',
-    },
-    body: {
-      elements: [{
-        tag: 'markdown',
-        content: `${ok ? '✅' : '❌'} **${label}** by ${user || '匿名'} · ${new Date().toLocaleTimeString('zh-CN', { hour12: false })}`,
-      }],
-    },
+    tag: 'collapsible_panel',
+    element_id: ELEMENTS.tool(i),
+    header: { title: { tag: 'plain_text', content: headerText } },
+    expanded: true,
+    elements: bodyElements,
   }
 }
 
@@ -207,36 +401,92 @@ interface ConsoleOpts {
   status: 'idle' | 'working' | 'awaiting_permission' | 'starting' | 'stopped'
   model?: string
   effort?: string
-  uptime?: string
-  lastActivity?: string
+  /** ms since this ClaudeProcess spawned — formatted to "1h 23m" inside. */
+  uptimeMs?: number
+  /** Current context-window occupancy estimate (input + cache tokens of
+   * the last assistant message). 0 if no turn has completed yet. */
+  contextTokens?: number
+  /** Window upper bound. Defaults to 1M (claude-opus-4-7[1m]). */
+  contextLimit?: number
+  cumStats?: { tokens: number; costUsd: number; turns: number }
+  lastTurn?: { tokens: number; costUsd: number; durationMs: number }
+  sessionId?: string | null
   hasSession: boolean
 }
 
+/** Format token counts as a compact human-readable string: 1,234 → 1.2K. */
+function fmtTokens(n: number): string {
+  if (!n) return '0'
+  if (n < 1000) return String(n)
+  if (n < 1_000_000) return (n / 1000).toFixed(n < 10_000 ? 1 : 0).replace(/\.0$/, '') + 'K'
+  return (n / 1_000_000).toFixed(2).replace(/\.?0+$/, '') + 'M'
+}
+
+function fmtCost(c: number): string {
+  if (c < 0.01) return `$${c.toFixed(4)}`
+  return `$${c.toFixed(2)}`
+}
+
+function fmtDurationMs(ms: number): string {
+  if (ms < 1000) return `${ms}ms`
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`
+  const m = Math.floor(ms / 60_000)
+  const s = Math.round((ms % 60_000) / 1000)
+  return `${m}m ${s}s`
+}
+
+function fmtUptime(ms: number): string {
+  if (ms < 60_000) return `${Math.round(ms / 1000)}s`
+  const totalMin = Math.floor(ms / 60_000)
+  if (totalMin < 60) return `${totalMin}m`
+  const h = Math.floor(totalMin / 60)
+  const m = totalMin % 60
+  if (h < 24) return `${h}h ${m}m`
+  const d = Math.floor(h / 24)
+  return `${d}d ${h % 24}h`
+}
+
 export function consoleCard(opts: ConsoleOpts): object {
-  const { sessionName, status, model, effort, uptime, lastActivity, hasSession } = opts
+  const {
+    sessionName, status, model, effort, uptimeMs,
+    contextTokens, contextLimit, cumStats, lastTurn, sessionId, hasSession,
+  } = opts
   const statusEmoji = {
     idle: '🟢 闲', working: '⚙️ 工作中', awaiting_permission: '🔐 等审批',
     starting: '🚀 启动中', stopped: '⚪ 未运行',
   }[status]
-  const meta = [
-    `状态: ${statusEmoji}`,
-    model ? `模型: ${model}${effort ? `/${effort}` : ''}` : null,
-    uptime ? `运行: ${uptime}` : null,
-    lastActivity ? `最近: ${lastActivity}` : null,
-  ].filter(Boolean).join(' · ')
 
-  const buttons: [string, string, string][] = hasSession
-    ? [
-        ['⏸ 中断', 'interrupt', 'default'],
-        ['🧹 /clear', 'clear', 'default'],
-        ['⏹ 终止', 'stop', 'danger'],
-        ['📁 ls', 'ls', 'default'],
-      ]
-    : [
-        ['🚀 启动', 'start', 'primary'],
-        ['🔁 续聊', 'resume', 'default'],
-        ['📁 ls', 'ls', 'default'],
-      ]
+  const modelLine = model ? `${model}${effort ? `/${effort}` : ''}` : null
+  const headerLine = [statusEmoji, modelLine].filter(Boolean).join(' · ')
+
+  // Build the metric lines that make this panel useful. Each is "label
+  // <tab> value" rendered as plain markdown — keeps it readable inside
+  // the small Feishu card area without competing with the button row.
+  const lines: string[] = [headerLine]
+
+  if (contextTokens != null) {
+    const limit = contextLimit ?? 1_000_000
+    const pct = limit > 0 ? Math.round((contextTokens / limit) * 100) : 0
+    lines.push(`**📦 上下文**　${fmtTokens(contextTokens)} / ${fmtTokens(limit)}　(${pct}%)`)
+  }
+  if (uptimeMs != null && uptimeMs > 0) {
+    lines.push(`**⏱ 已运行**　${fmtUptime(uptimeMs)}`)
+  }
+  if (cumStats && (cumStats.tokens > 0 || cumStats.costUsd > 0 || cumStats.turns > 0)) {
+    lines.push(`**💬 累计**　${fmtTokens(cumStats.tokens)} tokens · ${fmtCost(cumStats.costUsd)} · ${cumStats.turns} turn${cumStats.turns === 1 ? '' : 's'}`)
+  }
+  if (lastTurn) {
+    lines.push(`**🔄 上一轮**　+${fmtTokens(lastTurn.tokens)} · ${fmtCost(lastTurn.costUsd)} · ${fmtDurationMs(lastTurn.durationMs)}`)
+  }
+  if (sessionId) {
+    lines.push(`**🆔 session**　\`${sessionId.slice(0, 8)}…\``)
+  }
+
+  void hasSession // accept the field for caller compat; lifecycle is now
+  // driven by bare-word commands (`hi` / `kill` / `restart` / `clear`),
+  // not buttons — keeps the panel pure-readout and one-handed mobile-
+  // friendly. The 'refresh' / 'ls' actions stay in onConsoleAction for
+  // backward compat with any still-floating older cards in chat history.
 
   const template = status === 'working' ? 'blue'
     : status === 'awaiting_permission' ? 'orange'
@@ -252,19 +502,7 @@ export function consoleCard(opts: ConsoleOpts): object {
     },
     body: {
       elements: [
-        { tag: 'markdown', content: meta || '_(no state)_' },
-        {
-          tag: 'column_set',
-          columns: buttons.map(([label, action, kind]) => ({
-            tag: 'column', width: 'weighted', weight: 1,
-            elements: [{
-              tag: 'button',
-              text: { tag: 'plain_text', content: label },
-              type: kind,
-              behaviors: [{ type: 'callback', value: { kind: 'console', action } }],
-            }],
-          })),
-        },
+        { tag: 'markdown', content: lines.join('\n\n') },
       ],
     },
   }

package/src/claude-process.ts

@@ -44,6 +44,23 @@ export interface CanUseToolRequest {
   tool_use_id?: string
 }
 
+/** Subset of the SDK's `usage` object — only the fields the console
+ * panel actually shows. Anthropic adds new ones (server_tool_use,
+ * service_tier, iterations, …) without breaking existing readers. */
+export interface ClaudeUsage {
+  input_tokens?: number
+  output_tokens?: number
+  cache_creation_input_tokens?: number
+  cache_read_input_tokens?: number
+}
+
+export interface ClaudeResultMeta {
+  cost_usd: number | null
+  duration_ms: number | null
+  num_turns: number | null
+  usage: ClaudeUsage | null
+}
+
 export interface HookCallbackRequest {
   request_id: string
   callback_id: string
@@ -60,6 +77,22 @@ export class ClaudeProcess extends EventEmitter {
   private expectedExit = false
   sessionId: string | null = null
   lastAssistantUuid: string | null = null
+  /** Model id (`claude-opus-4-7`, …) from the most recent assistant
+   * message — surfaced in the console panel so the user sees what's
+   * actually running, not whatever default we'd assume. */
+  lastModel: string | null = null
+  /** Usage from the most recent `assistant` message — input_tokens +
+   * cache_* on the *latest* message is the best proxy for current
+   * context-window occupancy, since each assistant turn replays the
+   * accumulated conversation. */
+  lastUsage: ClaudeUsage | null = null
+  /** Result-level metadata from the most recent `result` message —
+   * per-turn cost / wallclock / num_turns. Cleared to null only on
+   * spawn; persists across turns so the console panel can show "last
+   * turn" stats even while idle. */
+  lastResult: ClaudeResultMeta = {
+    cost_usd: null, duration_ms: null, num_turns: null, usage: null,
+  }
 
   constructor(opts: SpawnOpts) {
     super()
@@ -184,6 +217,8 @@ export class ClaudeProcess extends EventEmitter {
           this.emit('thinking', { uuid: msg.uuid, text: block.thinking })
         }
       }
+      if (msg.message?.usage) this.lastUsage = msg.message.usage as ClaudeUsage
+      if (typeof msg.message?.model === 'string') this.lastModel = msg.message.model
       if (msg.uuid) this.lastAssistantUuid = msg.uuid
       return
     }
@@ -201,6 +236,12 @@ export class ClaudeProcess extends EventEmitter {
       return
     }
     if (type === 'result') {
+      this.lastResult = {
+        cost_usd: typeof msg.total_cost_usd === 'number' ? msg.total_cost_usd : null,
+        duration_ms: typeof msg.duration_ms === 'number' ? msg.duration_ms : null,
+        num_turns: typeof msg.num_turns === 'number' ? msg.num_turns : null,
+        usage: msg.usage ?? null,
+      }
       this.emit('result', msg)
       return
     }
@@ -245,19 +286,53 @@ export class ClaudeProcess extends EventEmitter {
     })
   }
 
-  sendPermissionResponse(requestId: string, decision: 'allow' | 'deny', updatedInput?: any): void {
+  /** Response schema for `can_use_tool` control_request (NOT the
+   * PreToolUse-hook output shape that lives elsewhere in the SDK).
+   *   allow → { behavior: 'allow', updatedInput: <record> }
+   *   deny  → { behavior: 'deny',  message: <string> }
+   * Sending the wrong shape gets Zod-rejected on the Claude side and
+   * the decision never lands — the card visually flips to "resolved"
+   * but Claude immediately re-fires the same can_use_tool, looking to
+   * the user like a "flash back to original" bug. */
+  sendPermissionResponse(
+    requestId: string,
+    decision: 'allow' | 'deny',
+    payload?: { updatedInput?: Record<string, unknown>; denyMessage?: string },
+  ): void {
+    const response = decision === 'allow'
+      ? { behavior: 'allow' as const, updatedInput: payload?.updatedInput ?? {} }
+      : { behavior: 'deny' as const, message: payload?.denyMessage ?? 'denied by user' }
     this.write({
       type: 'control_response',
       response: {
         subtype: 'success',
         request_id: requestId,
-        response: {
-          hookSpecificOutput: {
-            hookEventName: 'PreToolUse',
-            permissionDecision: decision,
-            ...(updatedInput ? { permissionDecisionInput: updatedInput } : {}),
-          },
-        },
+        response,
+      },
+    })
+  }
+
+  /** Feed a `tool_result` back to Claude as if a tool finished — used
+   * by the daemon when WE (the client) own the tool's execution side,
+   * e.g. AskUserQuestion: the SDK emits `tool_use` and waits for the
+   * client to render UI, collect a choice, and supply the result here.
+   * `content` is whatever the tool's contract says — for
+   * AskUserQuestion this is a JSON string `{"answers": {...}}`.
+   *
+   * NOTE: this is the same `{type:'user'}` envelope as `sendUserText`,
+   * just with a `tool_result` content block instead of plain text. The
+   * SDK demultiplexes by `tool_use_id`. */
+  sendToolResult(toolUseId: string, content: string, isError = false): void {
+    this.write({
+      type: 'user',
+      message: {
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: toolUseId,
+          content,
+          ...(isError ? { is_error: true } : {}),
+        }],
       },
     })
   }

package/src/feishu.ts

@@ -12,7 +12,7 @@ import { mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from '
 import { homedir } from 'node:os'
 import { basename, extname, join } from 'node:path'
 import { config } from './config'
-import { DATA_DIR, INBOX_DIR, SESSION_CHAT_MAP_FILE } from './paths'
+import { DATA_DIR, INBOX_DIR, SESSION_CHAT_MAP_FILE, SESSION_RESUME_MAP_FILE } from './paths'
 import { log } from './log'
 
 const APP_ID = config.feishu.app_id
@@ -70,6 +70,42 @@ export function bindSessionToChat(sessionName: string, chatId: string): void {
   log(`feishu: bound session "${sessionName}" → ${chatId}${prev ? ` (was ${prev})` : ''}`)
 }
 
+// ── Session resume map ────────────────────────────────────────────────
+// `sessionName → last-known claude session_id`. Persisted so a daemon
+// restart (systemctl, crash, watchdog) doesn't strand the user with a
+// fresh conversation when they next type `restart`. Updated on every
+// `system/init` from a claude subprocess.
+const lastSessionIdByName = new Map<string, string>()
+
+export function loadSessionResumeMap(): void {
+  try {
+    const obj = JSON.parse(readFileSync(SESSION_RESUME_MAP_FILE, 'utf8'))
+    for (const [name, id] of Object.entries(obj)) {
+      if (typeof id === 'string') lastSessionIdByName.set(name, id)
+    }
+    log(`feishu: loaded ${lastSessionIdByName.size} session→resume bindings`)
+  } catch {}
+}
+
+function saveSessionResumeMap(): void {
+  try {
+    const obj: Record<string, string> = {}
+    for (const [k, v] of lastSessionIdByName) obj[k] = v
+    mkdirSync(DATA_DIR, { recursive: true })
+    writeFileSync(SESSION_RESUME_MAP_FILE, JSON.stringify(obj, null, 2))
+  } catch (e) { log(`feishu: save session-resume-map failed: ${e}`) }
+}
+
+export function bindSessionResume(sessionName: string, sessionId: string): void {
+  if (lastSessionIdByName.get(sessionName) === sessionId) return
+  lastSessionIdByName.set(sessionName, sessionId)
+  saveSessionResumeMap()
+}
+
+export function getSessionResume(sessionName: string): string | null {
+  return lastSessionIdByName.get(sessionName) ?? null
+}
+
 export function chatIdForSession(sessionName: string): string | null {
   const preferred = preferredChatForSession.get(sessionName)
   if (preferred && chatNameCache.get(preferred) === sessionName) return preferred
@@ -127,23 +163,6 @@ export async function sendCard(chatId: string, card: object): Promise<string | n
   } catch (e) { log(`feishu: sendCard failed chat=${chatId}: ${e}`); return null }
 }
 
-// PATCH a regular interactive message (i.e. a card NOT promoted to a
-// cardkit entity). Used for permission cards that flip allow/deny once.
-export async function patchCardMessage(messageId: string, card: object): Promise<void> {
-  try {
-    const token = await getTenantToken()
-    const res = await fetch(`https://open.feishu.cn/open-apis/im/v1/messages/${messageId}`, {
-      method: 'PATCH',
-      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ content: JSON.stringify(card) }),
-    })
-    const data = await res.json() as any
-    if (data?.code && data.code !== 0) {
-      log(`feishu: patchCardMessage ${messageId} code=${data.code} msg=${data.msg}`)
-    }
-  } catch (e) { log(`feishu: patchCardMessage ${messageId} failed: ${e}`) }
-}
-
 // ── Reactions ──────────────────────────────────────────────────────────
 export async function addReaction(messageId: string, emojiType: string): Promise<void> {
   if (!messageId) return

package/src/paths.ts

@@ -8,6 +8,7 @@
  *   daemon.pid              — single-instance lock          (in DATA_DIR)
  *   daemon.log              — append-only run log           (in DATA_DIR)
  *   session-chat-map.json   — duplicate-name routing        (in DATA_DIR)
+ *   session-resume-map.json — last-known claude session_id  (in DATA_DIR)
  *   inbox/                  — downloaded attachments        (in DATA_DIR)
  */
 
@@ -38,4 +39,5 @@ export const CONFIG_FILE = process.env.LODESTAR_CONFIG ?? join(CONFIG_DIR, 'conf
 export const PID_FILE = join(DATA_DIR, 'daemon.pid')
 export const LOG_FILE = join(DATA_DIR, 'daemon.log')
 export const SESSION_CHAT_MAP_FILE = join(DATA_DIR, 'session-chat-map.json')
+export const SESSION_RESUME_MAP_FILE = join(DATA_DIR, 'session-resume-map.json')
 export const INBOX_DIR = join(DATA_DIR, 'inbox')

package/src/session.ts

@@ -9,7 +9,7 @@
 
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
-import { ClaudeProcess, type CanUseToolRequest, type HookCallbackRequest } from './claude-process'
+import { ClaudeProcess, type CanUseToolRequest, type HookCallbackRequest, type ClaudeUsage } from './claude-process'
 import { CHANNEL_INSTRUCTIONS } from './instructions'
 import * as cardkit from './cardkit'
 import * as cards from './cards'
@@ -22,7 +22,18 @@ interface TurnState {
   userText: string
   thinkingText: string
   toolCount: number
-  toolByUseId: Map<string, { i: number; name: string; input: any }>
+  /** `output` / `isError` are filled in by completeTool — kept on the
+   * meta (instead of being thrown away after the first render) so a
+   * later Task* op can re-render every prior Task* panel with the
+   * latest todo mirror appended. */
+  toolByUseId: Map<string, {
+    i: number
+    name: string
+    input: any
+    resolvedNote?: string
+    output?: string
+    isError?: boolean
+  }>
   assistantSegmentCount: number
   currentAssistantSegmentId: string | null
   currentAssistantText: string
@@ -41,23 +52,65 @@ export interface SessionOpts {
   permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions'
 }
 
+/** Per-turn delta extracted from the SDK `result` message — feeds the
+ * "上一轮" line in the console panel. */
+interface LastTurnDelta {
+  tokens: number      // input + cache_* + output for that turn
+  costUsd: number
+  durationMs: number
+  inputTokens: number // input + cache_* (excludes output) — context-window estimate
+}
+
+/** Cumulative session counters. Reset on full restart (`clear`), preserved
+ * across resume — but resumed conversations start counting from the
+ * resume point, not the original turn 0; the SDK doesn't replay historical
+ * usage. The session_id continuity is preserved separately by the resume
+ * map; cumStats represents "since the current ClaudeProcess was spawned". */
+interface CumStats {
+  tokens: number
+  costUsd: number
+  turns: number
+}
+
 export class Session {
   private proc: ClaudeProcess | null = null
   private currentTurn: TurnState | null = null
-  private pendingPermissions = new Map<string, { messageId: string; toolName: string }>()
+  private pendingPermissions = new Map<string, { toolUseId: string }>()
+  /** Open AskUserQuestion tool calls — keyed by tool_use_id, valued
+   * with the questions array so we can construct the `answers` reply
+   * once a button is clicked. Cleared when the answer is sent or the
+   * turn ends. */
+  private pendingAsks = new Map<string, { questions: cards.AskQuestion[]; i: number }>()
   private turnCounter = 0
   // Last seen sessionId — preserved across `kill`/`stop` so a later
   // `restart` can resume the same Claude conversation even after the
   // child process is gone.
   private lastSessionId: string | null = null
   private startedAt: number = 0
+  private cumStats: CumStats = { tokens: 0, costUsd: 0, turns: 0 }
+  private lastTurnDelta: LastTurnDelta | null = null
+  /** Local mirror of the SDK's task list — built incrementally from
+   * TaskCreate / TaskUpdate input+output pairs and rendered as a footer
+   * on every Task* panel. Lives for the lifetime of the Session
+   * instance; daemon restart wipes it (the SDK doesn't replay history).
+   * Not authoritative — Claude calling TaskList is still the source of
+   * truth; this mirror is purely for the panel readout. */
+  private currentTodos = new Map<number, cards.Todo>()
   status: Status = 'stopped'
 
   constructor(
     public readonly sessionName: string,
     public readonly chatId: string,
     private opts: SessionOpts = {},
-  ) {}
+  ) {
+    // Restore last-known claude session_id from disk so a daemon restart
+    // (systemctl, crash, watchdog) doesn't strand the user with a fresh
+    // conversation when they next type `restart`.
+    this.lastSessionId = feishu.getSessionResume(sessionName)
+    if (this.lastSessionId) {
+      log(`session "${sessionName}": restored lastSessionId=${this.lastSessionId.slice(0, 8)}…`)
+    }
+  }
 
   get workDir(): string { return join(feishu.PROJECTS_ROOT, this.sessionName) }
   isRunning(): boolean { return !!this.proc && this.proc.isAlive() }
@@ -82,7 +135,7 @@ export class Session {
     this.proc = new ClaudeProcess({
       workDir: this.workDir,
       effort: 'max',
-      permissionMode: this.opts.permissionMode ?? 'default',
+      permissionMode: this.opts.permissionMode ?? 'bypassPermissions',
       appendSystemPrompt: CHANNEL_INSTRUCTIONS,
     })
     this.wireProc(this.proc)
@@ -122,7 +175,7 @@ export class Session {
       this.proc = new ClaudeProcess({
         workDir: this.workDir,
         effort: 'max',
-        permissionMode: 'default',
+        permissionMode: this.opts.permissionMode ?? 'bypassPermissions',
         resumeSessionId: prevSessionId,
         appendSystemPrompt: CHANNEL_INSTRUCTIONS,
       })
@@ -132,6 +185,16 @@ export class Session {
       this.startedAt = Date.now()
       await feishu.sendText(this.chatId, `🔁 已重启并恢复 session=${prevSessionId.slice(0, 8)}…`)
     } else {
+      // Resume requested but no prior session_id on file — surface it
+      // explicitly rather than silently fresh-starting (the old behavior
+      // hid the daemon-restart sessionId-loss bug for months).
+      if (resume) {
+        await feishu.sendText(this.chatId, '⚠️ 没有可恢复的上一会话，将以新会话启动')
+      }
+      // Fresh conversation — drop cumulative stats so the next `hi` shows
+      // zeroed counters instead of bleeding numbers from the prior chat.
+      this.cumStats = { tokens: 0, costUsd: 0, turns: 0 }
+      this.lastTurnDelta = null
       await this.start()
     }
   }
@@ -168,14 +231,27 @@ export class Session {
   }
 
   async showConsole(): Promise<void> {
-    const uptime = this.startedAt
-      ? `${Math.round((Date.now() - this.startedAt) / 1000)}s`
-      : undefined
+    const uptimeMs = this.startedAt ? (Date.now() - this.startedAt) : undefined
+    // Strip the `claude-` prefix so the panel stays compact: `opus-4-7`
+    // reads better than `claude-opus-4-7` in the small status header.
+    const rawModel = this.proc?.lastModel ?? null
+    const model = rawModel ? rawModel.replace(/^claude-/, '') : undefined
     const card = cards.consoleCard({
       sessionName: this.sessionName,
       status: this.status,
+      model,
       effort: 'max',
-      uptime,
+      uptimeMs,
+      contextTokens: this.currentContextTokens(),
+      cumStats: this.cumStats,
+      lastTurn: this.lastTurnDelta
+        ? {
+            tokens: this.lastTurnDelta.tokens,
+            costUsd: this.lastTurnDelta.costUsd,
+            durationMs: this.lastTurnDelta.durationMs,
+          }
+        : undefined,
+      sessionId: this.proc?.sessionId ?? this.lastSessionId,
       hasSession: this.isRunning(),
     })
     await feishu.sendCard(this.chatId, card)
@@ -212,8 +288,22 @@ export class Session {
     if (!pending) { log(`session "${this.sessionName}": stray permission ${requestId}`); return }
     this.pendingPermissions.delete(requestId)
 
-    const resolved = cards.permissionResolvedCard(pending.toolName, decision, user)
-    await feishu.patchCardMessage(pending.messageId, resolved)
+    // Update the tool element in the main turn card in place — the
+    // permission decision lives on the same row as the tool call.
+    const turn = this.currentTurn
+    const meta = turn?.toolByUseId.get(pending.toolUseId)
+    if (turn && meta) {
+      const todos = this.isTaskWorkflow(meta.name) ? this.todosArray() : undefined
+      if (decision === 'deny') {
+        const el = cards.toolCallElement(meta.i, meta.name, meta.input, `🚫 已拒绝 by ${user || '匿名'}`, '❌', undefined, todos)
+        void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
+      } else {
+        const label = decision === 'allow_always' ? '始终允许' : '已允许'
+        meta.resolvedNote = `✅ **${label}** by ${user || '匿名'}`
+        const el = cards.toolCallElement(meta.i, meta.name, meta.input, null, '⏳', meta.resolvedNote, todos)
+        void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
+      }
+    }
 
     const claudeDecision = decision === 'deny' ? 'deny' : 'allow'
     this.proc?.sendPermissionResponse(requestId, claudeDecision)
@@ -227,6 +317,42 @@ export class Session {
     }
   }
 
+  /** Handle a click on an AskUserQuestion option button. We construct
+   * the SDK-shaped `answers` map (question text → picked option label),
+   * send it back as a `tool_result`, and freeze the panel showing the
+   * picked option. The permission half of the flow was already auto-
+   * allowed in `renderPermission`, so no second action needed there. */
+  async onAskAnswer(toolUseId: string, questionIdx: number, optionIdx: number, user: string): Promise<void> {
+    const pending = this.pendingAsks.get(toolUseId)
+    if (!pending) { log(`session "${this.sessionName}": stray ask answer for ${toolUseId}`); return }
+    const q = pending.questions[questionIdx]
+    const opt = q?.options?.[optionIdx]
+    if (!q || !opt) {
+      log(`session "${this.sessionName}": ask answer out of range q=${questionIdx} o=${optionIdx}`)
+      return
+    }
+    // Build the answers map. SDK keys answers by the question text
+    // (matches what the AskUserQuestion contract expects). For
+    // unanswered secondary questions we don't include them — the SDK
+    // tolerates a partial map; Claude will see whichever it got.
+    const answers: Record<string, string> = { [q.question]: opt.label }
+    const content = JSON.stringify({ answers })
+    this.proc?.sendToolResult(toolUseId, content)
+    this.pendingAsks.delete(toolUseId)
+
+    // Repaint the panel to reflect the final choice — same element_id,
+    // status flips to ✅, body shows what was picked.
+    const turn = this.currentTurn
+    const meta = turn?.toolByUseId.get(toolUseId)
+    if (turn && meta) {
+      meta.output = content
+      meta.isError = false
+      const resolvedNote = `\n\n✅ **已回答** by ${user || '匿名'}: ${opt.label}`
+      const el = cards.askUserQuestionElement(meta.i, toolUseId, pending.questions, '✅', resolvedNote)
+      void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
+    }
+  }
+
   async onConsoleAction(action: string): Promise<void> {
     log(`session "${this.sessionName}": console action=${action}`)
     switch (action) {
@@ -235,12 +361,22 @@ export class Session {
       case 'stop':      await this.stop(); break
       case 'start':     await this.start(); break
       case 'resume':    await this.restart(true); break
+      case 'refresh':   await this.showConsole(); break
       case 'ls':        await feishu.sendText(this.chatId, `📁 ${this.workDir}`); break
     }
   }
 
   // ── Wiring Claude → Feishu ─────────────────────────────────────────
   private wireProc(p: ClaudeProcess): void {
+    p.on('init', () => {
+      // Persist the freshly assigned session_id so a later daemon
+      // restart can resume this conversation. Skip if unchanged to
+      // avoid hammering the file on every init for resumed sessions.
+      if (p.sessionId && p.sessionId !== this.lastSessionId) {
+        this.lastSessionId = p.sessionId
+        feishu.bindSessionResume(this.sessionName, p.sessionId)
+      }
+    })
     p.on('assistant_text', ({ text }: { text: string }) => {
       this.appendAssistant(text)
     })
@@ -254,13 +390,14 @@ export class Session {
       this.completeTool(tool_use_id, content, is_error)
     })
     p.on('can_use_tool', (req: CanUseToolRequest) => {
-      void this.renderPermission(req)
+      this.renderPermission(req)
     })
     p.on('hook_callback', (req: HookCallbackRequest) => {
       // No hooks registered → fail-safe ack.
       this.proc?.sendHookResponse(req.request_id, {})
     })
     p.on('result', () => {
+      this.accumulateResultStats()
       void this.closeTurnCard()
       this.status = 'idle'
     })
@@ -275,6 +412,37 @@ export class Session {
     })
   }
 
+  /** Pull per-turn numbers off `proc.lastResult` (set by ClaudeProcess when
+   * the `result` message landed) and roll them into cumStats + the
+   * "上一轮" delta. Called exactly once per result event, right before
+   * closeTurnCard. */
+  private accumulateResultStats(): void {
+    const r = this.proc?.lastResult
+    if (!r) return
+    const u = r.usage ?? {}
+    const inputTokens = (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0)
+    const outputTokens = u.output_tokens ?? 0
+    const tokens = inputTokens + outputTokens
+    const costUsd = r.cost_usd ?? 0
+    const durationMs = r.duration_ms ?? 0
+    this.cumStats.tokens += tokens
+    this.cumStats.costUsd += costUsd
+    this.cumStats.turns += r.num_turns ?? 1
+    this.lastTurnDelta = { tokens, costUsd, durationMs, inputTokens }
+  }
+
+  /** Current context-window occupancy estimate — uses the most recent
+   * assistant `usage` (input + caches), since each assistant reply replays
+   * the full conversation. Falls back to the last-turn delta when no
+   * assistant message has streamed yet this process. */
+  private currentContextTokens(): number {
+    const u = this.proc?.lastUsage as ClaudeUsage | null | undefined
+    if (u) {
+      return (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0)
+    }
+    return this.lastTurnDelta?.inputTokens ?? 0
+  }
+
   private async openTurnCard(userText: string): Promise<void> {
     const turn = ++this.turnCounter
     const card = cards.mainConversationCard({
@@ -338,6 +506,14 @@ export class Session {
     )
   }
 
+  private isTaskWorkflow(name: string): boolean {
+    return name.startsWith('Task') && name !== 'Task'
+  }
+
+  private todosArray(): cards.Todo[] {
+    return [...this.currentTodos.values()]
+  }
+
   private addTool(toolUseId: string, name: string, input: any): void {
     if (!this.currentTurn) return
     // Close current assistant segment (if any) so the tool panel renders
@@ -350,7 +526,27 @@ export class Session {
     }
     const i = this.currentTurn.toolCount++
     this.currentTurn.toolByUseId.set(toolUseId, { i, name, input })
-    const el = cards.toolCallElement(i, name, input, null, '⏳')
+    // AskUserQuestion is a client-side tool — daemon renders the choice
+    // UI in-line and supplies the tool_result itself once the user
+    // clicks. Branch BEFORE the generic toolCallElement so we never
+    // fall through to a JSON dump or, worse, get clobbered by the
+    // permission flow (which would render 🔐 three-button buttons that
+    // don't match the actual N options).
+    if (name === 'AskUserQuestion') {
+      const questions = Array.isArray(input?.questions) ? input.questions as cards.AskQuestion[] : []
+      this.pendingAsks.set(toolUseId, { questions, i })
+      const el = cards.askUserQuestionElement(i, toolUseId, questions, '🤔')
+      void cardkit.addElement(this.currentTurn.cardId, el, {
+        type: 'insert_before',
+        targetElementId: cards.ELEMENTS.footer,
+      })
+      return
+    }
+    // Pending Task* panels still show the *pre-op* todo mirror so users
+    // can read the current state immediately, without waiting for the
+    // tool to return.
+    const todos = this.isTaskWorkflow(name) ? this.todosArray() : undefined
+    const el = cards.toolCallElement(i, name, input, null, '⏳', undefined, todos)
     void cardkit.addElement(this.currentTurn.cardId, el, {
       type: 'insert_before',
       targetElementId: cards.ELEMENTS.footer,
@@ -366,26 +562,141 @@ export class Session {
       : Array.isArray(content)
         ? content.map((c: any) => c?.text ?? JSON.stringify(c)).join('\n')
         : JSON.stringify(content)
-    const el = cards.toolCallElement(meta.i, meta.name, meta.input, output, isError ? '❌' : '✅')
+    // Stash on the meta — every Task* op coming after this point may
+    // need to re-render this panel with a fresher todo footer, so we
+    // can't discard the output after the first paint.
+    meta.output = output
+    meta.isError = isError
+    // Update the local todo mirror BEFORE rendering so the just-
+    // completed panel shows the new state too (e.g. a TaskCreate panel
+    // already lists the task it just created).
+    if (!isError && this.isTaskWorkflow(meta.name)) {
+      this.updateTodosFromTask(meta.name, meta.input, output)
+    }
+    const todos = this.isTaskWorkflow(meta.name) ? this.todosArray() : undefined
+    const el = cards.toolCallElement(meta.i, meta.name, meta.input, output, isError ? '❌' : '✅', meta.resolvedNote, todos)
     void cardkit.replaceElement(this.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
+    // Cascade the new mirror into every prior Task* panel in this turn
+    // so any expanded panel reflects the latest state, not the snapshot
+    // captured when that op ran.
+    if (!isError && this.isTaskWorkflow(meta.name)) {
+      this.refreshOtherTaskPanels(toolUseId)
+    }
   }
 
-  private async renderPermission(req: CanUseToolRequest): Promise<void> {
-    this.status = 'awaiting_permission'
-    const card = cards.permissionCard({
-      sessionName: this.sessionName,
-      toolName: req.tool_name,
-      description: `工具 \`${req.tool_name}\` 想在 ~/${this.sessionName} 执行操作`,
-      inputPreview: JSON.stringify(req.input ?? {}),
-      requestId: req.request_id,
-    })
-    const messageId = await feishu.sendCard(this.chatId, card)
-    if (!messageId) {
-      log(`session "${this.sessionName}": permission card send failed; auto-deny`)
-      this.proc?.sendPermissionResponse(req.request_id, 'deny')
+  /** Roll a single Task* op into the local mirror — best-effort. Output
+   * parsing is regex-based (the SDK returns plain text like "Task #7
+   * created successfully: …"), so unexpected variants are skipped
+   * silently rather than blowing up the panel render. */
+  private updateTodosFromTask(name: string, input: any, output: string): void {
+    switch (name) {
+      case 'TaskCreate': {
+        const m = output.match(/Task #(\d+) created/)
+        if (!m) return
+        const id = Number(m[1])
+        this.currentTodos.set(id, {
+          id,
+          subject: input.subject,
+          description: input.description,
+          activeForm: input.activeForm,
+          status: 'pending',
+        })
+        return
+      }
+      case 'TaskUpdate': {
+        const id = Number(input.taskId)
+        if (!Number.isFinite(id)) return
+        // status=deleted is the SDK's tombstone — drop from the mirror
+        // so the readout doesn't carry it forever. Server still keeps
+        // it; the mirror is just for the panel footer.
+        if (input.status === 'deleted') { this.currentTodos.delete(id); return }
+        const cur = this.currentTodos.get(id) ?? { id, status: 'pending' as const }
+        if (input.status)      cur.status = input.status
+        if (input.subject)     cur.subject = input.subject
+        if (input.description) cur.description = input.description
+        if (input.owner)       cur.owner = input.owner
+        if (input.activeForm)  cur.activeForm = input.activeForm
+        this.currentTodos.set(id, cur)
+        return
+      }
+      // TaskList / TaskGet / TaskStop / TaskOutput / TaskDelete:
+      // read-only or parse-heavy — skip mirror update. The panel will
+      // still render the SDK's textual result below the operation
+      // block, which is enough to disambiguate.
+    }
+  }
+
+  /** Re-render every Task* panel in the current turn (except the one
+   * that just landed — already up-to-date) so they all show the latest
+   * todo mirror in their footers. Cheap: ELEMENTS.tool(i) replace is
+   * queued through the per-card Promise chain like any other op. */
+  private refreshOtherTaskPanels(skipToolUseId: string): void {
+    if (!this.currentTurn) return
+    const todos = this.todosArray()
+    for (const [id, meta] of this.currentTurn.toolByUseId) {
+      if (id === skipToolUseId) continue
+      if (!this.isTaskWorkflow(meta.name)) continue
+      const status: '⏳' | '✅' | '❌' = meta.output === undefined
+        ? '⏳'
+        : (meta.isError ? '❌' : '✅')
+      const el = cards.toolCallElement(
+        meta.i, meta.name, meta.input, meta.output ?? null,
+        status, meta.resolvedNote, todos,
+      )
+      void cardkit.replaceElement(this.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
+    }
+  }
+
+  /** Merge the permission ask into the existing tool element in the
+   * current turn card. The user sees one continuous timeline: ⏳ pending
+   * → 🔐 awaiting approval (with buttons) → ⏳ allowed / ❌ denied → ✅
+   * with output. No floating orange card.
+   *
+   * `tool_use` is emitted as part of the assistant message and lands on
+   * our `addTool` handler BEFORE the SDK's `can_use_tool` control_request
+   * arrives — so by the time we get here, `toolByUseId` already has the
+   * entry we need to replace.
+   *
+   * Edge cases (no current turn / missing tool_use_id / unknown id) are
+   * surfaced loudly and auto-denied. We don't fall back to a standalone
+   * card — per the project's no-fallbacks rule, hidden anomalies are
+   * worse than visible deny errors. */
+  private renderPermission(req: CanUseToolRequest): void {
+    const turn = this.currentTurn
+    if (!turn) {
+      log(`session "${this.sessionName}": can_use_tool with no current turn — auto-deny req=${req.request_id}`)
+      this.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'no active turn' })
       return
     }
-    this.pendingPermissions.set(req.request_id, { messageId, toolName: req.tool_name })
+    const toolUseId = req.tool_use_id
+    if (!toolUseId) {
+      log(`session "${this.sessionName}": can_use_tool without tool_use_id — auto-deny req=${req.request_id}`)
+      this.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'no tool_use_id' })
+      return
+    }
+    const meta = turn.toolByUseId.get(toolUseId)
+    if (!meta) {
+      log(`session "${this.sessionName}": can_use_tool for unknown tool_use_id=${toolUseId} — auto-deny req=${req.request_id}`)
+      this.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'unknown tool_use_id' })
+      return
+    }
+    // AskUserQuestion: daemon already rendered the choice UI in addTool
+    // and is collecting the user's answer asynchronously. The SDK
+    // wraps it in the standard permission flow anyway (even under
+    // bypassPermissions), so we auto-allow the request — otherwise
+    // Claude would block on can_use_tool forever, AND our permission
+    // renderer would overwrite the ask UI with the wrong 3-button
+    // panel. Keeping it allow-by-default also matches the user's
+    // mental model: they expect to choose an option, not "approve"
+    // the question itself.
+    if (meta.name === 'AskUserQuestion') {
+      this.proc?.sendPermissionResponse(req.request_id, 'allow')
+      return
+    }
+    this.status = 'awaiting_permission'
+    this.pendingPermissions.set(req.request_id, { toolUseId })
+    const el = cards.toolCallPermissionElement(meta.i, meta.name, meta.input, req.request_id)
+    void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
   }
 
   private async closeTurnCard(suffix?: string): Promise<void> {