@leviyuan/lodestar 0.2.6 → 0.2.8

package/package.json

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

package/src/cardkit.ts

@@ -81,7 +81,12 @@ async function call(method: string, path: string, body?: object): Promise<any> {
 }
 
 function isStreamingClosed(e: unknown): boolean {
-  return typeof e === 'object' && e !== null && (e as any).code === 300309
+  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
@@ -98,15 +103,16 @@ async function reopenStreaming(cardId: string): Promise<void> {
 }
 
 /** Run `op` inside the per-card queue. If it fails with code=300309
- * (Feishu auto-closed streaming after the 10-minute TTL), reopen
- * streaming inline and retry `op` exactly once. Anything else — non-
- * 300309 failure, reopen failure, retry failure — is logged and
- * swallowed, matching the fire-and-forget contract every cardkit op
- * already has at the call sites. */
+ * 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()
@@ -114,20 +120,23 @@ async function withReopenOnStreamingClosed(
   } catch (e) {
     if (!isStreamingClosed(e)) {
       log(`cardkit ${label} ${cardId}: ${e}`)
+      if (onFailure) onFailure()
       return
     }
-    log(`cardkit ${label} ${cardId}: streaming closed (300309) — reopening`)
+    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()
   }
 }
 
@@ -201,11 +210,20 @@ export async function flush(cardId: string): Promise<void> {
   }
 }
 
