@leviyuan/lodestar 0.1.6 → 0.1.7

package/daemon.ts

@@ -32,7 +32,19 @@ try {
 mkdirSync(dirname(PID_FILE), { recursive: true })
 writeFileSync(PID_FILE, String(process.pid))
 
-const cleanup = () => { try { unlinkSync(PID_FILE) } catch {} }
+const cleanup = () => {
+  // Snapshot which sessions are still alive so the next boot can
+  // revive them — only the ones still running at shutdown, NOT
+  // anything the user already `kill`-ed (those are absent from the
+  // sessions Map filter below and stay stopped after restart).
+  try {
+    const alive: string[] = []
+    for (const s of sessions.values()) if (s.isRunning()) alive.push(s.sessionName)
+    feishu.writeAliveMarker(alive)
+    if (alive.length > 0) log(`alive marker: [${alive.join(', ')}]`)
+  } catch (e) { log(`alive marker write failed: ${e}`) }
+  try { unlinkSync(PID_FILE) } catch {}
+}
 process.on('exit', cleanup)
 process.on('SIGTERM', () => { log('SIGTERM'); cleanup(); process.exit(0) })
 process.on('SIGINT',  () => { log('SIGINT');  cleanup(); process.exit(0) })
@@ -51,6 +63,33 @@ function sessionFor(chatId: string, sessionName: string): Session {
   return s
 }
 
+/** Auto-restart any session that was alive when the previous daemon
+ * went down. Driven by the marker file written in `cleanup` — that
+ * file ONLY lists sessions that were running, so anything the user
+ * had explicitly `kill`-ed before shutdown is intentionally absent
+ * and stays stopped. Each revived session is `restart(true)`-ed so
+ * the SDK gets `--resume <claudeSessionId>` and the in-flight
+ * conversation continues without the user typing anything. */
+async function reviveAliveSessions(): Promise<void> {
+  const names = feishu.readAndConsumeAliveMarker()
+  if (names.length === 0) return
+  log(`revive: ${names.length} session(s) marked alive on shutdown: ${names.join(', ')}`)
+  for (const sessionName of names) {
+    const chatId = feishu.chatIdForSession(sessionName)
+    if (!chatId) {
+      log(`revive: no chatId binding for "${sessionName}", skip`)
+      continue
+    }
+    const session = sessionFor(chatId, sessionName)
+    try {
+      await session.restart(true)
+      log(`revive: spawned "${sessionName}" (chat ${chatId.slice(0, 8)}…)`)
+    } catch (e) {
+      log(`revive: restart "${sessionName}" failed: ${e}`)
+    }
+  }
+}
+
 // ── Inbound message handler ─────────────────────────────────────────────
 const STALE_THRESHOLD_MS = 10_000
 const seenMessageIds = new Set<string>()
@@ -225,6 +264,11 @@ async function boot(): Promise<void> {
   })
   ws.start({ eventDispatcher: dispatcher })
   log(`lodestar-daemon: WS started, watching ${feishu.chatNameCache.size} groups`)
+
+  // 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.
+  await reviveAliveSessions()
 }
 
 boot().catch(e => { log(`boot fatal: ${e}`); process.exit(1) })

package/package.json

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

package/src/cards.ts

