@leviyuan/lodestar 0.1.0 → 0.1.1

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

@@ -152,6 +152,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.1",
   "publishConfig": {
     "access": "public"
   },

package/src/cards.ts

@@ -23,6 +23,13 @@ export const ELEMENTS = {
 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 +51,76 @@ 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). */
+function renderTaskWorkflowBody(name: string, input: any, output: string | null): 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')
+}
+
 interface MainCardOpts {
   sessionName: string
   turn: number
@@ -100,70 +177,79 @@ 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,
 ): 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), 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) + 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,64 +265,97 @@ function permissionButtonColumn(label: string, type: string, requestId: string,
   }
 }
 
-export function permissionResolvedCard(
-  toolName: string,
-  decision: 'allow' | 'allow_always' | 'deny',
-  user: string,
-): object {
-  const ok = decision !== 'deny'
-  const label = decision === 'allow_always' ? '始终允许' : decision === 'allow' ? '已允许' : '已拒绝'
-  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 })}`,
-      }],
-    },
-  }
-}
-
 interface ConsoleOpts {
   sessionName: string
   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 +371,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,28 @@ 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,
       },
     })
   }

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,7 @@ interface TurnState {
   userText: string
   thinkingText: string
   toolCount: number
-  toolByUseId: Map<string, { i: number; name: string; input: any }>
+  toolByUseId: Map<string, { i: number; name: string; input: any; resolvedNote?: string }>
   assistantSegmentCount: number
   currentAssistantSegmentId: string | null
   currentAssistantText: string
@@ -41,23 +41,53 @@ 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 }>()
   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
   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 +112,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 +152,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 +162,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 +208,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 +265,21 @@ 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) {
+      if (decision === 'deny') {
+        const el = cards.toolCallElement(meta.i, meta.name, meta.input, `🚫 已拒绝 by ${user || '匿名'}`, '❌')
+        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)
+        void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
+      }
+    }
 
     const claudeDecision = decision === 'deny' ? 'deny' : 'allow'
     this.proc?.sendPermissionResponse(requestId, claudeDecision)
@@ -235,12 +301,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 +330,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 +352,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({
@@ -366,26 +474,47 @@ 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 ? '❌' : '✅')
+    const el = cards.toolCallElement(meta.i, meta.name, meta.input, output, isError ? '❌' : '✅', meta.resolvedNote)
     void cardkit.replaceElement(this.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
   }
 
-  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')
+  /** 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
+    }
+    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
     }
-    this.pendingPermissions.set(req.request_id, { messageId, toolName: req.tool_name })
+    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
+    }
+    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> {