@leviyuan/lodestar 0.2.5 → 0.2.7

package/daemon.ts

@@ -11,13 +11,13 @@
  */
 
 import * as lark from '@larksuiteoapi/node-sdk'
-import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
 import { dirname } from 'node:path'
 import { Session } from './src/session'
 import * as feishu from './src/feishu'
 import { config } from './src/config'
 import { log } from './src/log'
-import { PID_FILE } from './src/paths'
+import { DEBUG_CTX_FILE, DEBUG_SOCK_FILE, PID_FILE } from './src/paths'
 
 // ── PID guard ───────────────────────────────────────────────────────────
 try {
@@ -44,6 +44,7 @@ const cleanup = () => {
     if (alive.length > 0) log(`alive marker: [${alive.join(', ')}]`)
   } catch (e) { log(`alive marker write failed: ${e}`) }
   try { unlinkSync(PID_FILE) } catch {}
+  try { unlinkSync(DEBUG_SOCK_FILE) } catch {}
 }
 process.on('exit', cleanup)
 process.on('SIGTERM', () => { log('SIGTERM'); cleanup(); process.exit(0) })
@@ -126,6 +127,29 @@ async function handleMessage(data: any): Promise<void> {
   }
 
   const chatId = message.chat_id as string
+
+  // `[DEBUG]` prefix — seed the inject context with the real chat/sender
+  // captured from a live WS event, then strip the prefix and continue as
+  // normal. The injector script (scripts/test-inject.ts) reads this
+  // context to replay arbitrary messages without the user touching Feishu.
+  let contentObjForDebug: any = {}
+  try { contentObjForDebug = JSON.parse(message.content ?? '{}') } catch {}
+  const debugTextRaw = (message.message_type === 'text' ? contentObjForDebug.text ?? '' : '')
+  if (typeof debugTextRaw === 'string' && debugTextRaw.startsWith('[DEBUG]')) {
+    try {
+      writeFileSync(DEBUG_CTX_FILE, JSON.stringify({
+        chat_id: chatId,
+        sender_open_id: userOpenId,
+        seeded_at: new Date().toISOString(),
+        seeded_msg_id: msgId ?? '',
+      }, null, 2))
+      log(`debug: seeded inject context chat=${chatId.slice(0, 8)}… sender=${userOpenId.slice(0, 8)}…`)
+    } catch (e) { log(`debug: seed context failed: ${e}`) }
+    const stripped = debugTextRaw.slice('[DEBUG]'.length)
+    contentObjForDebug.text = stripped
+    message.content = JSON.stringify(contentObjForDebug)
+  }
+
   let groupName = feishu.chatNameCache.get(chatId)
   if (!groupName) {
     await feishu.refreshChatList()
@@ -218,6 +242,55 @@ function fmt(m: any[]): string {
   return m.map(x => typeof x === 'string' ? x : JSON.stringify(x)).join(' ')
 }
 
+// ── Debug message injection ─────────────────────────────────────────────
+// Listens on a unix socket so scripts/test-inject.ts can replay messages
+// through the same `handleMessage` path that real WS events take. Seeded
+// by a one-time `[DEBUG]<anything>` from the real Feishu user; from then
+// on the injector reuses that chat_id + sender_open_id.
+function startDebugSocket(): void {
+  try { if (existsSync(DEBUG_SOCK_FILE)) unlinkSync(DEBUG_SOCK_FILE) } catch {}
+  try {
+    Bun.serve({
+      unix: DEBUG_SOCK_FILE,
+      fetch: async (req: Request) => {
+        if (req.method !== 'POST') return new Response('use POST', { status: 405 })
+        let body: any = {}
+        try { body = await req.json() } catch { return new Response('bad json', { status: 400 }) }
+        if (!existsSync(DEBUG_CTX_FILE)) {
+          return new Response('no debug context yet — send `[DEBUG]hi` from Feishu first', { status: 412 })
+        }
+        let ctx: any = {}
+        try { ctx = JSON.parse(readFileSync(DEBUG_CTX_FILE, 'utf8')) } catch (e) {
+          return new Response(`ctx read failed: ${e}`, { status: 500 })
+        }
+        const text: string = String(body.text ?? '')
+        if (!text) return new Response('text required', { status: 400 })
+        const fakeMsgId = `om_DEBUG_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`
+        const payload = {
+          sender: { sender_id: { open_id: ctx.sender_open_id } },
+          message: {
+            message_id: fakeMsgId,
+            chat_id: ctx.chat_id,
+            message_type: 'text',
+            content: JSON.stringify({ text }),
+            create_time: String(Date.now()),
+          },
+        }
+        log(`debug: inject text=${JSON.stringify(text).slice(0, 80)} fake_id=${fakeMsgId}`)
+        // Don't await — match real WS dispatcher behavior (fire-and-forget per event).
+        handleMessage(payload).catch(e => log(`debug: handleMessage rejected: ${e}`))
+        return new Response(JSON.stringify({ ok: true, fake_msg_id: fakeMsgId }), {
+          headers: { 'content-type': 'application/json' },
+        })
+      },
+    })
+    try { chmodSync(DEBUG_SOCK_FILE, 0o600) } catch {}
+    log(`debug: inject socket listening at ${DEBUG_SOCK_FILE}`)
+  } catch (e) {
+    log(`debug: socket bind failed: ${e}`)
+  }
+}
+
 async function boot(): Promise<void> {
   log(`lodestar-daemon: pid ${process.pid} starting`)
   feishu.loadSessionChatMap()
@@ -269,6 +342,8 @@ async function boot(): Promise<void> {
   ws.start({ eventDispatcher: dispatcher })
   log(`lodestar-daemon: WS started, watching ${feishu.chatNameCache.size} groups`)
 
+  startDebugSocket()
+
   // Auto-revive sessions that were running when we last went down.
   // Runs AFTER the WS is up so any 🔁 revive message lands in the
   // right chat instead of disappearing into the void.

package/package.json

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

package/src/cardkit.ts

@@ -73,11 +73,68 @@ async function call(method: string, path: string, body?: object): Promise<any> {
   })
   const json = await res.json() as any
   if (json?.code && json.code !== 0) {
-    throw new Error(`cardkit ${method} ${path}: code=${json.code} msg=${json.msg}`)
+    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 {
+  return typeof e === 'object' && e !== null && (e as any).code === 300309
+}
+
+/** 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
+ * (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. */
+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 (300309) — 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 })
@@ -101,17 +158,17 @@ export async function createCardEntity(card: object): Promise<string> {
 export function streamText(cardId: string, elementId: string, content: string): Promise<void> {
   if (!content || !content.trim()) return Promise.resolve()
   const s = state(cardId)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
+  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)
-    } catch (e) {
-      log(`cardkit streamText ${cardId}/${elementId}: ${e}`)
-    }
-  })
+    },
+  ))
   return s.queue
 }
 