@@ -332,121 +332,177 @@ export interface AskQuestion {
  * the first question only and a text-only listing for the rest (an
  * acceptable limitation — these are rare in practice and we can lift
  * it once the UX is validated). */
-/** Final-state info for an AskUserQuestion panel. Mutually-exclusive
- * branches inside: either the user picked one of the SDK-provided
- * options (`optionIdx`), or they typed a free-form answer
- * (`customText`). When both are absent the panel is still pending. */
+/** Per-question final-state. Mutually-exclusive branches: option pick
+ * vs. free-form custom text. */
 export interface AskAnswered {
   optionIdx?: number
   customText?: string
   user?: string
 }
 
+/** State the panel renders against. `currentIdx` undefined → terminal
+ * (every question answered). Otherwise it's the question currently on
+ * screen; everything in `answered` is history. */
+export interface AskState {
+  currentIdx?: number
+  answered: Map<number, AskAnswered>
+}
+
+/** Render one question's body — either as clickable interactive_container
+ * rows (when picked === undefined) or as plain markdown summary
+ * (already-answered, shown in history-panel context). */
+function renderAskQuestionBody(
+  q: AskQuestion,
+  toolUseId: string,
+  questionIdx: number,
+  picked?: AskAnswered,
+): any[] {
+  const els: any[] = []
+  els.push({ tag: 'markdown', content: `**${q.question}**` })
+  for (let oi = 0; oi < q.options.length; oi++) {
+    const opt = q.options[oi]
+    const desc = opt.description ? `  ·  ${opt.description}` : ''
+    if (picked) {
+      const isPicked = picked.optionIdx === oi
+      els.push({
+        tag: 'markdown',
+        content: isPicked
+          ? `✅ **${opt.label}**${desc}`
+          : `~~◯ ${opt.label}${desc}~~`,
+      })
+    } else {
+      els.push({
+        tag: 'interactive_container',
+        background_style: 'default',
+        has_border: true,
+        corner_radius: '6px',
+        padding: '8px 12px',
+        margin: '4px 0px 4px 0px',
+        behaviors: [{
+          type: 'callback',
+          value: {
+            kind: 'ask',
+            tool_use_id: toolUseId,
+            question_idx: questionIdx,
+            option_idx: oi,
+          },
+        }],
+        elements: [{ tag: 'markdown', content: `**${opt.label}**${desc}` }],
+      })
+    }
+  }
+  if (picked?.customText) {
+    els.push({ tag: 'markdown', content: `✏️ **自定义回答**：${picked.customText}` })
+  }
+  return els
+}
+
+/** Folded "📜 已答 N 题" panel — option C from the multi-question
+ * design discussion. Returns null when there's no history to show. */
+function renderAskHistoryPanel(
+  questions: AskQuestion[],
+  answered: Map<number, AskAnswered>,
+): any | null {
+  if (answered.size === 0) return null
+  const lines: string[] = []
+  const sortedIdx = [...answered.keys()].sort((a, b) => a - b)
+  for (const idx of sortedIdx) {
+    const q = questions[idx]
+    const a = answered.get(idx)!
+    const tag = q?.header ?? `Q${idx + 1}`
+    const value = a.customText
+      ?? (a.optionIdx !== undefined ? q?.options[a.optionIdx]?.label : undefined)
+      ?? '?'
+    lines.push(`- ✅ **${tag}**：${value}`)
+  }
+  return {
+    tag: 'collapsible_panel',
+    header: {
+      title: { tag: 'plain_text', content: `📜 已答 ${answered.size} 题（点击展开）` },
+    },
+    expanded: false,
+    elements: [{ tag: 'markdown', content: lines.join('\n') }],
+  }
+}
+
 export function askUserQuestionElement(
   i: number,
   toolUseId: string,
   questions: AskQuestion[],
   status: '🤔' | '✅' | '❌' = '🤔',
-  answered?: AskAnswered,
+  state?: AskState,
 ): object {
-  const primary = questions[0]
-  const isAnswered = !!answered && (answered.optionIdx !== undefined || !!answered.customText)
-  const headerTag = primary?.header ? ` · ${primary.header}` : ''
-  let headerText: string
-  if (isAnswered) {
-    // Surface the picked answer in the header so a collapsed panel
-    // still tells the reader what was chosen.
-    const picked = answered!.customText
-      ?? (answered!.optionIdx !== undefined ? primary?.options[answered!.optionIdx]?.label : undefined)
-      ?? '?'
-    headerText = `${status} 已回答${headerTag}：${picked}`
-  } else {
-    headerText = `${status} 🤔 AskUserQuestion${headerTag}`
-  }
+  const total = questions.length
+  const answered = state?.answered ?? new Map<number, AskAnswered>()
+  const currentIdx = state?.currentIdx
+  const isTerminal = currentIdx === undefined && answered.size > 0
   const bodyElements: any[] = []
-  if (primary) {
-    bodyElements.push({ tag: 'markdown', content: `**${primary.question}**` })
-    // One row per option. While pending, each row is a full-width
-    // interactive_container so the entire row is the click target.
-    // Once answered, rows degrade to plain markdown (Feishu has no
-    // generic non-interactive container — `div` doesn't exist, it
-    // rejects the PUT with code 300121).
-    for (let optIdx = 0; optIdx < primary.options.length; optIdx++) {
-      const opt = primary.options[optIdx]
-      const isPicked = answered?.optionIdx === optIdx
-      const desc = opt.description ? `  ·  ${opt.description}` : ''
-      if (!isAnswered) {
-        bodyElements.push({
-          tag: 'interactive_container',
-          background_style: 'default',
-          has_border: true,
-          corner_radius: '6px',
-          padding: '8px 12px',
-          margin: '4px 0px 4px 0px',
-          behaviors: [{
-            type: 'callback',
-            value: {
-              kind: 'ask',
-              tool_use_id: toolUseId,
-              question_idx: 0,
-              option_idx: optIdx,
-            },
-          }],
-          elements: [{ tag: 'markdown', content: `**${opt.label}**${desc}` }],
-        })
-      } else if (isPicked) {
-        bodyElements.push({
-          tag: 'markdown',
-          content: `✅ **${opt.label}**${desc}`,
-        })
-      } else {
-        bodyElements.push({
-          tag: 'markdown',
-          content: `~~◯ ${opt.label}${desc}~~`,
-        })
-      }
+  let headerText: string
+
+  if (isTerminal) {
+    // All questions resolved — collapse and roll up answers in header
+    // + body. Single-question case keeps the old "已回答：xxx" header
+    // style; multi-question gets a "已回答 · N 题" count and a flat
+    // listing of Q→A pairs in the body.
+    if (total === 1) {
+      const q0 = questions[0]
+      const a0 = answered.get(0)
+      const value = a0?.customText
+        ?? (a0?.optionIdx !== undefined ? q0?.options[a0.optionIdx]?.label : undefined)
+        ?? '?'
+      const headerTag = q0?.header ? ` · ${q0.header}` : ''
+      headerText = `${status} 已回答${headerTag}：${value}`
+    } else {
+      headerText = `${status} 已回答 · ${total} 题`
     }
-    // Custom-answer hint (pending state only). Feishu schema 2.0
-    // doesn't actually have `form` / `input` elements — `tag: form`
-    // gets rejected with code 300315. Instead we route custom
-    // answers through a plain chat message: daemon.handleMessage
-    // detects a pending ask and forwards the next inbound text as
-    // the answer, no new turn opened. This is also more Feishu-
-    // native: the chat input is right there, no extra widget.
-    if (!isAnswered) {
+    const sortedIdx = [...answered.keys()].sort((a, b) => a - b)
+    for (const idx of sortedIdx) {
+      const q = questions[idx]
+      const a = answered.get(idx)!
+      const tag = q?.header ?? `Q${idx + 1}`
+      const value = a.customText
+        ?? (a.optionIdx !== undefined ? q?.options[a.optionIdx]?.label : undefined)
+        ?? '?'
       bodyElements.push({
         tag: 'markdown',
-        content: '_💬 也可以直接在群里回复你的答案（裸词命令 `hi`/`kill`/`restart`/`clear` 仍然优先）_',
+        content: `**${tag}**：${value}`,
       })
-    } else if (answered?.customText) {
+    }
+    const lastUser = [...answered.values()].reverse().find(a => a.user)?.user
+    if (lastUser) {
       bodyElements.push({
         tag: 'markdown',
-        content: `✏️ **自定义回答**：${answered.customText}`,
+        content: `\n*— 由 ${lastUser} 回答*`,
       })
     }
-  }
-  // Secondary questions (rare): text-only listing. TODO when needed.
-  for (let qi = 1; qi < questions.length; qi++) {
-    const q = questions[qi]
-    const opts = q.options.map(o => `  - ${o.label}${o.description ? ` — ${o.description}` : ''}`).join('\n')
+  } else if (currentIdx !== undefined && questions[currentIdx]) {
+    // In-progress: render current question + folded history above.
+    // Progress tag in header lets the user see how many are left,
+    // even with the history panel folded.
+    const q = questions[currentIdx]
+    const headerTag = q.header ? ` · ${q.header}` : ''
+    const progress = total > 1 ? ` (${currentIdx + 1}/${total})` : ''
+    headerText = `${status} 🤔 AskUserQuestion${headerTag}${progress}`
+    const history = renderAskHistoryPanel(questions, answered)
+    if (history) bodyElements.push(history)
+    bodyElements.push(...renderAskQuestionBody(q, toolUseId, currentIdx))
     bodyElements.push({
       tag: 'markdown',
-      content: `\n---\n**(其他问题 #${qi + 1}, 暂未支持回答)** ${q.question}\n${opts}`,
-    })
-  }
-  if (isAnswered && answered?.user) {
-    bodyElements.push({
-      tag: 'markdown',
-      content: `\n*— 由 ${answered.user} 回答*`,
+      content: '_💬 也可以直接在群里回复你的答案（裸词命令 `hi`/`kill`/`restart`/`clear` 仍然优先）_',
     })
+  } else {
+    // Defensive fallback — neither answered nor a valid currentIdx.
+    headerText = `${status} 🤔 AskUserQuestion`
+    if (questions[0]) {
+      bodyElements.push({ tag: 'markdown', content: `**${questions[0].question}**` })
+    }
   }
+
   return {
     tag: 'collapsible_panel',
     element_id: ELEMENTS.tool(i),
     header: { title: { tag: 'plain_text', content: headerText } },
-    // Collapse once answered: header carries the picked answer, body
-    // is just history at that point.
-    expanded: !isAnswered,
+    expanded: !isTerminal,
     elements: bodyElements,
   }
 }

package/src/feishu.ts

@@ -8,11 +8,11 @@
 
 import * as lark from '@larksuiteoapi/node-sdk'
 import { execSync } from 'node:child_process'
-import { mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { basename, extname, join } from 'node:path'
 import { config } from './config'
-import { DATA_DIR, INBOX_DIR, SESSION_CHAT_MAP_FILE, SESSION_RESUME_MAP_FILE } from './paths'
+import { ALIVE_MARKER_FILE, DATA_DIR, INBOX_DIR, SESSION_CHAT_MAP_FILE, SESSION_RESUME_MAP_FILE } from './paths'
 import { log } from './log'
 
 const APP_ID = config.feishu.app_id
@@ -106,6 +106,36 @@ export function getSessionResume(sessionName: string): string | null {
   return lastSessionIdByName.get(sessionName) ?? null
 }
 
+// ── Alive-on-shutdown marker ──────────────────────────────────────────
+// Persists the list of session names that were still running when the
+// daemon went down. Next boot reads + unlinks the file and auto-spawns
+// (via session.restart(true)) only those — sessions that were already
+// `stop`ped before shutdown are deliberately NOT in this list, so they
+// stay stopped after restart.
+
+export function writeAliveMarker(sessionNames: string[]): void {
+  try {
+    writeFileSync(ALIVE_MARKER_FILE, JSON.stringify(sessionNames, null, 2))
+  } catch (e) { log(`feishu: write alive marker failed: ${e}`) }
+}
+
+/** Read + unlink in one shot — marker is single-use: revival should
+ * happen exactly once per boot, not re-run on every subsequent crash
+ * loop where systemd might keep re-launching us. */
+export function readAndConsumeAliveMarker(): string[] {
+  if (!existsSync(ALIVE_MARKER_FILE)) return []
+  try {
+    const raw = readFileSync(ALIVE_MARKER_FILE, 'utf8')
+    try { unlinkSync(ALIVE_MARKER_FILE) } catch {}
+    const data = JSON.parse(raw)
+    return Array.isArray(data) ? data.filter((x: unknown): x is string => typeof x === 'string') : []
+  } catch (e) {
+    log(`feishu: read alive marker failed: ${e}`)
+    try { unlinkSync(ALIVE_MARKER_FILE) } catch {}
+    return []
+  }
+}
+
 export function chatIdForSession(sessionName: string): string | null {
   const preferred = preferredChatForSession.get(sessionName)
   if (preferred && chatNameCache.get(preferred) === sessionName) return preferred

package/src/paths.ts

@@ -40,4 +40,10 @@ export const PID_FILE = join(DATA_DIR, 'daemon.pid')
 export const LOG_FILE = join(DATA_DIR, 'daemon.log')
 export const SESSION_CHAT_MAP_FILE = join(DATA_DIR, 'session-chat-map.json')
 export const SESSION_RESUME_MAP_FILE = join(DATA_DIR, 'session-resume-map.json')
+/** Marker file written at shutdown listing the session names that
+ * were still alive. The next daemon boot reads it (and unlinks it)
+ * to auto-revive those sessions via `restart(true)` — bridges the
+ * gap between systemctl-restart killing every child Claude and
+ * 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')

package/src/session.ts

@@ -89,12 +89,19 @@ export class Session {
     questions: cards.AskQuestion[]
     i: number
     requestId?: string
-    deferredAnswer?: {
-      questionIdx: number
-      optionIdx?: number
-      customText?: string
-      user: string
-    }
+    /** 累计答案 — key 是 question 原文 (SDK 把这条 record 格式
+     * 化进 tool_result), value 是用户选的 option label 或自定
+     * 义文字。全部 question 都答完时一并塞进 updatedInput.answers
+     * 发回 SDK。 */
+    answers: Record<string, string>
+    /** 已答详情 (按 question idx 索引)，用来给历史面板和 terminal
+     * 状态画选中态。answers 同步累计，但这里多保留 customText /
+     * optionIdx 字段以便 UI 区分两种回答路径。 */
+    answered: Map<number, cards.AskAnswered>
+    /** 当前展示的 question idx。undefined 表示全部答完 (terminal)
+     * —— 这时若 requestId 已就位则 finalize；否则等 renderPermission
+     * 一来立即 finalize。 */
+    currentIdx?: number
   }>()
   private turnCounter = 0
   // Last seen sessionId — preserved across `kill`/`stop` so a later
@@ -340,11 +347,11 @@ export class Session {
     return this.pendingAsks.size > 0
   }
 
-  /** Funnel an arbitrary chat message into the oldest pending ask as
-   * a `customText` answer. Falls back to a normal turn if for some
-   * reason there's nothing pending (defensive — handleMessage's gate
-   * should prevent that). Picks the first entry by Map insertion
-   * order, which is the earliest unanswered ask. */
+  /** 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
+   * input always answers whatever question is on screen right now
+   * (`pending.currentIdx`), and a new question slides in after. */
   async onAskMessageAnswer(text: string, user: string): Promise<void> {
     const firstEntry = this.pendingAsks.entries().next()
     if (firstEntry.done) {
@@ -352,102 +359,121 @@ export class Session {
       await this.onUserMessage(text)
       return
     }
-    const [toolUseId, _pending] = firstEntry.value
-    await this.onAskCustomAnswer(toolUseId, 0, text, user)
+    const [toolUseId, pending] = firstEntry.value
+    if (pending.currentIdx === undefined) {
+      log(`session "${this.sessionName}": pending ask ${toolUseId} already terminal — ignoring message`)
+      return
+    }
+    await this.onAskCustomAnswer(toolUseId, pending.currentIdx, text, user)
   }
 
-  /** Click handler for an AskUserQuestion option button. Dispatches
-   * to `resolveAsk` if can_use_tool has already arrived, otherwise
-   * parks the click on the pendingAsk record for renderPermission
-   * to drain. */
+  /** Click handler for an option button. The click must target the
+   * question currently on screen (`pending.currentIdx`); a stale
+   * click (e.g. user clicked an older render before it swapped in
+   * the next question) is logged and dropped — better than double-
+   * answering. */
   async onAskAnswer(toolUseId: string, questionIdx: number, optionIdx: number, user: string): Promise<void> {
     const pending = this.pendingAsks.get(toolUseId)
     if (!pending) { log(`session "${this.sessionName}": stray ask answer for ${toolUseId}`); return }
-    if (pending.requestId) {
-      this.resolveAsk(toolUseId, pending.requestId, { questionIdx, optionIdx, user })
-    } else {
-      pending.deferredAnswer = { questionIdx, optionIdx, user }
-      log(`session "${this.sessionName}": ask answer deferred for ${toolUseId} (no requestId yet)`)
+    if (questionIdx !== pending.currentIdx) {
+      log(`session "${this.sessionName}": stale ask click q=${questionIdx} current=${pending.currentIdx}`)
+      return
     }
+    this.advanceAsk(toolUseId, { optionIdx, user })
   }
 
-  /** Form-submit handler for the custom-answer input on an
-   * AskUserQuestion panel. Same dispatch pattern as `onAskAnswer`,
-   * just routes a free-form string into `resolveAsk` instead of an
-   * option index. Empty/whitespace input is ignored (no answer
-   * sent, panel stays pending). */
+  /** Custom-text branch. Same staleness rule as onAskAnswer; empty
+   * input is silently ignored (panel stays pending). */
   async onAskCustomAnswer(toolUseId: string, questionIdx: number, customText: string, user: string): Promise<void> {
     const pending = this.pendingAsks.get(toolUseId)
     if (!pending) { log(`session "${this.sessionName}": stray ask custom for ${toolUseId}`); return }
     const trimmed = (customText ?? '').trim()
     if (!trimmed) { log(`session "${this.sessionName}": empty custom answer, ignoring`); return }
-    if (pending.requestId) {
-      this.resolveAsk(toolUseId, pending.requestId, { questionIdx, customText: trimmed, user })
-    } else {
-      pending.deferredAnswer = { questionIdx, customText: trimmed, user }
-      log(`session "${this.sessionName}": ask custom deferred for ${toolUseId} (no requestId yet)`)
+    if (questionIdx !== pending.currentIdx) {
+      log(`session "${this.sessionName}": stale ask custom q=${questionIdx} current=${pending.currentIdx}`)
+      return
     }
+    this.advanceAsk(toolUseId, { customText: trimmed, user })
   }
 
-  /** Settle an AskUserQuestion: emit the permission allow with the
-   * picked option OR custom text folded into `updatedInput.answers`
-   * (this is the shape the SDK reads to synthesise the tool_result
-   * string), repaint the panel ✅, drop bookkeeping. Single source
-   * of truth — option-click, custom-submit, and the deferred drain
-   * all go through here. */
-  private resolveAsk(
+  /** Record an answer for the current question, advance the state
+   * machine, repaint. If every question is now answered, finalize
+   * (or defer the finalize until can_use_tool lands — the race is
+   * handled by renderPermission). */
+  private advanceAsk(
     toolUseId: string,
-    requestId: string,
-    answer: { questionIdx: number; optionIdx?: number; customText?: string; user: string },
+    answer: { optionIdx?: number; customText?: string; user: string },
   ): void {
     const pending = this.pendingAsks.get(toolUseId)
-    if (!pending) return
-    const q = pending.questions[answer.questionIdx]
-    if (!q) {
-      log(`session "${this.sessionName}": ask answer out of range q=${answer.questionIdx}`)
-      return
-    }
-    // Determine the literal string that will become the SDK's
-    // `answers` value for this question — custom wins if both are
-    // somehow set (shouldn't happen, but defensive).
-    let answerValue: string
-    if (answer.customText) {
-      answerValue = answer.customText
+    if (!pending || pending.currentIdx === undefined) return
+    const cur = pending.currentIdx
+    const q = pending.questions[cur]
+    if (!q) { log(`session "${this.sessionName}": advanceAsk currentIdx=${cur} out of range`); return }
+    // Resolve the literal answer value — custom text wins if both set.
+    let value: string
+    if (answer.customText !== undefined) {
+      value = answer.customText
     } else if (answer.optionIdx !== undefined) {
       const opt = q.options?.[answer.optionIdx]
-      if (!opt) {
-        log(`session "${this.sessionName}": ask option out of range o=${answer.optionIdx}`)
-        return
-      }
-      answerValue = opt.label
+      if (!opt) { log(`session "${this.sessionName}": advanceAsk option ${answer.optionIdx} out of range`); return }
+      value = opt.label
     } else {
-      log(`session "${this.sessionName}": resolveAsk called with neither optionIdx nor customText`)
+      log(`session "${this.sessionName}": advanceAsk with neither customText nor optionIdx`)
       return
     }
-    const turn = this.currentTurn
-    const meta = turn?.toolByUseId.get(toolUseId)
-    const originalInput = meta?.input ?? {}
-    // SDK keys the answer record by the question's text — confirmed
-    // by the v0.1.2 jsonl trace (empty record formatted to "User has
-    // answered your questions: .").
-    const answers: Record<string, string> = { [q.question]: answerValue }
-    this.proc?.sendPermissionResponse(requestId, 'allow', {
-      updatedInput: { ...originalInput, answers },
+    pending.answers[q.question] = value
+    pending.answered.set(cur, {
+      optionIdx: answer.optionIdx,
+      customText: answer.customText,
+      user: answer.user,
     })
-    this.pendingPermissions.delete(requestId)
-    this.pendingAsks.delete(toolUseId)
+    // Next unanswered idx — linear from cur+1. Implementation
+    // always moves forward; we don't currently let users revisit a
+    // previous question (would need richer UI affordance for that).
+    const total = pending.questions.length
+    let nextIdx: number | undefined = undefined
+    for (let i = cur + 1; i < total; i++) {
+      if (!pending.answered.has(i)) { nextIdx = i; break }
+    }
+    pending.currentIdx = nextIdx
 
+    const turn = this.currentTurn
+    const meta = turn?.toolByUseId.get(toolUseId)
     if (turn && meta) {
-      meta.output = JSON.stringify({ answers })
-      meta.isError = false
-      const el = cards.askUserQuestionElement(meta.i, toolUseId, pending.questions, '✅', {
-        optionIdx: answer.optionIdx,
-        customText: answer.customText,
-        user: answer.user || '匿名',
-      })
+      const el = cards.askUserQuestionElement(
+        meta.i, toolUseId, pending.questions,
+        nextIdx === undefined ? '✅' : '🤔',
+        { currentIdx: nextIdx, answered: pending.answered },
+      )
       void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
     }
 
+    if (nextIdx === undefined) {
+      // All done. Finalize iff we have the permission request id;
+      // otherwise renderPermission will pick it up when it arrives.
+      if (pending.requestId) this.finalizeAsk(toolUseId)
+      else log(`session "${this.sessionName}": ask ${toolUseId} all answered, waiting for can_use_tool`)
+    }
+  }
+
+  /** Settle a fully-answered AskUserQuestion: emit the SDK allow
+   * with the full `answers` record folded into `updatedInput`,
+   * drop bookkeeping, restore status. The terminal panel paint was
+   * already done by the final advanceAsk; this is just protocol. */
+  private finalizeAsk(toolUseId: string): void {
+    const pending = this.pendingAsks.get(toolUseId)
+    if (!pending || !pending.requestId) return
+    const meta = this.currentTurn?.toolByUseId.get(toolUseId)
+    const originalInput = meta?.input ?? {}
+    this.proc?.sendPermissionResponse(pending.requestId, 'allow', {
+      updatedInput: { ...originalInput, answers: pending.answers },
+    })
+    this.pendingPermissions.delete(pending.requestId)
+    if (meta) {
+      meta.output = JSON.stringify({ answers: pending.answers })
+      meta.isError = false
+    }
+    this.pendingAsks.delete(toolUseId)
     if (this.pendingPermissions.size === 0 && this.status === 'awaiting_permission') {
       this.status = 'working'
     }
@@ -634,8 +660,19 @@ export class Session {
     // don't match the actual N options).
     if (name === 'AskUserQuestion') {
       const questions = Array.isArray(input?.questions) ? input.questions as cards.AskQuestion[] : []
-      this.pendingAsks.set(toolUseId, { questions, i })
-      const el = cards.askUserQuestionElement(i, toolUseId, questions, '🤔')
+      const startIdx = questions.length > 0 ? 0 : undefined
+      const answered = new Map<number, cards.AskAnswered>()
+      this.pendingAsks.set(toolUseId, {
+        questions,
+        i,
+        answers: {},
+        answered,
+        currentIdx: startIdx,
+      })
+      const el = cards.askUserQuestionElement(i, toolUseId, questions, '🤔', {
+        currentIdx: startIdx,
+        answered,
+      })
       void cardkit.addElement(this.currentTurn.cardId, el, {
         type: 'insert_before',
         targetElementId: cards.ELEMENTS.footer,
@@ -799,24 +836,16 @@ export class Session {
     if (meta.name === 'AskUserQuestion') {
       const ask = this.pendingAsks.get(toolUseId)
       if (!ask) {
-        // Defensive: addTool should have populated pendingAsks. If it
-        // didn't, fall back to a denial so Claude doesn't hang.
         log(`session "${this.sessionName}": AskUserQuestion ${toolUseId} missing pendingAsk — deny`)
         this.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'no pending ask' })
         return
       }
       ask.requestId = req.request_id
       this.pendingPermissions.set(req.request_id, { toolUseId })
-      if (ask.deferredAnswer) {
-        const d = ask.deferredAnswer
-        ask.deferredAnswer = undefined
-        this.resolveAsk(toolUseId, req.request_id, {
-          questionIdx: d.questionIdx,
-          optionIdx: d.optionIdx,
-          customText: d.customText,
-          user: d.user,
-        })
-      }
+      // Fast-clicker race: the user may have answered every question
+      // while we were still waiting for can_use_tool to arrive. If so,
+      // advanceAsk parked the all-done state and we drain it now.
+      if (ask.currentIdx === undefined) this.finalizeAsk(toolUseId)
       return
     }
     this.status = 'awaiting_permission'