@leviyuan/lodestar 0.1.10 → 0.1.12

package/README.md

@@ -16,10 +16,12 @@ AI 不是帮手,是倍率。它放大的不是体力,是你——你的直觉、
 
 ## 你会得到什么
 
-- 🌊 **真·流式卡片** — 飞书 Card Kit v1 streaming,Claude 一个 token 一个 token 地打在同一张卡片里,不是发一堆零碎消息刷屏。
+- 🌊 **真·流式卡片** — 飞书 Card Kit v1 streaming,Claude 一个 token 一个 token 地打在同一张卡片里,不是发一堆零碎消息刷屏。每张 turn 卡片 footer 自带 `✅ ⏱ 12.3s · 📊 47% · 💰 $0.45`,本轮上下文占用 / 实付成本一眼可见。
 - 🧠 **思考过程透明** — `thinking` 流式渲染,turn 结束后自动收起为可展开面板。每次工具调用也是一格折叠面板:折起是概述,展开看完整 input/output。
 - 🔐 **权限审批就地完成** — 需要授权的工具调用,**原地**升级为 🔐 等审批状态,三颗按钮 `允许 / 始终允许 / 拒绝` 直接嵌在面板里。不弹独立卡片,不破坏时序。点完按钮,后续 output 接在同一条线上继续往下走。
 - ❓ **结构化追问** — Claude 的 `AskUserQuestion` 在群里呈现为可点击选项行;不满意?直接在群里**打字回答**,daemon 会把自由文本当作 custom answer 发回去。多题串行,有进度计数和"已答 N 题"折叠历史。
+- ⌨️ **Type-ahead 不打断** — Claude 跑着你继续连珠炮,daemon 全部接住排队,排队消息打 `⏳` 反应,消化后清空(`stop` 取消则换 `❌`)。daemon 还会给每条合并消息前面注 `[#N]\n` 序号,模型一眼分得清"这是 5 条独立消息"而不是一个长字符串。turn 中途有新消息进来 + 下一个 tool_use 边界 → 旧卡 `📨 转交新卡` 收尾(既不是 done 也不是打断),新卡续写,边界跟语义对齐。
+- ⏰ **定时唤醒可见化** — Claude 用 `CronCreate` / `ScheduleWakeup` 自己安排周期任务,到点子进程在 idle 间隙 fire,daemon 检测"非首次 init"自动开一张 `⏰ 定时唤醒` 卡片承接;这种自发 turn 不响加急(凌晨 3 点自检不该震你)。
 - 📦 **状态面板一键唤出** — 发 `hi` 弹一张控制台:model、上下文占用 %、累计 tokens/cost、上一轮 delta、session id、订阅额度(5h / 7d 真实 utilization,直读 Anthropic 官方 OAuth Usage API,凭据走 `~/.claude/.credentials.json`,token 过期自动 refresh)、本机所有活跃项目并列展示。
 - 📎 **图片 / 文件双向互传** — 用户在群里发图/文件,Claude 通过消息里的 `[file: /abs/path]` 提示就能读;Claude 在回复里写 `[[send: /abs/path]]`,标记被剥离,文件以独立消息发回群里。出站路径走 realpath + 白名单校验,只允许工作目录、`/tmp/lodestar-*`、inbox 三块,`/etc`、`~/.ssh`、`~/.config` 即使被符号链接绕也拒绝。
 - 📲 **加急锁屏推送** — 需要你回答问题、需要你批准操作、一轮跑完了——三种关键时刻自动触发飞书"应用内加急",直接打穿勿扰、亮屏推送。卡片摘要会同步改写成具体待办("🔐 等审批: Bash · rm -rf …"、"❓ 待回答 3 题: …"),锁屏一瞥就知道发生了什么。
@@ -42,11 +44,12 @@ AI 不是帮手,是倍率。它放大的不是体力,是你——你的直觉、
 | 指令 | 行为 |
 | --- | --- |
 | `hi` | 未运行时启动;运行中弹一张**状态卡片** |