-/** Add a new element to the card body or relative to a sibling. */
+/** 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(
@@ -220,6 +238,7 @@ export function addElement(
         sequence: seq,
       })
     },
+    onFailure,
   ))
   return s.queue
 }

package/src/session.ts

@@ -91,11 +91,14 @@ interface LastTurnDelta {
   inputTokens: number // input + cache_* (excludes output) — context-window estimate
 }
 
-/** Cumulative session counters. Reset on full restart (`clear`), preserved
- * across resume — but resumed conversations start counting from the
- * resume point, not the original turn 0; the SDK doesn't replay historical
- * usage. The session_id continuity is preserved separately by the resume
- * map; cumStats represents "since the current ClaudeProcess was spawned". */
+/** Cumulative session counters. Reset on full restart (`clear`),
+ * preserved across `restart`/resume and daemon-restart so the `hi`
+ * panel reflects the user's total spend in this conversation
+ * regardless of how many times the underlying ClaudeProcess has been
+ * respawned. Resumed conversations start counting from the resume
+ * point onward — the SDK doesn't replay historical usage on resume,
+ * so a long pre-resume conversation shows up as zero here until the
+ * first new turn lands. */
 interface CumStats {
   tokens: number
   costUsd: number
@@ -115,18 +118,25 @@ export class Session {
   private currentTurn: TurnState | null = null
   /** Count of user messages we've written to Claude's stdin since the last
    * turn opened on our side. NOT a FIFO of individual messages — the SDK
-   * batch-merges every mid-turn user message into a single combined turn
-   * once the in-flight turn finishes, so the daemon only ever observes
-   * **one** init event per batch (no matter how many Feishu messages went
-   * into the batch). Tracking a count + last-sender (rather than an
-   * Array<msg>) keeps the daemon's view in sync with the SDK's actual
-   * dequeue semantics. Empirically verified 2026-05-15 from the SDK's
-   * `queue-operation` transcript events: 4 enqueues during a long turn
-   * → single dequeue at turn end → one merged user message. Count is
-   * decremented to 0 wholesale at the `init` boundary because the SDK
-   * has already collapsed them into one turn. Distinguishes user-msg
-   * turns from cron-fired scheduled wakeups: count > 0 ⇒ user;
-   * count === 0 ⇒ scheduled (and `initCount > 1`). */
+   * USUALLY batch-merges every mid-turn user message into a single
+   * combined turn once the in-flight turn finishes, so most of the time
+   * the daemon observes **one** init event per batch. Tracking a count +
+   * last-sender (rather than an Array<msg>) keeps the daemon's view
+   * loosely in sync with the SDK's dequeue semantics. Caveat verified
+   * 2026-05-17 (test1 accumulator, 8-message rapid-fire): when the first
+   * write lands in an idle SDK, that single msg gets its own turn and
+   * the rest merge into a second turn — i.e. 1+(N-1) split, not always
+   * one merge. To stay coherent with this, `drainMidTurnAndOpen` bumps
+   * the count by `batch.length` up front (covering both the first solo
+   * turn and the eventual merged tail), and the init handler resets to
+   * 0 on the first claim. If the SDK takes the merge path, the bail at
+   * `currentTurn=yes` in the init handler leaves pendingCount stale (>0)
+   * until the GC at the next `onUserMessage`; if it takes the split
+   * path, the second init sees pendingCount>0 and correctly classifies
+   * the trailing batch as user-batch (not a scheduled wakeup).
+   * Distinguishes user-msg turns from cron-fired scheduled
+   * wakeups: count > 0 ⇒ user; count === 0 ⇒ scheduled (and
+   * `initCount > 1`). */
   private pendingUserMessageCount = 0
   /** Mid-turn user messages buffered DAEMON-SIDE (not yet sendUserText'd
    * to the SDK). Drained in the `result` handler by writing each to SDK
@@ -294,6 +304,27 @@ export class Session {
     return true
   }
 
+  /** Drop every ⏳ OneSecond reaction this session is currently holding
+   * on user chat messages, then empty the two tracking maps. Used by
+   * every tear-down path (proc exit, kill, restart) so reactions don't
+   * outlive the conversation that placed them — without this, a Claude
+   * crash / daemon SIGTERM leaves orphan ⏳ stuck on user messages until
+   * Feishu's UI eventually GCs them (which it doesn't, in practice).
+   * closeTurnCard has its own release pass (with the slightly-early
+   * merged-batch trade-off documented there); this is the catastrophic-
+   * exit pass. Direct `deleteReaction` calls are fire-and-forget and
+   * swallow their own failures (see feishu.deleteReaction). */
+  private releaseAllReactions(): void {
+    for (const [msgId, rid] of [
+      ...this.pendingReactionIds.entries(),
+      ...this.currentBatchReactionIds.entries(),
+    ]) {
+      if (rid) void feishu.deleteReaction(msgId, rid)
+    }
+    this.pendingReactionIds = new Map()
+    this.currentBatchReactionIds = new Map()
+  }
+
   async stop(reason = '已终止'): Promise<void> {
     if (!this.proc) {
       this.status = 'stopped'
@@ -315,8 +346,7 @@ export class Session {
     this.pendingUserMessageCount = 0
     this.pendingMidTurnMsgs = []
     this.lastUserOpenId = ''
-    this.pendingReactionIds = new Map()
-    this.currentBatchReactionIds = new Map()
+    this.releaseAllReactions()
     this.initCount = 0
     this.openingTurn = false
     this.pendingPermissions.clear()
@@ -336,8 +366,7 @@ export class Session {
     this.pendingUserMessageCount = 0
     this.pendingMidTurnMsgs = []
     this.lastUserOpenId = ''
-    this.pendingReactionIds = new Map()
-    this.currentBatchReactionIds = new Map()
+    this.releaseAllReactions()
     this.initCount = 0
     this.openingTurn = false
     this.pendingPermissions.clear()
@@ -619,25 +648,37 @@ export class Session {
     //   - first message after spawn (init not yet fired)
     //   - bootstrap race (sibling msgs landing before init#1)
     //   - solo message after a prior turn has fully closed
-    this.proc!.sendUserText(wireText, files)
-    this.pendingUserMessageCount++
-    if (wasBusy && msgId) {
-      // Bootstrap race: the init handler will open the card for us; until
-      // then the OneSecond ⏳ is the only ack the user gets.
-      trackReaction(msgId)
-    }
+    // Eager-open path: open the card BEFORE feeding SDK, so a card-open
+    // failure doesn't strand the daemon with SDK processing a turn we
+    // have nowhere to render. `!openingTurn` means no sibling is mid-
+    // open; `initCount >= 1` means SDK boot init has fired (otherwise
+    // the init handler owns turn opening and we just feed the queue
+    // below). On failure openTurnCard surfaces a red banner via
+    // sendTextRaw; SDK was idle so no interrupt needed.
     if (!this.openingTurn && this.initCount >= 1) {
-      // Eager open: SDK is healthy and idle, open card now. Any extra
-      // messages arriving during the open's Feishu API await pile up in
-      // the count and the init handler batches them.
       this.openingTurn = true
-      this.pendingUserMessageCount--
       try {
         await this.openTurnCard(userOpenId, 'user_message')
+        if (!this.currentTurn) return
+        this.proc!.sendUserText(wireText, files)
+        this.pendingUserMessageCount++
         this.status = 'working'
       } finally {
         this.openingTurn = false
       }
+      return
+    }
+
+    // Non-eager path: either init hasn't fired yet (cold start) or a
+    // sibling onUserMessage is already opening. Feed SDK directly; the
+    // init handler / sibling card-opener will batch this message in.
+    this.proc!.sendUserText(wireText, files)
+    this.pendingUserMessageCount++
+    if (wasBusy && msgId) {
+      // Bootstrap race / sibling-opening race: until a card is open,
+      // the OneSecond ⏳ is the only ack the user gets. The init handler
+      // inherits these via currentBatchReactionIds when it opens.
+      trackReaction(msgId)
     }
   }
 
@@ -873,7 +914,19 @@ export class Session {
       void (async () => {
         try {
           await this.openTurnCard(userOpenId, isUserBatch ? 'user_message' : 'scheduled')
-          this.status = 'working'
+          if (!this.currentTurn) {
+            // SDK already started this turn (its `init` is what got us
+            // here) but we have no card to render into. Interrupt so
+            // assistant/tool events aren't silently dropped while the
+            // model burns tokens. Release the reactions this batch
+            // inherited (init handler moved them above) — otherwise
+            // they stay ⏳ forever on the user's chat messages.
+            log(`session "${this.sessionName}": init-path openTurnCard failed — sendInterrupt + release reactions`)
+            this.proc?.sendInterrupt()
+            this.releaseAllReactions()
+          } else {
+            this.status = 'working'
+          }
         } finally {
           this.openingTurn = false
         }
@@ -923,8 +976,7 @@ export class Session {
       this.pendingUserMessageCount = 0
       this.pendingMidTurnMsgs = []
       this.lastUserOpenId = ''
-      this.pendingReactionIds = new Map()
-      this.currentBatchReactionIds = new Map()
+      this.releaseAllReactions()
       this.initCount = 0
       this.openingTurn = false
       this.status = 'stopped'
@@ -984,7 +1036,17 @@ export class Session {
    * calls wake the SDK polling loop (priority="now" semantics) and
    * comprise the input for the new turn. Opens the card here rather
    * than deferring to init because the init for this batch will arrive
-   * with `currentTurn` already set and bail. */
+   * with `currentTurn` already set and bail.
+   *
+   * Each sendUserText also bumps `pendingUserMessageCount`. The SDK
+   * USUALLY collapses our N writes into one merged turn, but **not
+   * always** — empirically observed 2026-05-17, test1 accumulator
+   * session: when the first write lands in an idle SDK (turn just
+   * ended), the SDK eagerly starts a turn for that msg alone, then
+   * merges the rest into a second turn. Without the bump here, that
+   * second turn fires an `init` with `pendingUserMessageCount === 0`
+   * and the init handler misclassifies it as a scheduled wakeup,
+   * painting the `⏰ 触发` banner on what is really a user batch. */
   private async drainMidTurnAndOpen(): Promise<void> {
     if (this.pendingMidTurnMsgs.length === 0) return
     const batch = this.pendingMidTurnMsgs
@@ -993,6 +1055,7 @@ export class Session {
     try {
       for (const msg of batch) {
         this.proc!.sendUserText(msg.wireText, msg.files)
+        this.pendingUserMessageCount++
         if (msg.msgId) {
           const rid = this.pendingReactionIds.get(msg.msgId) ?? ''
           this.currentBatchReactionIds.set(msg.msgId, rid)
@@ -1031,11 +1094,10 @@ export class Session {
         this.chatId,
         '❌ 创建对话卡片失败 (Feishu SDK 重试 3 次后仍连不上)。你这条消息没能送到 Claude,请稍后重发。',
       )
-      // Halt Claude — we already wrote the user text to its stdin in
-      // onUserMessage, but with no card to stream into the response would
-      // be lost. Interrupt now so the model doesn't burn tokens producing
-      // an answer that has nowhere to land.
-      this.proc?.sendInterrupt()
+      // currentTurn left null as the failure signal. Caller decides
+      // whether to sendInterrupt: onUserMessage's eager-open path
+      // hasn't fed SDK yet so doesn't need to; the init handler has
+      // (SDK started the turn itself) and must.
       return
     }
     let cardId: string
@@ -1066,32 +1128,42 @@ export class Session {
   // and mutate `this.currentTurn` underfoot.
   private appendAssistant(delta: string): void {
     if (!this.currentTurn) return
-    if (!this.currentTurn.currentAssistantSegmentId) {
+    const turn = this.currentTurn
+    if (!turn.currentAssistantSegmentId) {
       // New assistant segment opens a visual break — any prior Read run
       // is now visually separated from future Reads, so close the batch
       // window. Future Reads will start a fresh batch at a new i.
-      this.currentTurn.openReadBatchI = null
-      const i = this.currentTurn.assistantSegmentCount++
+      turn.openReadBatchI = null
+      const i = turn.assistantSegmentCount++
       const segId = cards.ELEMENTS.assistant(i)
-      this.currentTurn.currentAssistantSegmentId = segId
-      this.currentTurn.currentAssistantText = ''
-      void cardkit.addElement(this.currentTurn.cardId, cards.assistantSegmentElement(i), {
+      turn.currentAssistantSegmentId = segId
+      turn.currentAssistantText = ''
+      void cardkit.addElement(turn.cardId, cards.assistantSegmentElement(i), {
         type: 'insert_before', targetElementId: cards.ELEMENTS.footer,
+      }, () => {
+        // addElement永久失败:reset segmentId 让下次 delta 重新创建
+        // segment,否则后续 streamText 全都 PUT 到不存在的 element,
+        // 整段 assistant text 在用户那看不到。守 segId 不变以防 turn
+        // rotation 或 addTool 已经清掉了它(每次 addElement 闭包带的
+        // 是自己创建那次的 segId,只清自己的)。
+        if (turn.currentAssistantSegmentId === segId) {
+          log(`session "${this.sessionName}": assistant segment ${segId} addElement failed — will retry on next delta`)
+          turn.currentAssistantSegmentId = null
+          turn.currentAssistantText = ''
+          turn.segmentTexts.delete(segId)
+        }
       })
     }
-    this.currentTurn.currentAssistantText += delta
-    const segId = this.currentTurn.currentAssistantSegmentId
-    this.currentTurn.segmentTexts.set(segId, this.currentTurn.currentAssistantText)
-    cardkit.streamTextThrottled(
-      this.currentTurn.cardId,
-      segId,
-      this.currentTurn.currentAssistantText,
-    )
+    turn.currentAssistantText += delta
+    const segId = turn.currentAssistantSegmentId
+    if (!segId) return  // addElement 已失败 reset,等下一次 delta 重建
+    turn.segmentTexts.set(segId, turn.currentAssistantText)
+    cardkit.streamTextThrottled(turn.cardId, segId, turn.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)
+    const tail = turn.currentAssistantText.slice(-60)
+    cardkit.patchSummaryThrottled(turn.cardId, tail)
   }
 
   private appendThinking(delta: string): void {