@@ -148,53 +205,69 @@ 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)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
+  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,
       })
-    } catch (e) { log(`cardkit addElement ${cardId}: ${e}`) }
-  })
+    },
+    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)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
+  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,
       })
-    } catch (e) { log(`cardkit replaceElement ${cardId}/${elementId}: ${e}`) }
-  })
+    },
+  ))
   return s.queue
 }
 
 /** Delete an element by id. */
 export function deleteElement(cardId: string, elementId: string): Promise<void> {
   const s = state(cardId)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
+  s.queue = s.queue.then(() => withReopenOnStreamingClosed(
+    cardId,
+    `deleteElement ${elementId}`,
+    async () => {
+      const seq = nextSeq(cardId)
       await call('DELETE', `/cards/${cardId}/elements/${elementId}`, {
         sequence: seq,
       })
-    } catch (e) { log(`cardkit deleteElement ${cardId}/${elementId}: ${e}`) }
-  })
+    },
+  ))
   return s.queue
 }
 
@@ -235,12 +308,22 @@ export function cancelSummary(cardId: string): void {
   summaryStates.delete(cardId)
 }
 
-/** Patch settings — used to flip streaming_mode off when a turn finishes. */
+/** 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)
-  const seq = nextSeq(cardId)
   s.queue = s.queue.then(async () => {
     try {
+      const seq = nextSeq(cardId)
       await call('PATCH', `/cards/${cardId}/settings`, {
         settings: JSON.stringify(settings),
         sequence: seq,

package/src/cards.ts

@@ -74,7 +74,7 @@ export function summarizeToolInput(name: string, input: any): string {
     return truncate(summarizeTaskWorkflow(name, input), 80)
   }
   switch (name) {
-    case 'Bash':       return truncate(String(input.command ?? ''), 80)
+    case 'Bash':       return truncate(String(input.description ?? input.command ?? ''), 80)
     case 'Read':
     case 'Write':
     case 'Edit':
@@ -181,7 +181,7 @@ interface MainCardOpts {
 /** Initial card sent at the start of each turn. Streaming on. */
 export function mainConversationCard(opts: MainCardOpts): object {
   const banner = opts.kind === 'scheduled'
-    ? [{ tag: 'markdown', content: '⏰ **定时任务触发** — Claude 在 idle 间隙被 CronCreate / ScheduleWakeup 唤醒' }]
+    ? [{ tag: 'markdown', content: '⏰ 触发' }]
     : []
   return {
     schema: '2.0',
@@ -276,6 +276,30 @@ export function toolCallElement(
   }
 }
 
+/** Merged panel for a run of consecutive `Read` tool calls in one turn.
+ * Header shows the dynamic count (`Read · 3 次`), body lists one row per
+ * Read with its own status + file path. Replaces the individual panels
+ * once a second Read joins the batch — single Reads still render as the
+ * full `toolCallElement` (with file-contents dump on completion). */
+export function readBatchElement(
+  i: number,
+  items: Array<{ input: any; output: string | null; isError: boolean }>,
+): object {
+  const n = items.length
+  const anyError = items.some(it => it.isError)
+  const allDone = items.every(it => it.output !== null)
+  const status = anyError ? '❌' : allDone ? '✅' : '⏳'
+  const headerText = `${status} 🔧 Read · ${n} 次`
+  const lines = items.map(it => `\`${String(it.input.file_path ?? '(无 path)')}\``)
+  return {
+    tag: 'collapsible_panel',
+    element_id: ELEMENTS.tool(i),
+    header: { title: { tag: 'plain_text', content: headerText } },
+    expanded: false,
+    elements: [{ tag: 'markdown', content: lines.join('\n') }],
+  }
+}
+
 /** Same tool panel as `toolCallElement`, but with the 🔐 status and
  * three inline action buttons (allow / allow_always / deny). Expanded
  * by default so the user can read the request without clicking through.

package/src/paths.ts

@@ -47,3 +47,11 @@ export const SESSION_RESUME_MAP_FILE = join(DATA_DIR, 'session-resume-map.json')
  * Lodestar's "you have to send a message to re-spawn it" default. */
 export const ALIVE_MARKER_FILE = join(DATA_DIR, 'alive-on-shutdown.json')
 export const INBOX_DIR = join(DATA_DIR, 'inbox')
+/** Unix-socket endpoint the daemon listens on for debug message
+ * injection (see scripts/test-inject.ts). A real Feishu user sends
+ * a `[DEBUG]…` text once to seed `DEBUG_CTX_FILE` with chat_id +
+ * sender_open_id; the injector then POSTs `{text}` here and the
+ * daemon replays it through `handleMessage` as if WS had delivered
+ * it. File mode 0600 — daemon-private, never network-exposed. */
+export const DEBUG_SOCK_FILE = join(DATA_DIR, 'debug.sock')
+export const DEBUG_CTX_FILE = join(DATA_DIR, 'debug-context.json')

package/src/session.ts

@@ -47,7 +47,23 @@ interface TurnState {
     resolvedNote?: string
     output?: string
     isError?: boolean
+    /** Set when this tool is part of a merged Read batch — points to the
+     * batch's slot in `readBatches[i].items`. completeTool uses it to
+     * update the right row instead of rendering a standalone panel. */
+    readBatchSlot?: number
   }>
+  /** Consecutive `Read` calls collapse into a single panel rendered by
+   * `cards.readBatchElement`. Keyed by element index `i` so completeTool
+   * can find the batch after its open-window closed (a non-Read tool or
+   * new assistant segment has since arrived).
+   *
+   * `openReadBatchI` is the i of the batch currently accepting new Reads;
+   * null once the run ends. Subsequent Read calls open a fresh batch at a
+   * new i. */
+  readBatches: Map<number, {
+    items: Array<{ toolUseId: string; input: any; output: string | null; isError: boolean }>
+  }>
+  openReadBatchI: number | null
   assistantSegmentCount: number
   currentAssistantSegmentId: string | null
   currentAssistantText: string
@@ -75,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
@@ -112,6 +131,15 @@ export class Session {
    * 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
+   * stdin, which doubles as the `priority="now"` wake signal the SDK
+   * polling loop needs to start the next batch turn (the SDK won't
+   * auto-dequeue queued type-ahead msgs after `result` — confirmed via
+   * claude-code issue #39632). Buffering also keeps mid-turn msgs out
+   * of any AskUserQuestion `QUEUE remove` storm, since they were never
+   * in the SDK queue to begin with. */
+  private pendingMidTurnMsgs: Array<{ wireText: string; files: string[]; userOpenId: string; msgId: string }> = []
   /** Most recent userOpenId seen via `onUserMessage`. Used only when a
    * merged batch fires its init event and the daemon needs *some* open_id
    * to scope the eventual `urgent_app` push — there's no obviously right
@@ -269,6 +297,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'
@@ -288,9 +337,9 @@ export class Session {
     this.proc = null
     this.currentTurn = null
     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()
@@ -308,9 +357,9 @@ export class Session {
     }
     this.currentTurn = null
     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()
@@ -372,11 +421,11 @@ export class Session {
         // but the daemon can't reach into it directly; in practice the
         // sendInterrupt() control_request causes the SDK to discard
         // queued input alongside the in-flight call.
-        if (!this.currentTurn && this.pendingUserMessageCount === 0) {
+        if (!this.currentTurn && this.pendingUserMessageCount === 0 && this.pendingMidTurnMsgs.length === 0) {
           await feishu.sendText(this.chatId, '⚪ 当前没有正在执行的 turn')
           return true
         }
-        log(`session "${this.sessionName}": stop command — interrupt + drop count=${this.pendingUserMessageCount}`)
+        log(`session "${this.sessionName}": stop command — interrupt + drop count=${this.pendingUserMessageCount} midBuffer=${this.pendingMidTurnMsgs.length}`)
         // Cancelled queued msgs: remove the OneSecond (no longer waiting)
         // and stamp a CrossMark (explicit cancelled state, distinct from
         // a natural release where reactions just disappear). Cancelled
@@ -388,11 +437,20 @@ export class Session {
           if (rid) void feishu.deleteReaction(msgId, rid)
           void feishu.addReaction(msgId, 'CrossMark')
         }
+        // Mid-turn buffer never reached SDK — cancel those too.
+        for (const msg of this.pendingMidTurnMsgs) {
+          if (msg.msgId) void feishu.addReaction(msg.msgId, 'CrossMark')
+        }
         this.pendingUserMessageCount = 0
+        this.pendingMidTurnMsgs = []
         this.lastUserOpenId = ''
         this.pendingReactionIds = new Map()
         this.currentBatchReactionIds = new Map()
         this.interrupt()
+        // SDK 收到 interrupt 后不发 `result`,没人会触发 closeTurnCard。
+        // 这里主动封口,把 footer 改成 🛑 打断、折叠 thinking、把
+        // streaming_mode 翻回 false,否则卡片会僵在 `⏳ working…`。
+        await this.closeTurnCard('🛑 打断')
         return true
       case 'kill':
         await this.stop()
@@ -532,8 +590,8 @@ export class Session {
     // reaction) and the model would see e.g. "123" + "321" + "1"
     // glued into a single string "1233211" (2026-05-16 accumulator
     // bug).
-    const wasBusy = this.currentTurn !== null || this.openingTurn || this.pendingUserMessageCount > 0
-    this.pendingUserMessageCount++
+    const wasBusy = this.currentTurn !== null || this.openingTurn
+      || this.pendingUserMessageCount > 0 || this.pendingMidTurnMsgs.length > 0
     this.lastUserOpenId = userOpenId
     // When the SDK will merge this msg with siblings into a multi-
     // content user turn, wrap it in `<u>...</u>` so the model sees a
@@ -547,59 +605,73 @@ export class Session {
     // skips the wrap — no sibling, no merge, no need. Contract
     // declared in CHANNEL_INSTRUCTIONS.
     const wireText = wasBusy ? `<u>${text}</u>` : text
-    this.proc!.sendUserText(wireText, files)
-    if (wasBusy && msgId) {
-      // Hold the slot in the map even if the API call hasn't returned
-      // yet — empty string is a sentinel meaning "we tried to react;
-      // reaction_id pending". When deleteReaction time comes, an empty
-      // string is a no-op (deleteReaction guards against it), which is
-      // the right behavior if the add failed.
-      this.pendingReactionIds.set(msgId, '')
+
+    // Reaction helper: track the OneSecond reaction so deleteReaction can
+    // clear it later. Use empty-string sentinel until addReaction returns.
+    const trackReaction = (id: string) => {
+      this.pendingReactionIds.set(id, '')
       void (async () => {
-        const rid = await feishu.addReaction(msgId, 'OneSecond')
+        const rid = await feishu.addReaction(id, 'OneSecond')
         if (!rid) return
-        if (this.pendingReactionIds.has(msgId)) {
-          this.pendingReactionIds.set(msgId, rid)
-        } else if (this.currentBatchReactionIds.has(msgId)) {
-          // Init handler renamed the sentinel into the batch map while
-          // addReaction was in flight — record the rid there so the
-          // batch's close-time deleteReaction sees it.
-          this.currentBatchReactionIds.set(msgId, rid)
+        if (this.pendingReactionIds.has(id)) {
+          this.pendingReactionIds.set(id, rid)
+        } else if (this.currentBatchReactionIds.has(id)) {
+          this.currentBatchReactionIds.set(id, rid)
         } else {
-          // Orphan: both maps cleared (closeTurnCard already released
-          // them) before our add returned. The reaction is now stuck
-          // on the Feishu message with no one tracking it — delete
+          // Orphan: both maps cleared before our add returned. Delete
           // directly so the user doesn't see a stale ⏳ forever.
-          // (Observed bug 2026-05-16: 8 OneSeconds added during a M0
-          // turn, 2 addReaction callbacks landed after close fired the
-          // release loop, those rids never made it back into either
-          // map → 2 stuck ⏳ in chat.)
-          void feishu.deleteReaction(msgId, rid)
+          void feishu.deleteReaction(id, rid)
         }
       })()
     }
-    // Mid-turn user messages don't touch the in-flight card — the SDK
-    // queues them and dequeues them on its next turn boundary, at
-    // which point `result` closes the current card with `📨 转交新卡`
-    // and `init` opens a fresh card for the merged batch turn. The
-    // user's own message bubble in the chat (plus the OneSecond ⏳
-    // reaction added above) is the only mid-flight feedback they get;
-    // no card edit, no echo inside the card.
-    if (!this.currentTurn && !this.openingTurn && this.initCount >= 1) {
-      // Eager open: this message is going to be processed solo (no current
-      // turn to merge with on the SDK side, so SDK runs it as its own turn).
-      // Claim one count and open the card with this message's own text +
-      // sender; any *additional* messages arriving during the open's
-      // Feishu API await will pile up in the count and get batched by the
-      // SDK into the NEXT turn (handled by the init handler).
+
+    if (this.currentTurn !== null) {
+      // Mid-turn — BUFFER instead of immediate sendUserText. The SDK polling
+      // loop will not auto-dequeue queued type-ahead msgs after `result`
+      // (only `priority="now"` writes wake it — claude-code issue #39632),
+      // so writing here would leave the msg stuck until the next user msg
+      // arrives. Drain happens in the `result` handler, which both wakes
+      // the SDK and opens a fresh card for the new batch turn.
+      this.pendingMidTurnMsgs.push({ wireText, files, userOpenId, msgId })
+      if (msgId) trackReaction(msgId)
+      return
+    }
+
+    // No in-flight turn: send straight to SDK. This path handles
+    //   - 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
+    // 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) {
       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)
     }
   }
 
@@ -655,7 +727,7 @@ export class Session {
    * acknowledgement that their type-ahead message landed (the card
    * doesn't open until the current turn finishes). */
   isBusy(): boolean {
-    return this.currentTurn !== null || this.pendingUserMessageCount > 0
+    return this.currentTurn !== null || this.pendingUserMessageCount > 0 || this.pendingMidTurnMsgs.length > 0
   }
 
   /** Funnel an arbitrary chat message into the *current* question
@@ -801,6 +873,7 @@ export class Session {
         feishu.bindSessionResume(this.sessionName, p.sessionId)
       }
       this.initCount++
+      log(`session "${this.sessionName}": SDK init#${this.initCount} pendingCount=${this.pendingUserMessageCount} midBuffer=${this.pendingMidTurnMsgs.length} currentTurn=${this.currentTurn ? 'yes' : 'no'} openingTurn=${this.openingTurn}`)
 
       // Boot init (initCount === 1) is claimed by `onUserMessage`'s
       // eager-open path — if a user message landed before the init
@@ -834,7 +907,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
         }
@@ -861,24 +946,30 @@ export class Session {
     })
     p.on('result', () => {
       this.accumulateResultStats()
-      // SDK-driven rotation: if any mid-turn user messages stacked up
-      // (the SDK is about to dequeue them into a fresh merged-batch
-      // turn), close the in-flight card with `📨 转交新卡` so the user
-      // sees the cut. The next `init` for that batch turn will open a
-      // new card whose top panel echoes those queued messages. No
-      // pending → natural ✅ close.
-      const suffix = this.pendingUserMessageCount > 0 ? '📨 转交新卡' : undefined
+      // Daemon-driven rotation: mid-turn msgs were buffered (not yet
+      // sent to SDK) — close the in-flight card with `📨 转交新卡` and
+      // drain the buffer in one shot. The drain writes each buffered
+      // msg to SDK stdin, which is the `priority="now"` wake the SDK
+      // polling loop needs (claude-code issue #39632) AND constitutes
+      // the input for the new batch turn. We open the new card here
+      // ourselves rather than waiting on init — the SDK init for this
+      // batch will fire shortly but `currentTurn` will already be set,
+      // so the init handler will return without double-opening.
+      const hasMidTurn = this.pendingMidTurnMsgs.length > 0
+      const suffix = hasMidTurn ? '📨 转交新卡' : undefined
+      log(`session "${this.sessionName}": SDK result midBuffer=${this.pendingMidTurnMsgs.length} suffix=${suffix ?? '<✅>'}`)
       void this.closeTurnCard(suffix)
       this.status = 'idle'
+      if (hasMidTurn) void this.drainMidTurnAndOpen()
     })
     p.on('exit', ({ code, signal, expected }: any) => {
       log(`session "${this.sessionName}": claude exited code=${code} signal=${signal} expected=${expected}`)
       this.proc = null
       this.currentTurn = null
       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'
@@ -932,8 +1023,39 @@ export class Session {
     return this.proc?.lastContextWindow ?? 200_000
   }
 
+  /** Drain `pendingMidTurnMsgs` to the SDK and open a fresh card for the
+   * resulting batch turn. Called from the `result` handler when buffered
+   * mid-turn messages need to start their own turn. The `sendUserText`
+   * 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. */
+  private async drainMidTurnAndOpen(): Promise<void> {
+    if (this.pendingMidTurnMsgs.length === 0) return
+    const batch = this.pendingMidTurnMsgs
+    this.pendingMidTurnMsgs = []
+    this.openingTurn = true
+    try {
+      for (const msg of batch) {
+        this.proc!.sendUserText(msg.wireText, msg.files)
+        if (msg.msgId) {
+          const rid = this.pendingReactionIds.get(msg.msgId) ?? ''
+          this.currentBatchReactionIds.set(msg.msgId, rid)
+          this.pendingReactionIds.delete(msg.msgId)
+        }
+      }
+      const last = batch[batch.length - 1]
+      const userOpenId = last?.userOpenId ?? this.lastUserOpenId
+      await this.openTurnCard(userOpenId, 'user_message')
+      this.status = 'working'
+    } finally {
+      this.openingTurn = false
+    }
+  }
+
   private async openTurnCard(userOpenId: string, trigger: 'user_message' | 'scheduled'): Promise<void> {
     const turn = ++this.turnCounter
+    log(`session "${this.sessionName}": openTurnCard turn=${turn} trigger=${trigger}`)
     const card = cards.mainConversationCard({
       sessionName: this.sessionName,
       turn,
@@ -954,11 +1076,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
@@ -972,6 +1093,8 @@ export class Session {
       thinkingText: '',
       toolCount: 0,
       toolByUseId: new Map(),
+      readBatches: new Map(),
+      openReadBatchI: null,
       assistantSegmentCount: 0,
       currentAssistantSegmentId: null,
       currentAssistantText: '',
@@ -987,28 +1110,42 @@ export class Session {
   // and mutate `this.currentTurn` underfoot.
   private appendAssistant(delta: string): void {
     if (!this.currentTurn) return
-    if (!this.currentTurn.currentAssistantSegmentId) {
-      const i = this.currentTurn.assistantSegmentCount++
+    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.
+      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 {
@@ -1039,7 +1176,37 @@ export class Session {
       this.currentTurn.currentAssistantSegmentId = null
       this.currentTurn.currentAssistantText = ''
     }
+    // Consecutive Read merger: if a Read run is already open, append to
+    // its batch and re-render the panel instead of inserting a new one.
+    // Any other tool name closes the run (handled below).
+    if (name === 'Read' && this.currentTurn.openReadBatchI !== null) {
+      const batchI = this.currentTurn.openReadBatchI
+      const batch = this.currentTurn.readBatches.get(batchI)!
+      const slot = batch.items.length
+      batch.items.push({ toolUseId, input, output: null, isError: false })
+      this.currentTurn.toolByUseId.set(toolUseId, { i: batchI, name, input, readBatchSlot: slot })
+      const el = cards.readBatchElement(batchI, batch.items)
+      void cardkit.replaceElement(this.currentTurn.cardId, cards.ELEMENTS.tool(batchI), el)
+      return
+    }
+    if (name !== 'Read') this.currentTurn.openReadBatchI = null
     const i = this.currentTurn.toolCount++
+    if (name === 'Read') {
+      // First Read of a potential run — render the existing single-tool
+      // panel (which keeps the full file-contents dump on completion). If
+      // a second Read arrives, completeTool/addTool will switch it to
+      // `readBatchElement`.
+      this.currentTurn.openReadBatchI = i
+      this.currentTurn.readBatches.set(i, {
+        items: [{ toolUseId, input, output: null, isError: false }],
+      })
+      this.currentTurn.toolByUseId.set(toolUseId, { i, name, input, readBatchSlot: 0 })
+      const el = cards.toolCallElement(i, name, input, null, '⏳', undefined, undefined)
+      void cardkit.addElement(this.currentTurn.cardId, el, {
+        type: 'insert_before', targetElementId: cards.ELEMENTS.footer,
+      })
+      return
+    }
     this.currentTurn.toolByUseId.set(toolUseId, { i, name, input })
     // AskUserQuestion is a client-side tool — daemon renders the choice
     // UI in-line and supplies the tool_result itself once the user
@@ -1116,6 +1283,22 @@ export class Session {
     // via toolCallElement would clobber the nice option-row layout
     // with a generic JSON dump. Bail out; the panel is done.
     if (meta.name === 'AskUserQuestion') return
+    // Read batch path: update this row's status in the shared batch then
+    // re-render. Single-item batches keep the original full-output panel
+    // (file-contents dump); 2+ items switch to the compact `Read · N 次`
+    // listing, which overwrites whatever was last drawn at this i.
+    if (meta.name === 'Read' && meta.readBatchSlot != null) {
+      const batch = this.currentTurn.readBatches.get(meta.i)
+      if (batch) {
+        const row = batch.items[meta.readBatchSlot]
+        if (row) { row.output = output; row.isError = isError }
+        const el = batch.items.length >= 2
+          ? cards.readBatchElement(meta.i, batch.items)
+          : cards.toolCallElement(meta.i, meta.name, meta.input, output, isError ? '❌' : '✅', meta.resolvedNote, undefined)
+        void cardkit.replaceElement(this.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
+      }
+      return
+    }
     // Update the local todo mirror BEFORE rendering so the just-
     // completed panel shows the new state too (e.g. a TaskCreate panel
     // already lists the task it just created).