@leviyuan/lodestar 0.2.1 → 0.2.3

package/README.md

@@ -24,7 +24,6 @@ AI 不是帮手,是倍率。它放大的不是体力,是你——你的直觉、
 - ⌨️ **Type-ahead 不打断**:连珠炮全收,排队下一轮合并处理
 - 🔢 **合并消息加序号**:`[#N]\n` 前缀让模型看清独立边界
 - ⏳ **排队反应可见**:消息进队列加 ⏳,消化/取消自动清/换 ❌
-- 📨 **mid-turn 切新卡**:中途新消息 → 下一 tool 边界切新卡续写
 - ⏰ **定时唤醒可见化**:Cron / ScheduleWakeup 到点自开新卡
 - 📊 **footer 实时指标**:`✅ ⏱时长 · 📊上下文% · 💰本轮成本`
 - 📦 **`hi` 弹控制台**:跨群项目、上下文%、订阅额度一屏看完
@@ -65,7 +64,7 @@ AI 不是帮手,是倍率。它放大的不是体力,是你——你的直觉、
 
 **运行时**:[Bun](https://bun.sh) ≥ 1.0。
 
-**Claude Code**:装好且能跑 —— 详见[官方文档](https://docs.anthropic.com/en/docs/claude-code)。**强烈建议用 claude.ai 账号 OAuth 登录**(`claude auth login`),而不是 `ANTHROPIC_API_KEY`:Cron / ScheduleWakeup / `/schedule` 等定时唤醒工具只在 OAuth 模式下注册。
+**Claude Code**:装好且能跑 —— 详见[官方文档](https://docs.anthropic.com/en/docs/claude-code)。
 
 **飞书自建应用**:去[飞书开放平台](https://open.feishu.cn/app)→ 创建企业自建应用,然后:
 

package/package.json

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

package/src/cards.ts

@@ -595,6 +595,15 @@ function fmtResetIn(date: Date | null): string {
   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: '⚪',
@@ -623,19 +632,22 @@ export function consoleUsageContent(
     case 'network':
       return `**📊 订阅额度**　拉取失败${usage.reason ? ' — `' + usage.reason + '`' : ''}`
   }
-  // state === 'ok'
+  // 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}`
-    : '**📊 订阅额度**'
+    ? `**📊 订阅额度** · ${usage.subscriptionType}${staleNote}`
+    : `**📊 订阅额度**${staleNote}`
   const lines: string[] = [head]
   if (usage.fiveHour) {
     const parts = [`${Math.round(usage.fiveHour.percent)}%`]
-    if (usage.fiveHour.resetsAt) parts.push(`重置 ${fmtResetIn(usage.fiveHour.resetsAt)}`)
+    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(`重置 ${fmtResetIn(usage.weekly.resetsAt)}`)
+    if (usage.weekly.resetsAt) parts.push(`重置 ${resetPrefix}${fmtResetIn(usage.weekly.resetsAt)}`)
     lines.push(`　· 7d　${parts.join(' · ')}`)
   }
   return lines.length === 1 ? '**📊 订阅额度**　_无数据_' : lines.join('\n')
@@ -668,7 +680,7 @@ export function consoleCard(opts: ConsoleOpts): object {
       lines.push(`　· ${dot} \`${p.name}\`${up}${mark}`)
     }
   }
-  if (contextTokens != null) {
+  if (contextTokens != null && contextTokens > 0) {
     const limit = contextLimit ?? 1_000_000
     const pct = limit > 0 ? Math.round((contextTokens / limit) * 100) : 0
     lines.push(`**📦 上下文**　${fmtTokens(contextTokens)} / ${fmtTokens(limit)}　(${pct}%)`)

package/src/session.ts

@@ -137,25 +137,6 @@ export class Session {
    * to clear (via deleteReaction). Empty for eager-opened solo turns
    * and for scheduled wakeups (no user messages went into those). */
   private currentBatchReactionIds = new Map<string, string>()
-  /** Set the moment a mid-turn user message lands. Tells the next
-   * content-adding event (assistant text delta or fresh tool_use) to
-   * rotate the card before applying its update — closes the in-flight
-   * card with a `📨 转交新卡` footer and opens a fresh card, so the
-   * continuation has a visible boundary instead of piling up under
-   * one card. Reset to false after the rotation fires (or on
-   * stop/restart/exit). User feedback (2026-05-15): the prior
-   * everything-in-one-card behavior made the order feel jumbled. */
-  private wantsRotation = false
-  /** Holds assistant / thinking / tool_use events that arrive while a
-   * card rotation is mid-flight (close-old → open-new straddles a
-   * Feishu API await window during which `currentTurn` is transiently
-   * null). Replayed onto the new card the moment rotation completes
-   * so no streamed token is lost across the boundary. */
-  private rotationBuffer: Array<
-    | { kind: 'assistant'; delta: string }
-    | { kind: 'thinking'; delta: string }
-    | { kind: 'tool_use'; id: string; name: string; input: any }
-  > = []
   /** Count of `system/init` events seen this subprocess. The first one is
    * the boot init (claimed by whichever user message lands first); all
    * subsequent ones mark the start of an SDK-initiated turn (queued
@@ -311,8 +292,6 @@ export class Session {
     this.lastUserOpenId = ''
     this.pendingReactionIds = new Map()
     this.currentBatchReactionIds = new Map()
-    this.wantsRotation = false
-    this.rotationBuffer = []
     this.initCount = 0
     this.openingTurn = false
     this.pendingPermissions.clear()
@@ -333,8 +312,6 @@ export class Session {
     this.lastUserOpenId = ''
     this.pendingReactionIds = new Map()
     this.currentBatchReactionIds = new Map()
-    this.wantsRotation = false
-    this.rotationBuffer = []
     this.initCount = 0
     this.openingTurn = false
     this.pendingPermissions.clear()
@@ -416,7 +393,6 @@ export class Session {
         this.lastUserOpenId = ''
         this.pendingReactionIds = new Map()
         this.currentBatchReactionIds = new Map()
-        this.wantsRotation = false
         this.interrupt()
         return true
       case 'kill':
@@ -453,6 +429,7 @@ export class Session {
       // ~5s; not worth blocking the panel on it).
       usage: undefined,
       contextTokens: this.currentContextTokens(),
+      contextLimit: this.contextWindowMax(),
       cumStats: this.cumStats,
       lastTurn: this.lastTurnDelta
         ? {
@@ -536,9 +513,6 @@ export class Session {
           this.pendingReactionIds.set(msgId, rid)
         }
       })()
-      // Rotation hint: a mid-turn user msg means the next assistant /
-      // tool event should split the visual into a new card.
-      this.wantsRotation = true
     }
     if (!this.currentTurn && !this.openingTurn && this.initCount >= 1) {
       // Eager open: this message is going to be processed solo (no current
@@ -853,7 +827,6 @@ export class Session {
       this.lastUserOpenId = ''
       this.pendingReactionIds = new Map()
       this.currentBatchReactionIds = new Map()
-      this.wantsRotation = false
       this.initCount = 0
       this.openingTurn = false
       this.status = 'stopped'
@@ -884,14 +857,17 @@ export class Session {
 
   /** 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. */
+   * the full conversation. Returns 0 when no per-call usage is available
+   * (process dead, or fresh spawn before first assistant message);
+   * `lastTurnDelta.inputTokens` is the CUMULATIVE turn input across all
+   * API calls in the turn (sum of cache_read across N steps) — using it
+   * here would inflate the percentage by Nx after a heavy multi-step
+   * turn (observed bug 2026-05-16: 417% in the `hi` panel after killing
+   * the proc with a long turn's delta still on file). */
   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
+    if (!u) return 0
+    return (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0)
   }
 
   /** Context-window capacity for the model the subprocess is currently
@@ -940,44 +916,8 @@ export class Session {
   // forget here and rely on enqueue source order — that way no `await`
   // can yield mid-handler and let `closeTurnCard` (or another event) race
   // and mutate `this.currentTurn` underfoot.
-  /** Rotate to a fresh card mid-turn: close the in-flight card with a
-   * `📨 转交新卡` footer (distinct from `✅ done` and `🛑 打断`) and
-   * open a new card so the post-user-message continuation has a
-   * visible boundary. Streams that land during the rotation's await
-   * windows are buffered in `rotationBuffer` and replayed onto the
-   * new card the moment it's ready, so no tokens are lost across the
-   * cut. Caller guarantees `wantsRotation` was true sync-immediately
-   * before. */
-  private async rotateCard(): Promise<void> {
-    this.openingTurn = true
-    try {
-      await this.closeTurnCard('📨 转交新卡')
-      await this.openTurnCard('', this.lastUserOpenId, 'user_message')
-    } finally {
-      this.openingTurn = false
-    }
-    if (this.rotationBuffer.length === 0) return
-    const buf = this.rotationBuffer
-    this.rotationBuffer = []
-    for (const e of buf) {
-      if (e.kind === 'assistant') this.appendAssistant(e.delta)
-      else if (e.kind === 'thinking') this.appendThinking(e.delta)
-      else if (e.kind === 'tool_use') this.addTool(e.id, e.name, e.input)
-    }
-  }
-
   private appendAssistant(delta: string): void {
-    if (!this.currentTurn) {
-      if (this.openingTurn) this.rotationBuffer.push({ kind: 'assistant', delta })
-      return
-    }
-    // Note: assistant text DOES NOT trigger rotation, even if a mid-turn
-    // user message landed and set `wantsRotation`. Rotating mid-segment
-    // would chop the model's in-progress reply (often a response to the
-    // ORIGINAL prompt that started this card) onto a fresh card,
-    // visually associating it with the queued msg — which is the bug
-    // the user surfaced 2026-05-16. The rotation defers to the next
-    // tool_use, which is a clean section boundary.
+    if (!this.currentTurn) return
     if (!this.currentTurn.currentAssistantSegmentId) {
       const i = this.currentTurn.assistantSegmentCount++
       const segId = cards.ELEMENTS.assistant(i)
@@ -1003,12 +943,7 @@ export class Session {
   }
 
   private appendThinking(delta: string): void {
-    if (!this.currentTurn) {
-      if (this.openingTurn) this.rotationBuffer.push({ kind: 'thinking', delta })
-      return
-    }
-    // Thinking, like assistant text, doesn't trigger rotation — it's
-    // preamble to the same response, not a section break.
+    if (!this.currentTurn) return
     this.currentTurn.thinkingText += delta
     cardkit.streamTextThrottled(
       this.currentTurn.cardId,
@@ -1026,16 +961,7 @@ export class Session {
   }
 
   private addTool(toolUseId: string, name: string, input: any): void {
-    if (!this.currentTurn) {
-      if (this.openingTurn) this.rotationBuffer.push({ kind: 'tool_use', id: toolUseId, name, input })
-      return
-    }
-    if (this.wantsRotation) {
-      this.wantsRotation = false
-      this.rotationBuffer.push({ kind: 'tool_use', id: toolUseId, name, input })
-      void this.rotateCard()
-      return
-    }
+    if (!this.currentTurn) return
     // Close current assistant segment (if any) so the tool panel renders
     // AFTER it in card body order. Flush queues the segment's last
     // buffered delta before the tool element is inserted.
@@ -1322,15 +1248,15 @@ export class Session {
     }
     const sendNote = sendPaths.length ? ` · 📎 ${sendPaths.length}` : ''
     // State marker leads the footer (✅ for natural completion, or the
-    // suffix verbatim for non-natural states like `📨 转交新卡`). The
+    // suffix verbatim for non-natural states like `🛑 打断`). The
     // trailing "done" word is gone — the ✅ already carries that
     // meaning. User-confirmed footer order 2026-05-16.
     const stateMark = suffix ? suffix : '✅'
     // Per-turn metrics: context-window occupancy (as a real percentage,
     // not a token count) and dollar cost. Only meaningful on a clean
-    // close — suffix-tagged turns (rotation / interrupt) didn't fire
-    // the `result` event that populates `lastTurnDelta`, so these
-    // numbers would be stale and misleading.
+    // close — suffix-tagged turns (interrupt) didn't fire the `result`
+    // event that populates `lastTurnDelta`, so these numbers would be
+    // stale and misleading.
     let metrics = ''
     if (!suffix) {
       const ctxTokens = this.currentContextTokens()

package/src/usage.ts

@@ -26,6 +26,18 @@
  * 调用共享同一份快照,不打 API。in-flight 去重保证并发的多个
  * 群同时唤出控制台时只触发一次后台请求。
  *
+ * Stale fallback (照 omchud HUD 规则): 单独记最后一次成功拉到的
+ * `state:'ok'` 快照,本次拉取失败 (network/rate_limited/auth_failed)
+ * 且距上次成功 <= MAX_STALE_MS (15 分钟) 时,返回上次的 ok 快照并打
+ * `stale:true` 标签,卡片层加 "缓存 Xm 前" 提示。这是 no_fallbacks
+ * 规则的显式例外 —— 用户明确要求订阅额度面板用缓存兜底,因为短暂
+ * 网络抖动里把面板上的数字抹成红色"拉取失败"信息密度反而更低。
+ *
+ * 429 指数退避: 收到 rate_limited 时增加 rateLimitedCount,下次允许
+ * 实拉的时间设为 now + CACHE_TTL_MS * 2^(count-1),封顶 5 分钟。
+ * 退避窗口内的 readUsage 直接走 stale fallback,不打 API。任何非 429
+ * 的响应 (ok / network / auth_failed) 都会重置计数器。
+ *
  * 参考实现: oh-my-claudecode HUD `src/hud/usage-api.ts`。这里只保留
  * Lodestar 用得到的最小子集 —— 不处理 keychain、不处理第三方网关
  * (z.ai / MiniMax)、不处理 enterprise 货币换算、不做多文件 cache 与
@@ -42,6 +54,11 @@ const TOKEN_REFRESH_URL = 'https://platform.claude.com/v1/oauth/token'
 const OAUTH_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e'
 const API_TIMEOUT_MS = 10_000
 const CACHE_TTL_MS = 60_000
+/** 失败时回退到上次成功快照的最大年龄。超过此值就不再用缓存兜底,
+ * 显示真实失败状态 —— 跟 omchud HUD 的 MAX_STALE_DATA_MS 对齐。 */
+const MAX_STALE_MS = 15 * 60 * 1000
+/** 429 退避封顶,跟 omchud HUD 的 MAX_RATE_LIMITED_BACKOFF_MS 对齐。 */
+const RATE_LIMITED_MAX_BACKOFF_MS = 5 * 60 * 1000
 
 function credentialsPath(): string {
   return join(homedir(), '.claude', '.credentials.json')
@@ -73,10 +90,29 @@ export type UsageSnapshot =
       fiveHour: UsageWindow | null
       weekly: UsageWindow | null
       fetchedAt: number
+      /** true 时本快照不是这次实拉的,而是 lastOk 兜底回来的旧数据。
+       * 卡片层据此显示 "缓存" 标记 + 重置时间加 `~` 前缀。 */
+      stale?: boolean
     }
 
+type UsageSnapshotOk = Extract<UsageSnapshot, { state: 'ok' }>
+
 let cache: { data: UsageSnapshot; at: number } | null = null
+/** 最近一次 state:'ok' 的快照,用于失败时兜底。和 cache 分开存:
+ * cache 是短时去重 (60s),lastOk 是长尾兜底 (15min)。 */
+let lastOk: { snapshot: UsageSnapshotOk; at: number } | null = null
 let inFlight: Promise<UsageSnapshot> | null = null
+/** 连续 429 计数,用于指数退避;遇到任何非 429 响应就重置为 0。 */
+let rateLimitedCount = 0
+/** 在这个时间戳之前不打 API,直接走 stale fallback。 */
+let rateLimitedUntil = 0
+
+function rateLimitedBackoffMs(count: number): number {
+  return Math.min(
+    CACHE_TTL_MS * Math.pow(2, Math.max(0, count - 1)),
+    RATE_LIMITED_MAX_BACKOFF_MS,
+  )
+}
 
 function readCredentials(): OAuthCredentials | null {
   const path = credentialsPath()
@@ -246,18 +282,46 @@ async function fetchUsage(): Promise<UsageSnapshot> {
   }
 }
 
+/** 失败快照 → 如果 MAX_STALE_MS 内还有 lastOk,就返回 lastOk 的副本
+ * (打 stale 标);否则透传失败快照。state:'ok' 走 fast path 原样返回。 */
+function withStaleFallback(snapshot: UsageSnapshot): UsageSnapshot {
+  if (snapshot.state === 'ok') return snapshot
+  if (lastOk && Date.now() - lastOk.at < MAX_STALE_MS) {
+    return { ...lastOk.snapshot, stale: true }
+  }
+  return snapshot
+}
+
 /** 返回订阅额度快照。CACHE_TTL_MS 内的重复调用读缓存;并发请求去重为
- * 单次后台 fetch。永不抛出 —— 失败状态由 `state` 字段表达,卡片层
- * 按 state 分支渲染。 */
+ * 单次后台 fetch。拉取失败但 lastOk 仍在 MAX_STALE_MS 内时,回退到
+ * lastOk 并打 stale 标。连续 429 走指数退避,退避窗口内不打 API。
+ * 永不抛出 —— 失败状态由 `state` 字段表达,卡片层按 state 分支渲染。 */
 export async function readUsage(): Promise<UsageSnapshot> {
-  if (cache && Date.now() - cache.at < CACHE_TTL_MS) return cache.data
+  // 429 退避窗口内不打 API。cache 里可能存的就是 rate_limited 失败态,
+  // withStaleFallback 会自动用 lastOk 顶上(15min 内)。
+  if (Date.now() < rateLimitedUntil) {
+    return withStaleFallback(cache?.data ?? { state: 'rate_limited' })
+  }
+  if (cache && Date.now() - cache.at < CACHE_TTL_MS) return withStaleFallback(cache.data)
   if (inFlight) return inFlight
   inFlight = fetchUsage()
-    .then(d => { cache = { data: d, at: Date.now() }; inFlight = null; return d })
+    .then(d => {
+      cache = { data: d, at: Date.now() }
+      if (d.state === 'ok') lastOk = { snapshot: d, at: Date.now() }
+      if (d.state === 'rate_limited') {
+        rateLimitedCount += 1
+        rateLimitedUntil = Date.now() + rateLimitedBackoffMs(rateLimitedCount)
+      } else {
+        rateLimitedCount = 0
+        rateLimitedUntil = 0
+      }
+      inFlight = null
+      return withStaleFallback(d)
+    })
     .catch(e => {
       log(`usage: fetchUsage threw: ${e}`)
       inFlight = null
-      return cache?.data ?? { state: 'network', reason: String(e) }
+      return withStaleFallback({ state: 'network', reason: String(e) })
     })
   return inFlight
 }