+| `stop` | 软打断当前 turn + 清空 type-ahead 排队;子进程保活,刚排队中的消息会被打 `CrossMark` 反应表示取消 |
 | `kill` | 优雅关闭 Claude 进程;记住 `sessionId`,下次 `restart` 还能 resume |
 | `restart` | 用上一次的 `sessionId` 重启会话(保留上下文) |
 | `clear` | 杀掉进程并启动一个全新 session(等价于 Claude Code 的 `/clear`) |
 
-> 这四个词被全局保留:在群里发 "hi" 当问候也会触发控制台卡片,不会到 Claude 那边。换来的是手机上单手打字的便利。
+> 这五个词被全局保留:在群里发 "hi" 当问候也会触发控制台卡片,不会到 Claude 那边。换来的是手机上单手打字的便利。
 
 ## 安装
 

package/daemon.ts

@@ -175,7 +175,7 @@ async function handleMessage(data: any): Promise<void> {
   }
 
   if (!text && !filePath) return
-  await session.onUserMessage(text || '(empty)', filePath ? [filePath] : [], userOpenId)
+  await session.onUserMessage(text || '(empty)', filePath ? [filePath] : [], userOpenId, msgId ?? '')
 }
 
 // ── Card action handler ────────────────────────────────────────────────

package/package.json

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

package/src/cards.ts

@@ -172,10 +172,18 @@ interface MainCardOpts {
   model?: string
   effort?: string
   userText: string
+  /** What started this turn. `'scheduled'` adds a top-of-card banner so
+   * the user can tell a cron-fired wakeup apart from one of their own
+   * messages — the user's message bubble is otherwise the only visual
+   * cue, and scheduled turns have no preceding bubble in the chat. */
+  kind?: 'user_message' | 'scheduled'
 }
 
 /** Initial card sent at the start of each turn. Streaming on. */
