@leviyuan/lodestar 0.1.6 → 0.1.8

package/daemon.ts

@@ -32,7 +32,19 @@ try {
 mkdirSync(dirname(PID_FILE), { recursive: true })
 writeFileSync(PID_FILE, String(process.pid))
 
-const cleanup = () => { try { unlinkSync(PID_FILE) } catch {} }
+const cleanup = () => {
+  // Snapshot which sessions are still alive so the next boot can
+  // revive them — only the ones still running at shutdown, NOT
+  // anything the user already `kill`-ed (those are absent from the
+  // sessions Map filter below and stay stopped after restart).
+  try {
+    const alive: string[] = []
+    for (const s of sessions.values()) if (s.isRunning()) alive.push(s.sessionName)
+    feishu.writeAliveMarker(alive)
+    if (alive.length > 0) log(`alive marker: [${alive.join(', ')}]`)
+  } catch (e) { log(`alive marker write failed: ${e}`) }
+  try { unlinkSync(PID_FILE) } catch {}
+}
 process.on('exit', cleanup)
 process.on('SIGTERM', () => { log('SIGTERM'); cleanup(); process.exit(0) })
 process.on('SIGINT',  () => { log('SIGINT');  cleanup(); process.exit(0) })
@@ -51,14 +63,49 @@ function sessionFor(chatId: string, sessionName: string): Session {
   return s
 }
 
+/** Auto-restart any session that was alive when the previous daemon
+ * went down. Driven by the marker file written in `cleanup` — that
+ * file ONLY lists sessions that were running, so anything the user
+ * had explicitly `kill`-ed before shutdown is intentionally absent
+ * and stays stopped. Each revived session is `restart(true)`-ed so
+ * the SDK gets `--resume <claudeSessionId>` and the in-flight
+ * conversation continues without the user typing anything. */
+async function reviveAliveSessions(): Promise<void> {
+  const names = feishu.readAndConsumeAliveMarker()
+  if (names.length === 0) return
+  log(`revive: ${names.length} session(s) marked alive on shutdown: ${names.join(', ')}`)
+  for (const sessionName of names) {
+    const chatId = feishu.chatIdForSession(sessionName)
+    if (!chatId) {
+      log(`revive: no chatId binding for "${sessionName}", skip`)
+      continue
+    }
+    const session = sessionFor(chatId, sessionName)
+    try {
+      await session.restart(true)
+      log(`revive: spawned "${sessionName}" (chat ${chatId.slice(0, 8)}…)`)
+    } catch (e) {
+      log(`revive: restart "${sessionName}" failed: ${e}`)
+    }
+  }
+}
+
 // ── Inbound message handler ─────────────────────────────────────────────
-const STALE_THRESHOLD_MS = 10_000
+const STALE_THRESHOLD_MS = 5_000
 const seenMessageIds = new Set<string>()
 
 async function handleMessage(data: any): Promise<void> {
   const message = data?.message
   if (!message) return
 
+  // Feishu's im.message.receive_v1 event puts `sender` at the event
+  // root, sibling of `message` — NOT inside `message` (we had this
+  // wrong before, which silently emptied userOpenId and skipped every
+  // urgent_app push). Try root first, fall back to nested in case the
+  // SDK wraps the payload differently.
+  const senderId = data?.sender?.sender_id ?? data?.event?.sender?.sender_id ?? message?.sender?.sender_id
+  const userOpenId: string = senderId?.open_id ?? ''
+
   const msgId = message.message_id as string | undefined
   if (msgId && seenMessageIds.has(msgId)) return
   if (msgId) {
@@ -77,7 +124,6 @@ async function handleMessage(data: any): Promise<void> {
     if (msgId) void feishu.addReaction(msgId, 'CrossMark')
     return
   }
-  if (msgId) void feishu.addReaction(msgId, 'OK')
 
   const chatId = message.chat_id as string
   let groupName = feishu.chatNameCache.get(chatId)
@@ -115,8 +161,8 @@ async function handleMessage(data: any): Promise<void> {
   // to text-only messages (an image attachment opens a new turn as
   // usual). Bare-word commands have already been intercepted above.
   if (msgType === 'text' && text && session.hasPendingAsk()) {
-    const userId = message.sender?.sender_id?.open_id ?? ''
-    await session.onAskMessageAnswer(text, userId)
+    if (msgId) void feishu.addReaction(msgId, 'CheckMark')
+    await session.onAskMessageAnswer(text, userOpenId)
     return
   }
 
@@ -129,7 +175,7 @@ async function handleMessage(data: any): Promise<void> {
   }
 
   if (!text && !filePath) return
-  await session.onUserMessage(text || '(empty)', filePath ? [filePath] : [])
+  await session.onUserMessage(text || '(empty)', filePath ? [filePath] : [], userOpenId)
 }
 
 // ── Card action handler ────────────────────────────────────────────────
@@ -225,6 +271,11 @@ async function boot(): Promise<void> {
   })
   ws.start({ eventDispatcher: dispatcher })
   log(`lodestar-daemon: WS started, watching ${feishu.chatNameCache.size} groups`)
+
+  // Auto-revive sessions that were running when we last went down.
+  // Runs AFTER the WS is up so any 🔁 revive message lands in the
+  // right chat instead of disappearing into the void.
+  await reviveAliveSessions()
 }
 
 boot().catch(e => { log(`boot fatal: ${e}`); process.exit(1) })

package/package.json

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

package/src/cardkit.ts

@@ -35,6 +35,14 @@ interface CardState {
 
 const cards = new Map<string, CardState>()
 
+interface SummaryState {
+  latest: string
+  lastSent: string
+  timer: ReturnType<typeof setTimeout> | null
+}
+const summaryStates = new Map<string, SummaryState>()
+const SUMMARY_FLUSH_MS = 1500
+
 function state(cardId: string): CardState {
   let s = cards.get(cardId)
   if (!s) {
@@ -190,6 +198,43 @@ export function deleteElement(cardId: string, elementId: string): Promise<void>
   return s.queue
 }
 
+/** Throttled card-summary update. The summary text is what Feishu shows
+ * in the chat list as the message preview. We coalesce writes on a
+ * SUMMARY_FLUSH_MS window so streaming assistant deltas don't blow up
+ * the settings-PATCH endpoint. Whitespace is collapsed and the input
+ * is trimmed; empty content is ignored. */
+export function patchSummaryThrottled(cardId: string, content: string): void {
+  const trimmed = (content ?? '').replace(/\s+/g, ' ').trim()
+  if (!trimmed) return
+  let s = summaryStates.get(cardId)
+  if (!s) {
+    s = { latest: trimmed, lastSent: '', timer: null }
+    summaryStates.set(cardId, s)
+  } else {
+    s.latest = trimmed
+  }
+  if (s.timer) return
+  s.timer = setTimeout(() => {
+    const st = summaryStates.get(cardId)
+    if (!st) return
+    st.timer = null
+    if (st.latest === st.lastSent) return
+    const toSend = st.latest
+    st.lastSent = toSend
+    void patchSettings(cardId, { config: { summary: { content: toSend } } })
+  }, SUMMARY_FLUSH_MS)
+}
+
+/** Cancel any pending throttled summary write. Call before emitting
+ * a terminal summary (e.g. "✅ ⏱ 12.3s · 4.2K tokens") so a stale
+ * mid-stream tail can't fire after and clobber the final preview. */
+export function cancelSummary(cardId: string): void {
+  const s = summaryStates.get(cardId)
+  if (!s) return
+  if (s.timer) { clearTimeout(s.timer); s.timer = null }
+  summaryStates.delete(cardId)
+}
+
 /** Patch settings — used to flip streaming_mode off when a turn finishes. */
 export function patchSettings(cardId: string, settings: object): Promise<void> {
   const s = state(cardId)
@@ -212,4 +257,5 @@ export async function dispose(cardId: string): Promise<void> {
   await flush(cardId)
   await s.queue
   cards.delete(cardId)
+  cancelSummary(cardId)
 }

package/src/cards.ts

@@ -17,6 +17,11 @@ export const ELEMENTS = {
    * and the next assistant chunk opens a new one, so element order in the
    * card matches Claude's emission order. */
   assistant: (i: number) => `assistant_${i}`,
+  /** Console (hi) card — the subscription-usage row is rendered as its
+   * own element so we can replace it after the initial card lands,
+   * decoupling the slow ccusage fetch from the rest of the panel's
+   * synchronous data. */
+  consoleUsage: 'console_usage',
 } as const
 
 /** Minimal projection of an SDK task — used by Session's local mirror,
@@ -332,121 +337,177 @@ export interface AskQuestion {
  * 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). */
-/** Final-state info for an AskUserQuestion panel. Mutually-exclusive
- * branches inside: either the user picked one of the SDK-provided
- * options (`optionIdx`), or they typed a free-form answer
- * (`customText`). When both are absent the panel is still pending. */
+/** Per-question final-state. Mutually-exclusive branches: option pick
+ * vs. free-form custom text. */
 export interface AskAnswered {
   optionIdx?: number
   customText?: string
   user?: string
 }
 
+/** State the panel renders against. `currentIdx` undefined → terminal
+ * (every question answered). Otherwise it's the question currently on
+ * screen; everything in `answered` is history. */
+export interface AskState {
+  currentIdx?: number
+  answered: Map<number, AskAnswered>
+}
+
+/** Render one question's body — either as clickable interactive_container
+ * rows (when picked === undefined) or as plain markdown summary
+ * (already-answered, shown in history-panel context). */
+function renderAskQuestionBody(
+  q: AskQuestion,
+  toolUseId: string,
+  questionIdx: number,
+  picked?: AskAnswered,
+): any[] {
+  const els: any[] = []
+  els.push({ tag: 'markdown', content: `**${q.question}**` })
+  for (let oi = 0; oi < q.options.length; oi++) {
+    const opt = q.options[oi]
+    const desc = opt.description ? `  ·  ${opt.description}` : ''
+    if (picked) {
+      const isPicked = picked.optionIdx === oi
+      els.push({
+        tag: 'markdown',
+        content: isPicked
+          ? `✅ **${opt.label}**${desc}`
+          : `~~◯ ${opt.label}${desc}~~`,
+      })
+    } else {
+      els.push({
+        tag: 'interactive_container',
+        background_style: 'default',
+        has_border: true,
+        corner_radius: '6px',
+        padding: '8px 12px',
+        margin: '4px 0px 4px 0px',
+        behaviors: [{
+          type: 'callback',
+          value: {
+            kind: 'ask',
+            tool_use_id: toolUseId,
+            question_idx: questionIdx,
+            option_idx: oi,
+          },
+        }],
+        elements: [{ tag: 'markdown', content: `**${opt.label}**${desc}` }],
+      })
+    }
+  }
+  if (picked?.customText) {
+    els.push({ tag: 'markdown', content: `✏️ **自定义回答**：${picked.customText}` })
+  }
+  return els
+}
+
+/** Folded "📜 已答 N 题" panel — option C from the multi-question
+ * design discussion. Returns null when there's no history to show. */
+function renderAskHistoryPanel(
+  questions: AskQuestion[],
+  answered: Map<number, AskAnswered>,
+): any | null {
+  if (answered.size === 0) return null
+  const lines: string[] = []
+  const sortedIdx = [...answered.keys()].sort((a, b) => a - b)
+  for (const idx of sortedIdx) {
+    const q = questions[idx]
+    const a = answered.get(idx)!
+    const tag = q?.header ?? `Q${idx + 1}`
+    const value = a.customText
+      ?? (a.optionIdx !== undefined ? q?.options[a.optionIdx]?.label : undefined)
+      ?? '?'
+    lines.push(`- ✅ **${tag}**：${value}`)
+  }
+  return {
+    tag: 'collapsible_panel',
+    header: {
+      title: { tag: 'plain_text', content: `📜 已答 ${answered.size} 题（点击展开）` },
+    },
+    expanded: false,
+    elements: [{ tag: 'markdown', content: lines.join('\n') }],
+  }
+}
+
 export function askUserQuestionElement(
   i: number,
   toolUseId: string,
   questions: AskQuestion[],
   status: '🤔' | '✅' | '❌' = '🤔',
-  answered?: AskAnswered,
+  state?: AskState,
 ): object {
-  const primary = questions[0]
-  const isAnswered = !!answered && (answered.optionIdx !== undefined || !!answered.customText)
-  const headerTag = primary?.header ? ` · ${primary.header}` : ''
-  let headerText: string
-  if (isAnswered) {
-    // Surface the picked answer in the header so a collapsed panel
-    // still tells the reader what was chosen.
-    const picked = answered!.customText
-      ?? (answered!.optionIdx !== undefined ? primary?.options[answered!.optionIdx]?.label : undefined)
-      ?? '?'
-    headerText = `${status} 已回答${headerTag}：${picked}`
-  } else {
-    headerText = `${status} 🤔 AskUserQuestion${headerTag}`
-  }
+  const total = questions.length
+  const answered = state?.answered ?? new Map<number, AskAnswered>()
+  const currentIdx = state?.currentIdx
+  const isTerminal = currentIdx === undefined && answered.size > 0
   const bodyElements: any[] = []
-  if (primary) {
-    bodyElements.push({ tag: 'markdown', content: `**${primary.question}**` })
-    // One row per option. While pending, each row is a full-width
-    // interactive_container so the entire row is the click target.
-    // Once answered, rows degrade to plain markdown (Feishu has no
-    // generic non-interactive container — `div` doesn't exist, it
-    // rejects the PUT with code 300121).
-    for (let optIdx = 0; optIdx < primary.options.length; optIdx++) {
-      const opt = primary.options[optIdx]
-      const isPicked = answered?.optionIdx === optIdx
-      const desc = opt.description ? `  ·  ${opt.description}` : ''
-      if (!isAnswered) {
-        bodyElements.push({
-          tag: 'interactive_container',
-          background_style: 'default',
-          has_border: true,
-          corner_radius: '6px',
-          padding: '8px 12px',
-          margin: '4px 0px 4px 0px',
-          behaviors: [{
-            type: 'callback',
-            value: {
-              kind: 'ask',
-              tool_use_id: toolUseId,
-              question_idx: 0,
-              option_idx: optIdx,
-            },
-          }],
-          elements: [{ tag: 'markdown', content: `**${opt.label}**${desc}` }],
-        })
-      } else if (isPicked) {
-        bodyElements.push({
-          tag: 'markdown',
-          content: `✅ **${opt.label}**${desc}`,
-        })
-      } else {
-        bodyElements.push({
-          tag: 'markdown',
-          content: `~~◯ ${opt.label}${desc}~~`,
-        })
-      }
+  let headerText: string
+
+  if (isTerminal) {
+    // All questions resolved — collapse and roll up answers in header
+    // + body. Single-question case keeps the old "已回答：xxx" header
+    // style; multi-question gets a "已回答 · N 题" count and a flat
+    // listing of Q→A pairs in the body.
+    if (total === 1) {
+      const q0 = questions[0]
+      const a0 = answered.get(0)
+      const value = a0?.customText
+        ?? (a0?.optionIdx !== undefined ? q0?.options[a0.optionIdx]?.label : undefined)
+        ?? '?'
+      const headerTag = q0?.header ? ` · ${q0.header}` : ''
+      headerText = `${status} 已回答${headerTag}：${value}`
+    } else {
+      headerText = `${status} 已回答 · ${total} 题`
     }
-    // Custom-answer hint (pending state only). Feishu schema 2.0
-    // doesn't actually have `form` / `input` elements — `tag: form`
-    // gets rejected with code 300315. Instead we route custom
-    // answers through a plain chat message: daemon.handleMessage
-    // detects a pending ask and forwards the next inbound text as
-    // the answer, no new turn opened. This is also more Feishu-
-    // native: the chat input is right there, no extra widget.
-    if (!isAnswered) {
+    const sortedIdx = [...answered.keys()].sort((a, b) => a - b)
+    for (const idx of sortedIdx) {
+      const q = questions[idx]
+      const a = answered.get(idx)!
+      const tag = q?.header ?? `Q${idx + 1}`
+      const value = a.customText
+        ?? (a.optionIdx !== undefined ? q?.options[a.optionIdx]?.label : undefined)
+        ?? '?'
       bodyElements.push({
         tag: 'markdown',
-        content: '_💬 也可以直接在群里回复你的答案（裸词命令 `hi`/`kill`/`restart`/`clear` 仍然优先）_',
+        content: `**${tag}**：${value}`,
       })
-    } else if (answered?.customText) {
+    }
+    const lastUser = [...answered.values()].reverse().find(a => a.user)?.user
+    if (lastUser) {
       bodyElements.push({
         tag: 'markdown',
-        content: `✏️ **自定义回答**：${answered.customText}`,
+        content: `\n*— 由 ${lastUser} 回答*`,
       })
     }
-  }
-  // Secondary questions (rare): text-only listing. TODO when needed.
-  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 (isAnswered && answered?.user) {
+  } else if (currentIdx !== undefined && questions[currentIdx]) {
+    // In-progress: render current question + folded history above.
+    // Progress tag in header lets the user see how many are left,
+    // even with the history panel folded.
+    const q = questions[currentIdx]
+    const headerTag = q.header ? ` · ${q.header}` : ''
+    const progress = total > 1 ? ` (${currentIdx + 1}/${total})` : ''
+    headerText = `${status} 🤔 AskUserQuestion${headerTag}${progress}`
+    const history = renderAskHistoryPanel(questions, answered)
+    if (history) bodyElements.push(history)
+    bodyElements.push(...renderAskQuestionBody(q, toolUseId, currentIdx))
     bodyElements.push({
       tag: 'markdown',
-      content: `\n*— 由 ${answered.user} 回答*`,
+      content: '_💬 也可以直接在群里回复你的答案（裸词命令 `hi`/`kill`/`restart`/`clear` 仍然优先）_',
     })
+  } else {
+    // Defensive fallback — neither answered nor a valid currentIdx.
+    headerText = `${status} 🤔 AskUserQuestion`
+    if (questions[0]) {
+      bodyElements.push({ tag: 'markdown', content: `**${questions[0].question}**` })
+    }
   }
+
   return {
     tag: 'collapsible_panel',
     element_id: ELEMENTS.tool(i),
     header: { title: { tag: 'plain_text', content: headerText } },
-    // Collapse once answered: header carries the picked answer, body
-    // is just history at that point.
-    expanded: !isAnswered,
+    expanded: !isTerminal,
     elements: bodyElements,
   }
 }
@@ -458,6 +519,20 @@ interface ConsoleOpts {
   effort?: string
   /** ms since this ClaudeProcess spawned — formatted to "1h 23m" inside. */
   uptimeMs?: number
+  /** All sessions currently running Claude across every Feishu group
+   * this daemon owns. Each entry is a sibling project. Empty/undefined
+   * → omit the section. The session matching this card's chat is
+   * flagged `isCurrent` so the row can be marked. */
+  peers?: Array<{
+    name: string
+    isCurrent: boolean
+    status: 'idle' | 'working' | 'awaiting_permission' | 'starting' | 'stopped'
+    uptimeMs?: number
+  }>
+  /** Subscription usage snapshot from ccusage. When `installed: false`
+   * the row renders an install hint; otherwise we surface the current
+   * 5h billing block + this week's aggregate. Undefined → omit row. */
+  usage?: import('./usage').UsageSnapshot
   /** Current context-window occupancy estimate (input + cache tokens of
    * the last assistant message). 0 if no turn has completed yet. */
   contextTokens?: number
@@ -501,9 +576,72 @@ function fmtUptime(ms: number): string {
   return `${d}d ${h % 24}h`
 }
 
+/** Human-readable "time until" — null/past dates collapse to '已重置'. */
+function fmtResetIn(date: Date | null): string {
+  if (!date) return '?'
+  const ms = date.getTime() - Date.now()
+  if (ms <= 0) return '已重置'
+  if (ms < 60 * 60 * 1000) return `${Math.max(1, Math.round(ms / 60_000))}m`
+  if (ms < 24 * 60 * 60 * 1000) return `${Math.round(ms / (60 * 60 * 1000))}h`
+  return `${Math.round(ms / (24 * 60 * 60 * 1000))}d`
+}
+
+const PEER_STATUS_EMOJI: Record<string, string> = {
+  idle: '🟢', working: '⚙️', awaiting_permission: '🔐',
+  starting: '🚀', stopped: '⚪',
+}
+
+/** Render the subscription-usage section of the console card. Pulled out
+ * of `consoleCard` so the caller can patch it in after the initial card
+ * is on screen (ccusage's first cold call is ~5s; we'd rather not block
+ * the whole panel on it). Layout intentionally splits 5h and 7d onto
+ * their own indented lines for readability on phone.
+ *
+ * `usage === undefined` → loading placeholder (initial paint).
+ * `usage === null`      → permanent "no data" (treat like installed but
+ *                          empty; rare path).
+ * `usage.installed=false` → install hint.
+ */
+export function consoleUsageContent(
+  usage: import('./usage').UsageSnapshot | null | undefined,
+): string {
+  if (usage === undefined) return '**📊 订阅额度**　_加载中…_'
+  if (usage === null) return '**📊 订阅额度**　_无数据_'
+  if (!usage.installed) return '**📊 订阅额度**　未装 `ccusage` — `bun i -g ccusage`'
+  // Format follows user spec: `5h X% $Y 剩Zh` / `7d X% $Y 剩Zd`.
+  // Both % values are vs. the user's own historical peak (peak block
+  // for 5h, peak week for 7d) since ccusage has no view into the
+  // actual subscription tier cap. Omit chips that the data layer
+  // couldn't supply rather than fabricate (no_fallbacks).
+  const lines: string[] = ['**📊 订阅额度**']
+  if (usage.fiveHour) {
+    const parts: string[] = []
+    if (usage.fiveHour.percentUsed != null) {
+      parts.push(`${Math.round(usage.fiveHour.percentUsed)}%`)
+    }
+    parts.push(`$${Math.round(usage.fiveHour.costUsd)}`)
+    if (usage.fiveHour.remainingMinutes != null) {
+      parts.push(`剩${(usage.fiveHour.remainingMinutes / 60).toFixed(1)}h`)
+    }
+    lines.push(`　· 5h　${parts.join(' ')}`)
+  }
+  if (usage.weekly) {
+    const parts: string[] = []
+    if (usage.weekly.percentUsed != null) {
+      parts.push(`${Math.round(usage.weekly.percentUsed)}%`)
+    }
+    parts.push(`$${Math.round(usage.weekly.costUsd)}`)
+    if (usage.weekly.remainingDays != null) {
+      parts.push(`剩${usage.weekly.remainingDays.toFixed(1)}d`)
+    }
+    lines.push(`　· 7d　${parts.join(' ')}`)
+  }
+  return lines.length === 1 ? '**📊 订阅额度**　_无数据_' : lines.join('\n')
+}
+
 export function consoleCard(opts: ConsoleOpts): object {
   const {
-    sessionName, status, model, effort, uptimeMs,
+    sessionName, status, model, effort, uptimeMs, peers, usage,
     contextTokens, contextLimit, cumStats, lastTurn, sessionId, hasSession,
   } = opts
   const statusEmoji = {
@@ -519,14 +657,23 @@ export function consoleCard(opts: ConsoleOpts): object {
   // the small Feishu card area without competing with the button row.
   const lines: string[] = [headerLine]
 
+  if (peers && peers.length > 0) {
+    lines.push(`**🗂 活跃项目** (${peers.length})`)
+    for (const p of peers) {
+      const dot = PEER_STATUS_EMOJI[p.status] ?? '·'
+      const up = p.uptimeMs != null && p.uptimeMs > 0 ? ` · ${fmtUptime(p.uptimeMs)}` : ''
+      const mark = p.isCurrent ? ' ← 当前' : ''
+      lines.push(`　· ${dot} \`${p.name}\`${up}${mark}`)
+    }
+  }
   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)}`)
-  }
+  void uptimeMs // session-level uptime is already shown per-project in
+  // the 活跃项目 list above (peers[].uptimeMs); the dedicated row would
+  // duplicate it for the current session.
   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'}`)
   }
@@ -557,7 +704,15 @@ export function consoleCard(opts: ConsoleOpts): object {
     },
     body: {
       elements: [
-        { tag: 'markdown', content: lines.join('\n\n') },
+        { tag: 'markdown', content: lines.join('\n') },
+        // Separate element so showConsole() can replace it after the
+        // ccusage fetch completes — initial paint goes out immediately
+        // with `_加载中…_`, then this row swaps to real data.
+        {
+          tag: 'markdown',
+          element_id: ELEMENTS.consoleUsage,
+          content: consoleUsageContent(usage),
+        },
       ],
     },
   }
@@ -592,6 +747,21 @@ export function menuCard(opts: MenuOpts): object {
   }
 }
 
-export const STREAMING_OFF_SETTINGS = {
-  config: { streaming_mode: false, summary: { content: '✅ Lodestar 完成' } },
+/** Settings patch applied when a turn finishes — flips streaming off
+ * and updates the chat-list preview with `⏱ duration · NK tokens`
+ * (or just the suffix if interrupted before a result event). */
+export function streamingOffSettings(opts: {
+  durationSec: string
+  tokens?: number
+  suffix?: string
+}): object {
+  const parts: string[] = []
+  parts.push(opts.suffix ?? '✅')
+  parts.push(`⏱ ${opts.durationSec}s`)
+  if (opts.tokens != null && opts.tokens > 0) {
+    parts.push(`${fmtTokens(opts.tokens)} tokens`)
+  }
+  return {
+    config: { streaming_mode: false, summary: { content: parts.join(' · ') } },
+  }
 }