@leviyuan/lodestar 0.2.9 → 0.3.0

package/src/cardkit.ts

@@ -1,349 +0,0 @@
-/**
- * Feishu Card Kit v1 wrapper.
- *
- * Endpoints used (base = https://open.feishu.cn/open-apis/cardkit/v1):
- *   POST   /cards/id_convert                              message_id → card_id
- *   POST   /cards                                         create a card entity
- *   PUT    /cards/:card_id/elements/:element_id/content   stream text (typewriter)
- *   POST   /cards/:card_id/elements                       add element
- *   PUT    /cards/:card_id/elements/:element_id           replace element
- *   DELETE /cards/:card_id/elements/:element_id           remove element
- *   PATCH  /cards/:card_id/settings                       toggle streaming_mode etc.
- *
- * Per-card invariants enforced here:
- *   - `sequence` is monotonically increasing per card_id
- *   - all writes for a card are serialized through a Promise queue
- *   - text-streaming PUTs are batched on a 120ms / 32-char heuristic to
- *     stay well under cardkit's per-card rate ceiling
- */
-
-import { getTenantToken } from './feishu'
-import { log } from './log'
-
-const BASE = 'https://open.feishu.cn/open-apis/cardkit/v1'
-
-const FLUSH_INTERVAL_MS = 120
-const FLUSH_MIN_DELTA = 32
-
-interface CardState {
-  sequence: number
-  queue: Promise<void>
-  buffer: Map<string, string>          // element_id → latest full text
-  lastSent: Map<string, string>        // element_id → text last actually PUT
-  flushTimer: ReturnType<typeof setTimeout> | null
-}
-
-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) {
-    s = {
-      sequence: 0,
-      queue: Promise.resolve(),
-      buffer: new Map(),
-      lastSent: new Map(),
-      flushTimer: null,
-    }
-    cards.set(cardId, s)
-  }
-  return s
-}
-
-function nextSeq(cardId: string): number {
-  const s = state(cardId)
-  s.sequence += 1
-  return s.sequence
-}
-
-async function call(method: string, path: string, body?: object): Promise<any> {
-  const token = await getTenantToken()
-  const res = await fetch(`${BASE}${path}`, {
-    method,
-    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-    ...(body ? { body: JSON.stringify(body) } : {}),
-  })
-  const json = await res.json() as any
-  if (json?.code && json.code !== 0) {
-    const e = new Error(`cardkit ${method} ${path}: code=${json.code} msg=${json.msg}`) as Error & { code: number }
-    e.code = json.code
-    throw e
-  }
-  return json?.data
-}
-
-function isStreamingClosed(e: unknown): boolean {
-  if (typeof e !== 'object' || e === null) return false
-  const code = (e as any).code
-  // 300309 "streaming mode is closed" — TTL already fired before our write.
-  // 200850 "card streaming timeout"   — TTL fired exactly during our write.
-  // Both mean the streaming session is gone and a reopen will unstick the card.
-  return code === 300309 || code === 200850
-}
-
-/** Reopen streaming_mode on a card that Feishu auto-closed after its
- * 10-minute streaming TTL (no keepalive, no idle reset — the timer
- * starts when streaming is opened and fires regardless of activity).
- * Called from inside the per-card queue's catch path, so it allocates
- * its own sequence and runs inline without re-enqueueing. */
-async function reopenStreaming(cardId: string): Promise<void> {
-  const seq = nextSeq(cardId)
-  await call('PATCH', `/cards/${cardId}/settings`, {
-    settings: JSON.stringify({ config: { streaming_mode: true } }),
-    sequence: seq,
-  })
-}
-
-/** Run `op` inside the per-card queue. If it fails with code=300309
- * or 200850 (Feishu auto-closed / timed-out streaming after the 10-
- * minute TTL), reopen streaming inline and retry `op` exactly once.
- * Anything else — other failure, reopen failure, retry failure — is
- * logged and swallowed, matching the fire-and-forget contract every
- * cardkit op already has at the call sites. */
-async function withReopenOnStreamingClosed(
-  cardId: string,
-  label: string,
-  op: () => Promise<void>,
-  onFailure?: () => void,
-): Promise<void> {
-  try {
-    await op()
-    return
-  } catch (e) {
-    if (!isStreamingClosed(e)) {
-      log(`cardkit ${label} ${cardId}: ${e}`)
-      if (onFailure) onFailure()
-      return
-    }
-    log(`cardkit ${label} ${cardId}: streaming closed (code=${(e as any).code}) — reopening`)
-  }
-  try {
-    await reopenStreaming(cardId)
-  } catch (re) {
-    log(`cardkit STREAMING_REOPEN_FAILED ${cardId}: ${re}`)
-    if (onFailure) onFailure()
-    return
-  }
-  try {
-    await op()
-  } catch (e2) {
-    log(`cardkit ${label} ${cardId} retry-after-reopen: ${e2}`)
-    if (onFailure) onFailure()
-  }
-}
-
-/** Convert a sent interactive message into a card entity. */
-export async function convertMessageToCard(messageId: string): Promise<string> {
-  const data = await call('POST', '/cards/id_convert', { message_id: messageId })
-  return data.card_id
-}
-
-/** Create a card entity from raw schema-2.0 card JSON. */
-export async function createCardEntity(card: object): Promise<string> {
-  const data = await call('POST', '/cards', {
-    type: 'card_json',
-    data: JSON.stringify(card),
-  })
-  return data.card_id
-}
-
-/** PUT element content (full text) — triggers typewriter on prefix-match.
- *
- * NOTE: CardKit rejects empty-string content with code 99992402 ("field
- * validation failed"); we drop empty/whitespace-only writes here so callers
- * can stream naively without per-call empty checks. */
-export function streamText(cardId: string, elementId: string, content: string): Promise<void> {
-  if (!content || !content.trim()) return Promise.resolve()
-  const s = state(cardId)
-  s.queue = s.queue.then(() => withReopenOnStreamingClosed(
-    cardId,
-    `streamText ${elementId}`,
-    async () => {
-      const seq = nextSeq(cardId)
-      await call('PUT', `/cards/${cardId}/elements/${elementId}/content`, {
-        content, sequence: seq,
-      })
-      s.lastSent.set(elementId, content)
-    },
-  ))
-  return s.queue
-}
-
-/** Throttled streaming: buffer + auto-flush every FLUSH_INTERVAL_MS or
- * when the buffered delta crosses FLUSH_MIN_DELTA characters. */
-export function streamTextThrottled(cardId: string, elementId: string, fullContent: string): void {
-  if (!fullContent || !fullContent.trim()) return
-  const s = state(cardId)
-  s.buffer.set(elementId, fullContent)
-
-  const last = s.lastSent.get(elementId) ?? ''
-  const delta = fullContent.length - last.length
-  if (delta >= FLUSH_MIN_DELTA) {
-    flush(cardId).catch(e => log(`cardkit flush(min-delta) ${cardId}: ${e}`))
-    return
-  }
-  if (!s.flushTimer) {
-    s.flushTimer = setTimeout(() => {
-      flush(cardId).catch(e => log(`cardkit flush(timer) ${cardId}: ${e}`))
-    }, FLUSH_INTERVAL_MS)
-  }
-}
-
-/** Force an immediate flush of the buffered streams for a card. */
-export async function flush(cardId: string): Promise<void> {
-  const s = cards.get(cardId)
-  if (!s) return
-  if (s.flushTimer) { clearTimeout(s.flushTimer); s.flushTimer = null }
-  const pending = [...s.buffer.entries()]
-  s.buffer.clear()
-  for (const [eid, text] of pending) {
-    if (s.lastSent.get(eid) === text) continue
-    await streamText(cardId, eid, text)
-  }
-}
-
-/** Add a new element to the card body or relative to a sibling.
- *
- * `onFailure` fires asynchronously (after promise queue settles) if the
- * element was NOT created — either the first attempt failed with a non-
- * 300309 error, or the retry-after-reopen also failed. Use it to invalidate
- * any daemon-side reference to the element you tried to add (e.g. a segment
- * id), so subsequent writes don't keep PUTting content to a phantom element
- * that Feishu will silently reject. Default (no callback) preserves the
- * legacy fire-and-forget swallow behavior. */
-export function addElement(
-  cardId: string,
-  element: object,
-  opts: { type?: 'append' | 'insert_before' | 'insert_after'; targetElementId?: string } = {},
-  onFailure?: () => void,
-): Promise<void> {
-  const s = state(cardId)
-  s.queue = s.queue.then(() => withReopenOnStreamingClosed(
-    cardId,
-    `addElement`,
-    async () => {
-      const seq = nextSeq(cardId)
-      await call('POST', `/cards/${cardId}/elements`, {
-        type: opts.type ?? 'append',
-        ...(opts.targetElementId ? { target_element_id: opts.targetElementId } : {}),
-        elements: JSON.stringify([element]),
-        sequence: seq,
-      })
-    },
-    onFailure,
-  ))
-  return s.queue
-}
-
-/** Replace an entire element (used to swap a tool placeholder with its result). */
-export function replaceElement(cardId: string, elementId: string, element: object): Promise<void> {
-  const s = state(cardId)
-  s.queue = s.queue.then(() => withReopenOnStreamingClosed(
-    cardId,
-    `replaceElement ${elementId}`,
-    async () => {
-      const seq = nextSeq(cardId)
-      await call('PUT', `/cards/${cardId}/elements/${elementId}`, {
-        element: JSON.stringify(element),
-        sequence: seq,
-      })
-    },
-  ))
-  return s.queue
-}
-
-/** Delete an element by id. */
-export function deleteElement(cardId: string, elementId: string): Promise<void> {
-  const s = state(cardId)
-  s.queue = s.queue.then(() => withReopenOnStreamingClosed(
-    cardId,
-    `deleteElement ${elementId}`,
-    async () => {
-      const seq = nextSeq(cardId)
-      await call('DELETE', `/cards/${cardId}/elements/${elementId}`, {
-        sequence: seq,
-      })
-    },
-  ))
-  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.
- *
- * `nextSeq` is called inside the queued task (not at enqueue time) to
- * match streamText/addElement/replaceElement/deleteElement above. Mixing
- * call-time and execution-time seq allocation interleaves badly: a
- * patchSettings enqueued right after a replaceElement would grab the
- * smaller seq number, but the replaceElement's then-block would grab
- * the larger one when it ran first, so the patchSettings PATCH lands
- * with a stale seq and Feishu rejects 300317 "sequence number compare
- * failed". Keeping all writes on execution-time allocation makes the
- * seq order match the queue order. */
-export function patchSettings(cardId: string, settings: object): Promise<void> {
-  const s = state(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
-      const seq = nextSeq(cardId)
-      await call('PATCH', `/cards/${cardId}/settings`, {
-        settings: JSON.stringify(settings),
-        sequence: seq,
-      })
-    } catch (e) { log(`cardkit patchSettings ${cardId}: ${e}`) }
-  })
-  return s.queue
-}
-
-/** Drop in-memory bookkeeping for a finished card. */
-export async function dispose(cardId: string): Promise<void> {
-  const s = cards.get(cardId)
-  if (!s) return
-  await flush(cardId)
-  await s.queue
-  cards.delete(cardId)
-  cancelSummary(cardId)
-}

