@leviyuan/lodestar 0.1.7 → 0.1.8

package/daemon.ts

@@ -91,13 +91,21 @@ async function reviveAliveSessions(): Promise<void> {
 }
 
 // ── 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) {
@@ -116,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)
@@ -154,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
   }
 
@@ -168,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 ────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leviyuan/lodestar",
-  "version": "0.1.7",
+  "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,
@@ -514,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
@@ -557,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 = {
@@ -575,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'}`)
   }
@@ -613,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),
+        },
       ],
     },
   }
@@ -648,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(' · ') } },
+  }
 }

package/src/feishu.ts

@@ -204,6 +204,50 @@ export async function addReaction(messageId: string, emojiType: string): Promise
   } catch (e) { log(`feishu: addReaction ${emojiType} on ${messageId} failed: ${e}`) }
 }
 
+// ── Urgent push ───────────────────────────────────────────────────────
+/** Fire Feishu's "加急 — 应用内" push for an already-sent message.
+ * Bypasses chat-level mute and pops a full-screen prompt on the
+ * recipient's phone. Bot must be the original sender of the message
+ * AND must still be a member of the chat.
+ *
+ * Endpoint:
+ *   PATCH /open-apis/im/v1/messages/{message_id}/urgent_app
+ *   ?user_id_type=open_id
+ *   body: { user_id_list: ["ou_..."] }
+ *
+ * Required app scope (either one):
+ *   - `im:message.urgent`            (「发送应用内加急消息」)
+ *   - `im:message.urgent:app_send`   (「…（历史版本）」)
+ *
+ * Limits: 50 QPS app-wide; per-recipient cap is 200 unread urgent
+ * messages (230023). No daily quota.
+ *
+ * Common error codes:
+ *   230012 — message not sent by this bot
+ *   230023 — recipient has 200 unread urgent already
+ *   230052 — missing scope / chat restricts urgent */
+export async function urgentApp(messageId: string, openIds: string[]): Promise<void> {
+  if (!messageId) { log(`feishu: urgentApp skip — missing messageId`); return }
+  if (openIds.length === 0) { log(`feishu: urgentApp skip — empty openIds (msg=${messageId})`); return }
+  const token = await getTenantToken()
+  const url = `https://open.feishu.cn/open-apis/im/v1/messages/${messageId}/urgent_app?user_id_type=open_id`
+  try {
+    const res = await fetch(url, {
+      method: 'PATCH',
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ user_id_list: openIds }),
+    })
+    const json = await res.json() as any
+    if (json?.code !== 0) {
+      log(`feishu: urgentApp ${messageId} code=${json?.code} msg=${json?.msg}`)
+      return
+    }
+    const invalid = json.data?.invalid_user_id_list ?? []
+    const delivered = openIds.length - invalid.length
+    log(`feishu: urgentApp ${messageId} ok — delivered=${delivered}${invalid.length ? ` invalid=${invalid.length}` : ''}`)
+  } catch (e) { log(`feishu: urgentApp ${messageId} failed: ${e}`) }
+}
+
 // ── Attachment download (image/file) ───────────────────────────────────
 export async function downloadAttachment(
   messageId: string, key: string, type: 'image' | 'file', name?: string,

package/src/session.ts

@@ -16,9 +16,18 @@ import * as cards from './cards'
 import * as feishu from './feishu'
 import { log } from './log'
 import { INBOX_DIR } from './paths'
+import { readUsage } from './usage'
 
 interface TurnState {
   cardId: string
+  /** Feishu message_id of the card — needed for urgent_app push on clean
+   * turn close. Kept separate from cardId because cardkit's stream APIs
+   * operate on card_id but the urgent_app endpoint takes message_id. */
+  messageId: string
+  /** open_id of the user who started this turn. Used to scope the
+   * urgent_app push so only the initiator gets pinged (in case there
+   * are other members in the group). Empty string → skip the ping. */
+  userOpenId: string
   userText: string
   thinkingText: string
   toolCount: number
@@ -73,6 +82,14 @@ interface CumStats {
 }
 
 export class Session {
+  /** Process-wide registry of every Session ever constructed in this daemon.
+   * Used by the `hi` console panel to enumerate sibling sessions across
+   * Feishu groups. Sessions are never removed (matches the daemon's
+   * `sessions` map lifecycle — one Session per chat for the daemon's
+   * lifetime). Callers should filter on `isRunning()` when they only
+   * want currently-alive Claude processes. */
+  static readonly all: Set<Session> = new Set()
+
   private proc: ClaudeProcess | null = null
   private currentTurn: TurnState | null = null
   private pendingPermissions = new Map<string, { toolUseId: string }>()
@@ -125,6 +142,7 @@ export class Session {
     public readonly chatId: string,
     private opts: SessionOpts = {},
   ) {
+    Session.all.add(this)
     // 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`.
@@ -134,6 +152,16 @@ export class Session {
     }
   }
 
+  /** Minimal cross-chat snapshot for the `hi` peer-list section.
+   * `startedAt` stays private so this is the documented read path. */
+  peerSnapshot(): { name: string; status: Status; uptimeMs?: number } {
+    return {
+      name: this.sessionName,
+      status: this.status,
+      uptimeMs: this.startedAt ? (Date.now() - this.startedAt) : undefined,
+    }
+  }
+
   get workDir(): string { return join(feishu.PROJECTS_ROOT, this.sessionName) }
   isRunning(): boolean { return !!this.proc && this.proc.isAlive() }
 
@@ -175,12 +203,21 @@ export class Session {
       await feishu.sendText(this.chatId, `⚪ session "${this.sessionName}" 当前未运行`)
       return
     }
-    this.lastSessionId = this.proc.sessionId ?? this.lastSessionId
-    await this.proc.kill()
+    // Flip lifecycle state SYNCHRONOUSLY before awaiting kill — daemon's
+    // SIGTERM cleanup snapshots `isRunning()` and if we're still mid-
+    // `proc.kill()` await it'll see proc!=null and write us into the
+    // alive marker, which makes the next boot auto-revive a session
+    // the user explicitly killed. Reordering the null-out fixes that
+    // race (bug observed 2026-05-15: `kill` immediately followed by
+    // `systemctl restart` revived the killed session on boot).
+    log(`session "${this.sessionName}": stop (${reason})`)
+    const proc = this.proc
+    this.lastSessionId = proc.sessionId ?? this.lastSessionId
     this.proc = null
     this.currentTurn = null
     this.pendingPermissions.clear()
     this.status = 'stopped'
+    await proc.kill()
     await feishu.sendText(this.chatId, `🔴 ${reason} (session: ${this.sessionName})`)
   }
 
@@ -264,6 +301,14 @@ export class Session {
       model,
       effort: 'max',
       uptimeMs,
+      peers: [...Session.all]
+        .filter(s => s.isRunning())
+        .map(s => ({ ...s.peerSnapshot(), isCurrent: s === this })),
+      // Initial paint without usage → cards.ts renders the
+      // `_加载中…_` placeholder in the consoleUsage element. We patch
+      // it in below once readUsage() resolves (ccusage cold-call is
+      // ~5s; not worth blocking the panel on it).
+      usage: undefined,
       contextTokens: this.currentContextTokens(),
       cumStats: this.cumStats,
       lastTurn: this.lastTurnDelta
@@ -276,7 +321,22 @@ export class Session {
       sessionId: this.proc?.sessionId ?? this.lastSessionId,
       hasSession: this.isRunning(),
     })
-    await feishu.sendCard(this.chatId, card)
+    const messageId = await feishu.sendCard(this.chatId, card)
+    if (!messageId) return
+    // Patch the usage element asynchronously so the rest of the panel
+    // stays responsive. We don't await; failures are logged and the
+    // placeholder stays visible (no fallback fabrication).
+    void (async () => {
+      try {
+        const cardId = await cardkit.convertMessageToCard(messageId)
+        const usage = await readUsage()
+        await cardkit.replaceElement(cardId, cards.ELEMENTS.consoleUsage, {
+          tag: 'markdown',
+          element_id: cards.ELEMENTS.consoleUsage,
+          content: cards.consoleUsageContent(usage),
+        })
+      } catch (e) { log(`session "${this.sessionName}": consoleUsage patch failed: ${e}`) }
+    })()
   }
 
   interrupt(): void {
@@ -286,7 +346,7 @@ export class Session {
   }
 
   // ── Inbound from Feishu ────────────────────────────────────────────
-  async onUserMessage(text: string, files: string[] = []): Promise<void> {
+  async onUserMessage(text: string, files: string[] = [], userOpenId = ''): Promise<void> {
     if (!this.isRunning()) {
       const ok = await this.start()
       if (!ok) return
@@ -296,7 +356,7 @@ export class Session {
       this.proc!.sendInterrupt()
       await this.closeTurnCard('🛑 用户打断')
     }
-    await this.openTurnCard(text)
+    await this.openTurnCard(text, userOpenId)
     this.proc!.sendUserText(text, files)
     this.status = 'working'
   }
@@ -569,7 +629,7 @@ export class Session {
     return this.lastTurnDelta?.inputTokens ?? 0
   }
 
-  private async openTurnCard(userText: string): Promise<void> {
+  private async openTurnCard(userText: string, userOpenId: string): Promise<void> {
     const turn = ++this.turnCounter
     const card = cards.mainConversationCard({
       sessionName: this.sessionName,
@@ -584,6 +644,8 @@ export class Session {
     catch (e) { log(`session "${this.sessionName}": id_convert failed: ${e}`); return }
     this.currentTurn = {
       cardId,
+      messageId,
+      userOpenId,
       userText,
       thinkingText: '',
       toolCount: 0,
@@ -620,6 +682,11 @@ export class Session {
       segId,
       this.currentTurn.currentAssistantText,
     )
+    // Chat-list preview: tail of the latest assistant text. Feishu
+    // truncates anyway; ~60 chars is what shows on a typical phone
+    // preview line. patchSummaryThrottled is rate-limited on its own.
+    const tail = this.currentTurn.currentAssistantText.slice(-60)
+    cardkit.patchSummaryThrottled(this.currentTurn.cardId, tail)
   }
 
   private appendThinking(delta: string): void {
@@ -677,6 +744,11 @@ export class Session {
         type: 'insert_before',
         targetElementId: cards.ELEMENTS.footer,
       })
+      // Phone push — user has to come back and answer before Claude can
+      // continue. urgentApp no-ops when userOpenId is empty.
+      if (this.currentTurn.userOpenId && this.currentTurn.messageId) {
+        void feishu.urgentApp(this.currentTurn.messageId, [this.currentTurn.userOpenId])
+      }
       return
     }
     // Pending Task* panels still show the *pre-op* todo mirror so users
@@ -852,6 +924,10 @@ export class Session {
     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)
+    // Phone push — Claude is blocked until the user approves/denies.
+    if (turn.userOpenId && turn.messageId) {
+      void feishu.urgentApp(turn.messageId, [turn.userOpenId])
+    }
   }
 
   private async closeTurnCard(suffix?: string): Promise<void> {
@@ -896,9 +972,26 @@ export class Session {
     const sendNote = sendPaths.length ? ` · 📎 ${sendPaths.length}` : ''
     const footer = `⏱ ${elapsed}s${suffix ? ' · ' + suffix : ''}${sendNote} · ✅ done`
     await cardkit.streamText(cardId, cards.ELEMENTS.footer, footer)
-    await cardkit.patchSettings(cardId, cards.STREAMING_OFF_SETTINGS)
+    // Final chat-list preview: clean finish shows "⏱ Xs · NK tokens";
+    // interrupted shows the suffix instead (no usage event landed).
+    // cancelSummary kills any in-flight throttled write so a stale
+    // mid-stream tail can't clobber this terminal summary.
+    cardkit.cancelSummary(cardId)
+    await cardkit.patchSettings(cardId, cards.streamingOffSettings({
+      durationSec: elapsed,
+      tokens: suffix ? undefined : this.lastTurnDelta?.tokens,
+      suffix,
+    }))
     await cardkit.dispose(cardId)
 
+    // Phone push on clean turn close so the user knows Claude is done
+    // even with the chat backgrounded. Skip on interrupts (no real
+    // completion) and when we don't know who to ping. Fire-and-forget;
+    // urgent_app failures are non-fatal and already logged in feishu.ts.
+    if (!suffix && turn.userOpenId && turn.messageId) {
+      void feishu.urgentApp(turn.messageId, [turn.userOpenId])
+    }
+
     // Fire uploads sequentially AFTER the card is sealed so each file
     // posts as its own Feishu message below the conversation card.
     // Path gate: workDir (Claude's project sandbox), the inbox where

package/src/usage.ts

@@ -0,0 +1,201 @@
+/**
+ * Subscription usage snapshot for the `hi` console panel.
+ *
+ * Source: the `ccusage` CLI (https://github.com/ryoppippi/ccusage), which
+ * parses Claude Code's local JSONL transcripts on demand. We shell out
+ * twice in parallel and cache the merged result for CACHE_TTL_MS.
+ *
+ *   - `blocks --active --token-limit max` → current 5h billing block.
+ *     `tokenLimitStatus.limit` is ccusage's "peak historical block"
+ *     value, used as the denominator for the 5h percentage. NOTE:
+ *     this is consumption relative to your own heaviest 5h ever —
+ *     NOT the Anthropic tier quota (which we have no way to read
+ *     without OAuth roundtrips). It's an internally-consistent burn
+ *     indicator, not an official quota gauge.
+ *
+ *   - `weekly --order desc` → list of weekly aggregates, newest first.
+ *     ccusage's weekly doesn't expose tokenLimitStatus, so we compute
+ *     the same "peak historical week" ratio locally.
+ *
+ * Failures stay visible (no fallback fabrication):
+ *   - ccusage not on PATH → `installed: false` → card renders install hint.
+ *   - ccusage runs but yields nothing → `fiveHour: null`, `weekly: null`.
+ */
+
+import { spawn } from 'node:child_process'
+import { log } from './log'
+
+const CCUSAGE_BIN = 'ccusage'
+const CACHE_TTL_MS = 60_000
+const SPAWN_TIMEOUT_MS = 15_000
+
+export interface FiveHourBlock {
+  costUsd: number
+  totalTokens: number
+  /** End of the current 5h billing window per ccusage. */
+  windowEndsAt: Date
+  /** Tokens/min over the current window, if ccusage reported one. */
+  burnRatePerMin: number | null
+  /** Consumption vs. user's historical peak 5h block (0–100). Null
+   * when ccusage hasn't built a peak yet (very new install). */
+  percentUsed: number | null
+  /** Minutes left in this 5h window per ccusage's projection. */
+  remainingMinutes: number | null
+}
+
+export interface WeeklyAggregate {
+  /** ISO date of this week's start, format ccusage chose (Sun by default). */
+  weekStart: string
+  costUsd: number
+  totalTokens: number
+  /** Consumption vs. user's historical peak week (0–100). Null when
+   * there's no prior week to compare against. */
+  percentUsed: number | null
+  /** Fractional days remaining until end of week (start + 7d). */
+  remainingDays: number | null
+}
+
+export type UsageSnapshot =
+  | { installed: false }
+  | {
+      installed: true
+      fiveHour: FiveHourBlock | null
+      weekly: WeeklyAggregate | null
+      /** When this snapshot was computed. */
+      fetchedAt: number
+    }
+
+function clampPct(v: number): number {
+  if (!isFinite(v)) return 0
+  return Math.max(0, Math.min(100, v))
+}
+
+let cache: { data: UsageSnapshot; at: number } | null = null
+let inFlight: Promise<UsageSnapshot> | null = null
+
+/** `null` = not on PATH (ENOENT); `undefined` = ran but failed (timeout,
+ * non-zero exit, JSON parse error). Distinct so the caller can render
+ * different UX. */
+type RunResult = any | null | undefined
+
+function runCcusage(args: string[]): Promise<RunResult> {
+  return new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+    let proc
+    try {
+      proc = spawn(CCUSAGE_BIN, args, { stdio: ['ignore', 'pipe', 'pipe'] })
+    } catch (e: any) {
+      if (e?.code === 'ENOENT') return resolve(null)
+      log(`ccusage spawn threw: ${e}`)
+      return resolve(undefined)
+    }
+
+    const timer = setTimeout(() => {
+      proc.kill('SIGTERM')
+      log(`ccusage ${args.join(' ')}: timeout after ${SPAWN_TIMEOUT_MS}ms`)
+    }, SPAWN_TIMEOUT_MS)
+
+    proc.on('error', (err: any) => {
+      clearTimeout(timer)
+      if (err?.code === 'ENOENT') resolve(null)
+      else { log(`ccusage error: ${err}`); resolve(undefined) }
+    })
+    proc.stdout!.on('data', (b) => { stdout += b.toString() })
+    proc.stderr!.on('data', (b) => { stderr += b.toString() })
+    proc.on('close', (code) => {
+      clearTimeout(timer)
+      if (code !== 0) {
+        log(`ccusage ${args.join(' ')}: exit ${code} stderr=${stderr.slice(0, 200)}`)
+        return resolve(undefined)
+      }
+      try { resolve(JSON.parse(stdout)) }
+      catch (e) { log(`ccusage JSON parse: ${e}`); resolve(undefined) }
+    })
+  })
+}
+
+async function fetchUsage(): Promise<UsageSnapshot> {
+  const [blocks, weekly] = await Promise.all([
+    // --active filters to the current 5h block (cheaper to parse).
+    // --token-limit max derives a cap from the user's peak historical
+    // block so ccusage emits `tokenLimitStatus`, giving us a numerator+
+    // denominator without us reading every block ourselves.
+    runCcusage(['blocks', '--json', '--active', '--token-limit', 'max']),
+    runCcusage(['weekly', '--json', '--order', 'desc']),
+  ])
+
+  if (blocks === null || weekly === null) return { installed: false }
+
+  let fiveHour: FiveHourBlock | null = null
+  if (blocks && Array.isArray(blocks.blocks)) {
+    const active = blocks.blocks.find((b: any) => b?.isActive && !b?.isGap)
+    if (active) {
+      const totalTokens = Number(active.totalTokens) || 0
+      const limit = Number(active.tokenLimitStatus?.limit) || 0
+      fiveHour = {
+        costUsd: Number(active.costUSD) || 0,
+        totalTokens,
+        windowEndsAt: new Date(active.endTime),
+        burnRatePerMin: typeof active.burnRate?.tokensPerMinute === 'number'
+          ? active.burnRate.tokensPerMinute : null,
+        percentUsed: limit > 0 ? clampPct((totalTokens / limit) * 100) : null,
+        remainingMinutes: typeof active.projection?.remainingMinutes === 'number'
+          ? active.projection.remainingMinutes : null,
+      }
+    }
+  }
+
+  let wk: WeeklyAggregate | null = null
+  if (weekly && Array.isArray(weekly.weekly) && weekly.weekly.length > 0) {
+    const current = weekly.weekly[0]
+    const totalTokens = Number(current.totalTokens) || 0
+    // Peak historical week (excluding the current one — comparing
+    // against itself would always read 100%). When this is the only
+    // recorded week we leave percentUsed null.
+    const peakTokens = weekly.weekly.slice(1).reduce(
+      (m: number, w: any) => Math.max(m, Number(w?.totalTokens) || 0), 0)
+    const percentUsed = peakTokens > 0 ? clampPct((totalTokens / peakTokens) * 100) : null
+    // Week end = weekStart + 7 days. ccusage emits weekStart as YYYY-MM-DD;
+    // parse as UTC so DST/timezone shifts don't drift the countdown.
+    const weekStartIso = String(current.week ?? '')
+    let remainingDays: number | null = null
+    if (weekStartIso) {
+      const start = new Date(weekStartIso + 'T00:00:00Z')
+      if (!isNaN(start.getTime())) {
+        const endMs = start.getTime() + 7 * 24 * 60 * 60 * 1000
+        remainingDays = Math.max(0, (endMs - Date.now()) / (24 * 60 * 60 * 1000))
+      }
+    }
+    wk = {
+      weekStart: weekStartIso,
+      costUsd: Number(current.totalCost) || 0,
+      totalTokens,
+      percentUsed,
+      remainingDays,
+    }
+  }
+
+  return { installed: true, fiveHour, weekly: wk, fetchedAt: Date.now() }
+}
+
+/** Returns a usage snapshot. Cached for CACHE_TTL_MS; concurrent callers
+ * dedupe to a single in-flight ccusage run. First call after stale-out
+ * pays the full ccusage cost (~5s on this machine); subsequent reads are
+ * instant. Never throws — returns `{ installed: false }` if ccusage is
+ * missing, or an empty `{ installed: true, fiveHour: null, ... }` if it
+ * runs but yields no data. */
+export async function readUsage(): Promise<UsageSnapshot> {
+  if (cache && Date.now() - cache.at < CACHE_TTL_MS) return cache.data
+  if (inFlight) return inFlight
+  inFlight = fetchUsage().then(d => {
+    cache = { data: d, at: Date.now() }
+    inFlight = null
+    return d
+  }).catch(e => {
+    log(`usage: fetchUsage threw: ${e}`)
+    inFlight = null
+    return cache?.data ?? { installed: false }
+  })
+  return inFlight
+}