-export function mainConversationCard(_opts: MainCardOpts): object {
+export function mainConversationCard(opts: MainCardOpts): object {
+  const banner = opts.kind === 'scheduled'
+    ? [{ tag: 'markdown', content: '⏰ **定时任务触发** — Claude 在 idle 间隙被 CronCreate / ScheduleWakeup 唤醒' }]
+    : []
   return {
     schema: '2.0',
     config: {
@@ -194,6 +202,7 @@ export function mainConversationCard(_opts: MainCardOpts): object {
       // thinking element starts with a single space placeholder; the first
       // real append overwrites it.
       elements: [
+        ...banner,
         { tag: 'markdown', element_id: ELEMENTS.thinking, content: ' ' },
         { tag: 'markdown', element_id: ELEMENTS.footer, content: '⏳ working…' },
       ],

package/src/claude-process.ts

@@ -93,6 +93,12 @@ export class ClaudeProcess extends EventEmitter {
   lastResult: ClaudeResultMeta = {
     cost_usd: null, duration_ms: null, num_turns: null, usage: null,
   }
+  /** Context-window capacity of the model that ran the latest turn —
+   * lifted from `result.modelUsage[model].contextWindow` so we don't
+   * have to hardcode `[1m]` vs stock variants. 200K is the safe
+   * default if no result has landed yet (e.g. between spawn and the
+   * first turn close). */
+  lastContextWindow: number = 200_000
 
   constructor(opts: SpawnOpts) {
     super()
@@ -242,6 +248,19 @@ export class ClaudeProcess extends EventEmitter {
         num_turns: typeof msg.num_turns === 'number' ? msg.num_turns : null,
         usage: msg.usage ?? null,
       }
+      // modelUsage maps "<model id>" → { contextWindow, maxOutputTokens, … }.
+      // For mixed-model runs the SDK reports one entry per model used in
+      // the turn; we take the one matching `lastModel` (the assistant's
+      // latest model id) and fall back to any single entry if it's the
+      // only one — covers the common single-model case.
+      const mu = msg.modelUsage
+      if (mu && typeof mu === 'object') {
+        const entry = (this.lastModel && mu[this.lastModel])
+          || (Object.keys(mu).length === 1 ? mu[Object.keys(mu)[0]!] : null)
+        if (entry && typeof entry.contextWindow === 'number' && entry.contextWindow > 0) {
+          this.lastContextWindow = entry.contextWindow
+        }
+      }
       this.emit('result', msg)
       return
     }

package/src/feishu.ts

@@ -194,14 +194,34 @@ export async function sendCard(chatId: string, card: object): Promise<string | n
 }
 
 // ── Reactions ──────────────────────────────────────────────────────────
-export async function addReaction(messageId: string, emojiType: string): Promise<void> {
-  if (!messageId) return
+/** Add an emoji reaction. Returns the new reaction_id on success (needed
+ * to delete the reaction later via {@link deleteReaction}) or null on
+ * failure. Failures are logged and swallowed — reactions are non-load-
+ * bearing UX, not worth bubbling errors. */
+export async function addReaction(messageId: string, emojiType: string): Promise<string | null> {
+  if (!messageId) return null
   try {
-    await client.im.messageReaction.create({
+    const res: any = await client.im.messageReaction.create({
       path: { message_id: messageId },
       data: { reaction_type: { emoji_type: emojiType } },
     })
-  } catch (e) { log(`feishu: addReaction ${emojiType} on ${messageId} failed: ${e}`) }
+    return res?.data?.reaction_id ?? null
+  } catch (e) { log(`feishu: addReaction ${emojiType} on ${messageId} failed: ${e}`); return null }
+}
+
+/** Remove a previously-added reaction by its reaction_id (returned from
+ * {@link addReaction}). Used for the "queued → released" lifecycle: the
+ * OneSecond placed on arrival is *removed* when the daemon hands the
+ * message off to the SDK's batch / system-reminder pipeline, instead of
+ * stacking a second CheckMark on top — keeps the message's reaction row
+ * uncluttered. Quiet on failure. */
+export async function deleteReaction(messageId: string, reactionId: string): Promise<void> {
+  if (!messageId || !reactionId) return
+  try {
+    await client.im.messageReaction.delete({
+      path: { message_id: messageId, reaction_id: reactionId },
+    })
+  } catch (e) { log(`feishu: deleteReaction ${reactionId} on ${messageId} failed: ${e}`) }
 }
 
 // ── Urgent push ───────────────────────────────────────────────────────

package/src/session.ts

@@ -28,6 +28,12 @@ interface TurnState {
    * 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
+  /** What kicked off this turn. Only `'user_message'` turns fire the
+   * end-of-turn urgent_app push — scheduled / cron / loop wakeups
+   * finish on their own time and pinging the user would be noise,
+   * not signal. Ask / permission urgents inside the turn still fire
+   * regardless (those genuinely need attention even mid-schedule). */
+  trigger: 'user_message' | 'scheduled'
   userText: string
   thinkingText: string
   toolCount: number
@@ -92,6 +98,79 @@ export class Session {
 
   private proc: ClaudeProcess | null = null
   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`). */
+  private pendingUserMessageCount = 0
+  /** 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
+   * answer when N messages from possibly different users collapse into
+   * one turn, and "the most recent sender" is a defensible default for
+   * the single-user private-bot scenario this product targets. */
+  private lastUserOpenId = ''
+  /** Feishu message_ids of user messages that arrived while the daemon
+   * was busy (turn in flight or mid-open), mapped to the `reaction_id`
+   * of the `OneSecond` reaction placed at arrival. The reaction_id is
+   * what `deleteReaction` needs to *remove* the OneSecond once the
+   * message has been absorbed by the SDK (either system-reminder
+   * injection mid-turn or a merged-batch dequeue on next turn).
+   * User feedback (2026-05-15): replacing OneSecond with a second
+   * CheckMark stacked two emojis on the same row; cleaner UX is
+   * "queued → released" via removal, not "queued → done" via
+   * stacking. */
+  private pendingReactionIds = new Map<string, string>()
+  /** Snapshot of `pendingReactionIds` taken when the init handler
+   * claims a merged batch — these are the Feishu messages whose
+   * OneSecond reactions are the currently-open turn's responsibility
+   * 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
+   * user message draining or a CronCreate fire). Reset on stop/restart/exit
+   * since `init` re-fires after every spawn. */
+  private initCount = 0
+  /** Sync guard set before any `await` in the eager-open path of
+   * `onUserMessage`, cleared after `currentTurn` is set. Closes the race
+   * where an SDK-emitted `init` event lands during the eager open's
+   * Feishu API await — without this, the init handler would observe
+   * `currentTurn === null && queue empty` (we've already shifted) and
+   * incorrectly open a *second* scheduled card for the same user
+   * message. The flag tells the init handler "an eager open is already
+   * claiming the slot, stand down". */
+  private openingTurn = false
   private pendingPermissions = new Map<string, { toolUseId: string }>()
   /** Open AskUserQuestion tool calls — keyed by tool_use_id. The SDK
    * routes AskUserQuestion through the can_use_tool flow even under
@@ -228,6 +307,14 @@ export class Session {
     this.lastSessionId = proc.sessionId ?? this.lastSessionId
     this.proc = null
     this.currentTurn = null
+    this.pendingUserMessageCount = 0
+    this.lastUserOpenId = ''
+    this.pendingReactionIds = new Map()
+    this.currentBatchReactionIds = new Map()
+    this.wantsRotation = false
+    this.rotationBuffer = []
+    this.initCount = 0
+    this.openingTurn = false
     this.pendingPermissions.clear()
     this.status = 'stopped'
     await proc.kill()
@@ -242,6 +329,14 @@ export class Session {
       this.proc = null
     }
     this.currentTurn = null
+    this.pendingUserMessageCount = 0
+    this.lastUserOpenId = ''
+    this.pendingReactionIds = new Map()
+    this.currentBatchReactionIds = new Map()
+    this.wantsRotation = false
+    this.rotationBuffer = []
+    this.initCount = 0
+    this.openingTurn = false
     this.pendingPermissions.clear()
     if (resume && prevSessionId) {
       this.proc = new ClaudeProcess({
@@ -271,15 +366,18 @@ export class Session {
     }
   }
 
-  /** Run a bare-text control command (`hi`, `kill`, `restart`, `clear`).
+  /** Run a bare-text control command (`hi`, `stop`, `kill`, `restart`, `clear`).
    * Returns true if the command was consumed (don't forward to Claude).
    * Exact match, case-insensitive, ignores trailing whitespace.
    *
-   * Trade-off (user-confirmed 2026-05-15): the four words are reserved
+   * Trade-off (user-confirmed 2026-05-15): these words are reserved
    * globally — typing "hi" as a literal greeting will show the console
    * card instead of reaching Claude. The ergonomic win (no slash, no
    * shift key, one-handed phone use) outweighs the collision in this
-   * product's private-bot use case. */
+   * product's private-bot use case. `stop` was added 2026-05-15 once
+   * auto-interrupt on mid-turn user messages was removed (matching
+   * claude-code's native type-ahead behavior) — explicit barge-out
+   * needed a knob and `kill` (full subprocess teardown) is too heavy. */
   async runCommand(raw: string): Promise<boolean> {
     switch (raw.trim().toLowerCase()) {
       case 'hi':
@@ -289,6 +387,38 @@ export class Session {
         }
         await this.showConsole()
         return true
+      case 'stop':
+        // Soft barge-out: interrupt the current turn (if any) AND drop
+        // the pending-message count so a stack of type-ahead doesn't
+        // refire after the interrupt. Subprocess stays alive. Note: the
+        // SDK keeps its OWN internal queue of the user-text frames we
+        // already sendText'd — interrupt should also flush that side,
+        // 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) {
+          await feishu.sendText(this.chatId, '⚪ 当前没有正在执行的 turn')
+          return true
+        }
+        log(`session "${this.sessionName}": stop command — interrupt + drop count=${this.pendingUserMessageCount}`)
+        // 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
+        // mid-batch msgs get the same treatment.
+        for (const [msgId, rid] of [
+          ...this.pendingReactionIds.entries(),
+          ...this.currentBatchReactionIds.entries(),
+        ]) {
+          if (rid) void feishu.deleteReaction(msgId, rid)
+          void feishu.addReaction(msgId, 'CrossMark')
+        }
+        this.pendingUserMessageCount = 0
+        this.lastUserOpenId = ''
+        this.pendingReactionIds = new Map()
+        this.currentBatchReactionIds = new Map()
+        this.wantsRotation = false
+        this.interrupt()
+        return true
       case 'kill':
         await this.stop()
         return true
@@ -359,19 +489,70 @@ export class Session {
   }
 
   // ── Inbound from Feishu ────────────────────────────────────────────
-  async onUserMessage(text: string, files: string[] = [], userOpenId = ''): Promise<void> {
+  /** Inbound user message. Always writes to Claude's stdin immediately —
+   * the SDK queues internally if a turn is in flight (FIFO, exactly the
+   * type-ahead semantics of the native claude-code REPL). Card opening:
+   *   - First msg of session OR no turn in flight  → open card eagerly here
+   *   - Mid-flight msg                              → defer; the `init`
+   *     handler opens its card when the SDK actually starts the turn
+   * This is what lets a single subprocess host both user-typed turns and
+   * cron-fired wakeups without the daemon ever calling `sendInterrupt` —
+   * `kill`/`stop` are the only paths that interrupt now. */
+  async onUserMessage(text: string, files: string[] = [], userOpenId = '', msgId = ''): Promise<void> {
     if (!this.isRunning()) {
       const ok = await this.start()
       if (!ok) return
     }
-    if (this.currentTurn) {
-      log(`session "${this.sessionName}": new turn arriving mid-flight, interrupting`)
-      this.proc!.sendInterrupt()
-      await this.closeTurnCard('🛑 用户打断')
+    // Capture busy-state SYNC, before any state mutation — this decides
+    // whether the message will visibly queue (gets the OneSecond → later
+    // CheckMark lifecycle reactions on its Feishu chat message) or
+    // eager-open its own card (no reaction needed; the card itself is
+    // the acknowledgement).
+    const wasBusy = this.currentTurn !== null || this.openingTurn
+    this.pendingUserMessageCount++
+    this.lastUserOpenId = userOpenId
+    // When this msg will be merged with siblings into a multi-content
+    // user turn (i.e. the SDK queued it because the daemon was busy),
+    // prepend a `[#N]\n` ordinal so the model can tell the merged
+    // blocks apart. Without it the harness renders multi-content text
+    // back-to-back ("1"+"2"+"5"+"56"+"89" → "1255689") and the model
+    // can't see the original boundaries — surfaced 2026-05-16 when a
+    // 5-msg accumulator test got mis-summed as one big number.
+    const wireText = wasBusy ? `[#${this.pendingUserMessageCount}]\n${text}` : 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, '')
+      void (async () => {
+        const rid = await feishu.addReaction(msgId, 'OneSecond')
+        if (rid && this.pendingReactionIds.has(msgId)) {
+          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
+      // 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).
+      this.openingTurn = true
+      this.pendingUserMessageCount--
+      try {
+        await this.openTurnCard(text, userOpenId, 'user_message')
+        this.status = 'working'
+      } finally {
+        this.openingTurn = false
+      }
     }
-    await this.openTurnCard(text, userOpenId)
-    this.proc!.sendUserText(text, files)
-    this.status = 'working'
   }
 
   async onPermissionDecision(
@@ -420,6 +601,15 @@ export class Session {
     return this.pendingAsks.size > 0
   }
 
+  /** True iff a turn is currently running (or a queued user message is
+   * waiting for its turn to start). daemon uses this to drop a hourglass
+   * reaction on inbound messages — without it the user sees no visible
+   * 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
+  }
+
   /** Funnel an arbitrary chat message into the *current* question
    * of the oldest pending ask as a `customText` answer. Multi-
    * question semantics: from the user's perspective, the chat
@@ -575,6 +765,58 @@ export class Session {
         this.lastSessionId = p.sessionId
         feishu.bindSessionResume(this.sessionName, p.sessionId)
       }
+      this.initCount++
+
+      // The boot init (initCount === 1) only happens once per spawn and
+      // is claimed by whichever user message gets processed first — that
+      // message's card is opened eagerly in `onUserMessage`, so the boot
+      // init itself opens nothing. EXCEPTION: if a user message landed
+      // before the boot init (rare race during start()), the queue has
+      // an entry — drain it here.
+      //
+      // Subsequent inits (initCount >= 2) mark the start of an SDK-
+      // initiated turn — either the SDK draining its internal type-ahead
+      // queue (we'll have an entry in `pendingUserMessages` mirroring
+      // it) or a CronCreate / ScheduleWakeup fire (queue empty). The
+      // `currentTurn` / `openingTurn` checks guard the race where
+      // `onUserMessage` already eager-opened (or is mid-open) for the
+      // same user message and the SDK emitted an init#≥2 we don't need
+      // to act on. The init handler ALSO claims `openingTurn` for its
+      // own async open so a user message landing during the open
+      // doesn't spawn a duplicate card.
+      if (this.currentTurn || this.openingTurn) return
+      // `pendingUserMessageCount > 0` ⇒ SDK is about to fire an init for a
+      // merged batch of one-or-more user messages we already sendText'd
+      // (the eager-open path didn't claim them because a turn was still
+      // running at the time). Claim the ENTIRE count here — the SDK
+      // collapses them into ONE turn, so only one card opens; any further
+      // messages that arrive after this point will start a fresh count
+      // and a fresh batch.
+      const isUserBatch = this.pendingUserMessageCount > 0
+      const isScheduledFire = !isUserBatch && this.initCount > 1
+      if (!isUserBatch && !isScheduledFire) return
+      const userOpenId = isUserBatch ? this.lastUserOpenId : ''
+      if (isUserBatch) {
+        this.pendingUserMessageCount = 0
+        // Inherit the queued reaction_ids — this turn is collectively
+        // responsible for releasing their OneSecond reactions when it
+        // closes (via deleteReaction in closeTurnCard).
+        this.currentBatchReactionIds = this.pendingReactionIds
+        this.pendingReactionIds = new Map()
+      }
+      this.openingTurn = true
+      void (async () => {
+        try {
+          await this.openTurnCard(
+            isUserBatch ? '' : '⏰ 定时唤醒',
+            userOpenId,
+            isUserBatch ? 'user_message' : 'scheduled',
+          )
+          this.status = 'working'
+        } finally {
+          this.openingTurn = false
+        }
+      })()
     })
     p.on('assistant_text', ({ text }: { text: string }) => {
       this.appendAssistant(text)
@@ -604,6 +846,13 @@ export class Session {
       log(`session "${this.sessionName}": claude exited code=${code} signal=${signal} expected=${expected}`)
       this.proc = null
       this.currentTurn = null
+      this.pendingUserMessageCount = 0
+      this.lastUserOpenId = ''
+      this.pendingReactionIds = new Map()
+      this.currentBatchReactionIds = new Map()
+      this.wantsRotation = false
+      this.initCount = 0
+      this.openingTurn = false
       this.status = 'stopped'
       if (!expected && code !== 0 && signal !== 'SIGTERM') {
         void feishu.sendText(this.chatId, `⚠️ Claude 异常退出 (code=${code}, signal=${signal})。回复任意消息将重新启动。`)
@@ -642,13 +891,24 @@ export class Session {
     return this.lastTurnDelta?.inputTokens ?? 0
   }
 
-  private async openTurnCard(userText: string, userOpenId: string): Promise<void> {
+  /** Context-window capacity for the model the subprocess is currently
+   * running — sourced authoritatively from `result.modelUsage[model]
+   * .contextWindow` captured by ClaudeProcess on each turn close, so
+   * the daemon doesn't have to enumerate model ids itself (was the
+   * source of a "560K/200K" display bug — model id didn't include
+   * `[1m]` so the hardcoded fallback won). */
+  private contextWindowMax(): number {
+    return this.proc?.lastContextWindow ?? 200_000
+  }
+
+  private async openTurnCard(userText: string, userOpenId: string, trigger: 'user_message' | 'scheduled'): Promise<void> {
     const turn = ++this.turnCounter
     const card = cards.mainConversationCard({
       sessionName: this.sessionName,
       turn,
       effort: 'max',
       userText,
+      kind: trigger,
     })
     const messageId = await feishu.sendCard(this.chatId, card)
     if (!messageId) { log(`session "${this.sessionName}": openTurnCard sendCard failed`); return }
@@ -659,6 +919,7 @@ export class Session {
       cardId,
       messageId,
       userOpenId,
+      trigger,
       userText,
       thinkingText: '',
       toolCount: 0,
@@ -676,8 +937,44 @@ 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) return
+    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.currentAssistantSegmentId) {
       const i = this.currentTurn.assistantSegmentCount++
       const segId = cards.ELEMENTS.assistant(i)
@@ -703,7 +1000,12 @@ export class Session {
   }
 
   private appendThinking(delta: string): void {
-    if (!this.currentTurn) return
+    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.
     this.currentTurn.thinkingText += delta
     cardkit.streamTextThrottled(
       this.currentTurn.cardId,
@@ -721,7 +1023,16 @@ export class Session {
   }
 
   private addTool(toolUseId: string, name: string, input: any): void {
-    if (!this.currentTurn) return
+    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
+    }
     // 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.
@@ -1007,7 +1318,28 @@ export class Session {
       await cardkit.replaceElement(cardId, cards.ELEMENTS.thinking, cards.thinkingCollapsedPanel(thinkingText))
     }
     const sendNote = sendPaths.length ? ` · 📎 ${sendPaths.length}` : ''
-    const footer = `⏱ ${elapsed}s${suffix ? ' · ' + suffix : ''}${sendNote} · ✅ done`
+    // State marker leads the footer (✅ for natural completion, or 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.
+    let metrics = ''
+    if (!suffix) {
+      const ctxTokens = this.currentContextTokens()
+      const ctxMax = this.contextWindowMax()
+      if (ctxTokens > 0 && ctxMax > 0) {
+        const pct = Math.round((ctxTokens / ctxMax) * 100)
+        metrics += ` · 📊 ${pct}%`
+      }
+      const cost = this.lastTurnDelta?.costUsd ?? 0
+      if (cost > 0) metrics += ` · 💰 $${cost.toFixed(3)}`
+    }
+    const footer = `${stateMark} ⏱ ${elapsed}s${metrics}${sendNote}`
     await cardkit.streamText(cardId, cards.ELEMENTS.footer, footer)
     // Final chat-list preview: clean finish shows "⏱ Xs · NK tokens";
     // interrupted shows the suffix instead (no usage event landed).
@@ -1023,12 +1355,44 @@ export class Session {
 
     // 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) {
+    // completion), when we don't know who to ping, and when the turn
+    // wasn't kicked off by the user typing a message — scheduled /
+    // cron / loop wakeups finish on their own and shouldn't ping the
+    // phone. Fire-and-forget; urgent_app failures are non-fatal and
+    // already logged in feishu.ts.
+    if (!suffix && turn.trigger === 'user_message' && turn.userOpenId && turn.messageId) {
       void feishu.urgentApp(turn.messageId, [turn.userOpenId])
     }
 
+    // Release the OneSecond reactions on every queued Feishu message
+    // this turn was responsible for. Two buckets:
+    //   1. `currentBatchReactionIds` — msgs the init handler explicitly
+    //      claimed (SDK dequeued them as a merged next-turn batch).
+    //   2. `pendingReactionIds` — msgs whose fate is invisible to the
+    //      daemon: the SDK either dequeued them as part of the
+    //      JUST-CLOSED turn OR injected them mid-turn as
+    //      `<system-reminder>` and silently removed them from the
+    //      queue (common when the current turn had tool calls).
+    //      Without visibility into queue-operation events the daemon
+    //      can't tell which; the safe default is "the prior turn just
+    //      ended, so the msg is at least *acknowledged* now —
+    //      release the OneSecond and let it stop saying 'queued',
+    //      instead of leaving it stuck permanently."
+    //      For merged-batch follow-ups, this releases slightly early
+    //      (before the merged turn actually runs), which is an
+    //      acceptable trade vs. msgs stuck under OneSecond forever.
+    const releaseEntries = [
+      ...this.currentBatchReactionIds.entries(),
+      ...this.pendingReactionIds.entries(),
+    ]
+    if (releaseEntries.length > 0) {
+      for (const [msgId, rid] of releaseEntries) {
+        if (rid) void feishu.deleteReaction(msgId, rid)
+      }
+      this.currentBatchReactionIds = new Map()
+      this.pendingReactionIds = new Map()
+    }
+
     // 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