package/src/cards/console.ts

@@ -1,352 +0,0 @@
-/**
- * Console / menu / settings cards — every non-turn-card Feishu surface
- * the daemon paints. Companion file to turn.ts; both re-exported from
- * src/cards.ts.
- */
-
-import type { SysInfo } from '../sysinfo'
-import type { UsageSnapshot } from '../usage'
-import { ELEMENTS } from './elements'
-
-interface ConsoleOpts {
-  sessionName: string
-  status: 'idle' | 'working' | 'awaiting_permission' | 'starting' | 'stopped'
-  model?: string
-  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?: UsageSnapshot
-  /** 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. `null` / undefined → unknown (e.g. spawn happened
-   * but no `result` has landed yet); renderer omits the `/ limit (pct%)`
-   * suffix instead of fabricating a default. */
-  contextLimit?: number | null
-  cumStats?: { tokens: number; costUsd: number; turns: number }
-  lastTurn?: { tokens: number; costUsd: number; durationMs: number }
-  sessionId?: string | null
-  /** Host snapshot: CPU 负载、内存、根/家目录磁盘、cc-* systemd 服务。
-   * undefined → 略过整个 host 段;数据自身字段缺失 (cpu/mem 为 null)
-   * 时单行渲染 `_n/a_`,不假数据。 */
-  sysinfo?: SysInfo
-}
-
-function fmtBytes(n: number): string {
-  if (n < 1024) return `${n}B`
-  if (n < 1024 * 1024) return `${(n / 1024).toFixed(0)}K`
-  if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(0)}M`
-  const gb = n / (1024 * 1024 * 1024)
-  return gb < 10 ? `${gb.toFixed(1)}G` : `${gb.toFixed(0)}G`
-}
-
-/** 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`
-}
-
-/** 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`
-}
-
-/** Human-readable "time since" — clamps sub-minute values to "刚刚". */
-function fmtAgo(timestamp: number): string {
-  const ms = Date.now() - timestamp
-  if (ms < 60_000) return '刚刚'
-  if (ms < 60 * 60 * 1000) return `${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 (网络往返可能慢于第一次 paint;先占位、回包后替换)。
- *
- * 数据源是 Anthropic 官方 OAuth Usage API (见 src/usage.ts)。
- * 百分比是真实 utilization,失败态按 state 区分显示具体原因。
- *
- * `usage === undefined` → 初始 loading 占位。
- */
-export function consoleUsageContent(
-  usage: UsageSnapshot | undefined,
-): string {
-  if (usage === undefined) return '**📊 订阅额度**　_加载中…_'
-  switch (usage.state) {
-    case 'no_credentials':
-      return '**📊 订阅额度**　未找到 OAuth 凭据 (`~/.claude/.credentials.json`)'
-    case 'auth_failed':
-      return '**📊 订阅额度**　Token 已过期且刷新失败 — 重新 `claude auth login`'
-    case 'rate_limited':
-      return '**📊 订阅额度**　API 429 限流,稍后重试'
-    case 'network':
-      return `**📊 订阅额度**　拉取失败${usage.reason ? ' — `' + usage.reason + '`' : ''}`
-  }
-  // state === 'ok' —— stale 时 head 加 "缓存 Xm 前",重置时间加 `~`
-  // 前缀,沿用 omchud HUD 的 stale 标记约定。
-  const staleNote = usage.stale ? ` _· 缓存 ${fmtAgo(usage.fetchedAt)}_` : ''
-  const resetPrefix = usage.stale ? '~' : ''
-  const head = usage.subscriptionType
-    ? `**📊 订阅额度** · ${usage.subscriptionType}${staleNote}`
-    : `**📊 订阅额度**${staleNote}`
-  const lines: string[] = [head]
-  if (usage.fiveHour) {
-    const parts = [`${Math.round(usage.fiveHour.percent)}%`]
-    if (usage.fiveHour.resetsAt) parts.push(`重置 ${resetPrefix}${fmtResetIn(usage.fiveHour.resetsAt)}`)
-    lines.push(`　· 5h　${parts.join(' · ')}`)
-  }
-  if (usage.weekly) {
-    const parts = [`${Math.round(usage.weekly.percent)}%`]
-    if (usage.weekly.resetsAt) parts.push(`重置 ${resetPrefix}${fmtResetIn(usage.weekly.resetsAt)}`)
-    lines.push(`　· 7d　${parts.join(' · ')}`)
-  }
-  return lines.length === 1 ? '**📊 订阅额度**　_无数据_' : lines.join('\n')
-}
-
-const SERVICE_STATUS_EMOJI: Record<string, string> = {
-  active: '🟢', activating: '🚀', reloading: '🔄',
-  inactive: '⚪', deactivating: '🟡', failed: '❌',
-}
-
-/** Host snapshot lines: 1 line for CPU+mem, 1 per disk, then services list.
- * 跟 peers 同样的缩进风格 (`　· ` 开头),保持视觉一致。 */
-function hostLines(sysinfo: SysInfo): string[] {
-  const out: string[] = []
-  const head: string[] = []
-  if (sysinfo.cpu) {
-    const { cores, load1, load5, load15 } = sysinfo.cpu
-    head.push(`load ${load1.toFixed(2)} / ${load5.toFixed(2)} / ${load15.toFixed(2)} (${cores}核)`)
-  }
-  if (sysinfo.mem) {
-    head.push(`mem ${sysinfo.mem.percent}% (${fmtBytes(sysinfo.mem.usedBytes)}/${fmtBytes(sysinfo.mem.totalBytes)})`)
-  }
-  if (head.length > 0) out.push(`**🖥 主机**　${head.join(' · ')}`)
-  else out.push('**🖥 主机**　_n/a_')
-
-  if (sysinfo.disks.length > 0) {
-    const parts = sysinfo.disks.map(d =>
-      `\`${d.label}\` ${d.percent}% (${fmtBytes(d.usedBytes)}/${fmtBytes(d.totalBytes)})`,
-    )
-    out.push(`**💽 磁盘**　${parts.join(' · ')}`)
-  }
-
-  if (sysinfo.servicesError) {
-    out.push(`**⚙️ 服务** cc-*　_${sysinfo.servicesError}_`)
-  } else if (sysinfo.services.length === 0) {
-    out.push('**⚙️ 服务** cc-*　_无_')
-  } else {
-    out.push(`**⚙️ 服务** cc-* (${sysinfo.services.length})`)
-    for (const s of sysinfo.services) {
-      const dot = SERVICE_STATUS_EMOJI[s.active] ?? '·'
-      // 三件套: 状态 (active/inactive/failed) · 最近活跃 (上次进入
-      // active 距今多久) · 持续时间 (当前状态持续多久)。
-      // - active: 最近活跃 == 持续时间 (同一时刻),合并成"已运行 5m"
-      // - inactive/failed: 两者不同,分开显示"上次活跃 3d前 · 已停 1h"
-      // - activating/deactivating: 只显示当前状态持续时间
-      // - 从未跑过的 inactive: 只标"从未启动"
-      const lastActive = s.lastActiveAgoSec
-      const stateAge = s.stateAgoSec
-      const parts: string[] = [s.active]
-      if (s.active === 'active') {
-        if (stateAge != null) parts.push(`已运行 ${fmtUptime(stateAge * 1000)}`)
-      } else if (s.active === 'inactive' || s.active === 'failed') {
-        if (lastActive != null) {
-          parts.push(`上次活跃 ${fmtUptime(lastActive * 1000)}前`)
-        } else {
-          parts.push('从未启动')
-        }
-        if (stateAge != null) {
-          const verb = s.active === 'failed' ? '已挂' : '已停'
-          parts.push(`${verb} ${fmtUptime(stateAge * 1000)}`)
-        }
-      } else {
-        // activating / deactivating / reloading
-        if (stateAge != null) parts.push(`已 ${fmtUptime(stateAge * 1000)}`)
-      }
-      out.push(`　· ${dot} \`${s.name}\` · ${parts.join(' · ')}`)
-    }
-  }
-  return out
-}
-
-export function consoleCard(opts: ConsoleOpts): object {
-  const {
-    sessionName, status, model, effort, uptimeMs, peers, usage,
-    contextTokens, contextLimit, cumStats, lastTurn, sessionId, sysinfo,
-  } = opts
-  const statusEmoji = {
-    idle: '🟢 闲', working: '⚙️ 工作中', awaiting_permission: '🔐 等审批',
-    starting: '🚀 启动中', stopped: '⚪ 未运行',
-  }[status]
-
-  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 (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 && contextTokens > 0) {
-    // Show `/ limit (pct%)` only when we actually know the window —
-    // `contextLimit` is populated from the SDK's modelUsage on first
-    // `result`. Pre-result panels (fresh spawn / kill+hi / clear+hi)
-    // render token count alone rather than fabricating a 1M or 200K
-    // default that may not match the running model.
-    if (contextLimit != null && contextLimit > 0) {
-      const pct = Math.round((contextTokens / contextLimit) * 100)
-      lines.push(`**📦 上下文**　${fmtTokens(contextTokens)} / ${fmtTokens(contextLimit)}　(${pct}%)`)
-    } else {
-      lines.push(`**📦 上下文**　${fmtTokens(contextTokens)}　_窗口待 result 上报_`)
-    }
-  }
-  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'}`)
-  }
-  if (lastTurn) {
-    lines.push(`**🔄 上一轮**　+${fmtTokens(lastTurn.tokens)} · ${fmtCost(lastTurn.costUsd)} · ${fmtDurationMs(lastTurn.durationMs)}`)
-  }
-  if (sessionId) {
-    lines.push(`**🆔 session**　\`${sessionId.slice(0, 8)}…\``)
-  }
-  if (sysinfo) {
-    lines.push(...hostLines(sysinfo))
-  }
-
-  const template = status === 'working' ? 'blue'
-    : status === 'awaiting_permission' ? 'orange'
-    : status === 'stopped' ? 'grey'
-    : 'green'
-
-  return {
-    schema: '2.0',
-    config: { update_multi: true },
-    header: {
-      title: { tag: 'plain_text', content: `🌟 Lodestar · ${sessionName}` },
-      template,
-    },
-    body: {
-      elements: [
-        { 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),
-        },
-      ],
-    },
-  }
-}
-
-interface MenuOpts {
-  question: string
-  options: string[]
-  requestId: string
-}
-
-export function menuCard(opts: MenuOpts): object {
-  const { question, options, requestId } = opts
-  return {
-    schema: '2.0',
-    config: { update_multi: true },
-    header: {
-      title: { tag: 'plain_text', content: '📋 等待选择' },
-      template: 'turquoise',
-    },
-    body: {
-      elements: [
-        { tag: 'markdown', content: question || '_请选择一项：_' },
-        ...options.map((opt, i) => ({
-          tag: 'button',
-          text: { tag: 'plain_text', content: opt },
-          type: 'default',
-          behaviors: [{ type: 'callback', value: { kind: 'menu', request_id: requestId, choice: i } }],
-        })),
-      ],
-    },
-  }
-}
-
-/** 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(' · ') } },
-  }
-}